From 4aceec16025bce611593bd3b27e40a081b6f88af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Wed, 30 Sep 2026 18:50:07 -0300
Subject: [PATCH 01/74] Fix file tree edge fades at scroll boundaries (#665)

---
 crates/ui/src/files/tree.rs | 66 +++++++++++++++++++++++++++++++++----
 1 file changed, 60 insertions(+), 6 deletions(-)

diff --git a/crates/ui/src/files/tree.rs b/crates/ui/src/files/tree.rs
index 1711f78e4f..a6c92749a9 100644
--- a/crates/ui/src/files/tree.rs
+++ b/crates/ui/src/files/tree.rs
@@ -114,6 +114,13 @@ fn tree_rail_geometry(
     Some((metrics, bounds.top()))
 }
 
+fn tree_scroll_overflow(list: &gpui::ListState) -> (bool, bool) {
+    // ListState reports a negative offset as content scrolls upward.
+    let offset = -f32::from(list.scroll_px_offset_for_scrollbar().y);
+    let max = f32::from(list.max_offset_for_scrollbar().y);
+    (offset > 0.5, offset < max - 0.5)
+}
+
 /// The file tree's share of the shared floating rail: it owns no scroll
 /// handle, so geometry comes from the list state's own accessors and drags
 /// land through the list state's scrollbar offset setter.
@@ -211,11 +218,7 @@ impl FilesSurface {
                         .min_h_0()
                         .with_sizing_behavior(ListSizingBehavior::Auto),
                 )
-                .fade_overflow_y_with(move |_| {
-                    let offset = f32::from(overflow.scroll_px_offset_for_scrollbar().y);
-                    let max = f32::from(overflow.max_offset_for_scrollbar().y);
-                    (offset > 0.5, offset < max - 0.5)
-                })
+                .fade_overflow_y_with(move |_| tree_scroll_overflow(&overflow))
             })
             .children(scrollbar)
             .into_any_element()
@@ -531,7 +534,7 @@ fn status_row(
 mod tests {
     use super::super::model::VisibleTreeRow;
     use super::*;
-    use gpui::{ListAlignment, ListOffset, ListState};
+    use gpui::{AppContext, ListAlignment, ListOffset, ListState};
 
     fn rows(paths: &[&str]) -> Vec<VisibleTreeRow> {
         paths
@@ -544,6 +547,57 @@ mod tests {
             .collect()
     }
 
+    #[gpui::test]
+    fn tree_fades_only_at_edges_with_hidden_rows(cx: &mut gpui::TestAppContext) {
+        struct TestTree(ListState);
+        impl gpui::Render for TestTree {
+            fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+                list(self.0.clone(), |_, _, _| {
+                    div().h(px(TREE_ROW_HEIGHT)).w_full().into_any_element()
+                })
+                .w_full()
+                .h_full()
+            }
+        }
+
+        let cx = cx.add_empty_window();
+        let state = ListState::new(10, ListAlignment::Top, px(0.0)).measure_all();
+        let view = cx.update(|_, cx| cx.new(|_| TestTree(state.clone())));
+        let mut draw = |height| {
+            cx.draw(
+                gpui::point(px(0.0), px(0.0)),
+                gpui::size(px(200.0), px(height)),
+                |_, _| view.clone().into_any_element(),
+            );
+        };
+
+        draw(100.0);
+        assert_eq!(state.max_offset_for_scrollbar().y, px(170.0));
+        assert_eq!(tree_scroll_overflow(&state), (false, true));
+
+        state.set_offset_from_scrollbar(gpui::point(px(0.0), px(-85.0)));
+        draw(100.0);
+        assert_eq!(tree_scroll_overflow(&state), (true, true));
+
+        state.scroll_to_reveal_item(9);
+        draw(100.0);
+        assert_eq!(tree_scroll_overflow(&state), (true, false));
+        let last = state.bounds_for_item(9).unwrap();
+        let viewport = state.viewport_bounds();
+        assert!(last.top() >= viewport.top() && last.bottom() <= viewport.bottom());
+
+        // A taller viewport or removed rows clamps scrolling during layout;
+        // the fade must disappear in that same frame.
+        draw(400.0);
+        assert_eq!(tree_scroll_overflow(&state), (false, false));
+        draw(100.0);
+        state.scroll_to_reveal_item(9);
+        draw(100.0);
+        state.splice(2..10, 0);
+        draw(100.0);
+        assert_eq!(tree_scroll_overflow(&state), (false, false));
+    }
+
     #[test]
     fn directory_load_keeps_the_viewport_on_the_same_path() {
         let old = rows(&["a", "src", "z"]);

From 6641095b5b5d1bd682da58b4939334f03dbf3bc6 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Wed, 30 Sep 2026 15:01:28 -0700
Subject: [PATCH 02/74] Fix Markdown drag selection across table columns (#681)

---
 crates/ui/src/markdown/render.rs | 255 ++++++++++++++++++++++++++++++-
 1 file changed, 248 insertions(+), 7 deletions(-)

diff --git a/crates/ui/src/markdown/render.rs b/crates/ui/src/markdown/render.rs
index 9dced2fb3b..f92e30bc9a 100644
--- a/crates/ui/src/markdown/render.rs
+++ b/crates/ui/src/markdown/render.rs
@@ -1509,18 +1509,27 @@ pub fn selection_surface_reset(prefix: String) -> impl IntoElement {
 }
 
 /// `(element index, byte offset)` for a window position: the registered
-/// element whose vertical band contains it, else the nearest by vertical
-/// distance (a drag past the gutter or between blocks clamps sensibly).
+/// element whose bounds contain it, else the nearest horizontally within the
+/// closest vertical band. Vertical distance stays primary so dragging beyond
+/// a short paragraph's edge keeps selecting that line. Horizontal distance
+/// distinguishes side-by-side text such as table cells and their padding.
 fn registry_point(position: gpui::Point<gpui::Pixels>) -> Option<(usize, usize)> {
     REGISTRY.with(|r| {
         let reg = r.borrow();
         let anchor = super::selection::anchor_key().unwrap_or_default();
-        let mut best: Option<(usize, f32)> = None;
+        let mut best: Option<(usize, f32, f32)> = None;
         for (ei, entry) in reg.iter().enumerate() {
             if selection_scope(&entry.key) != selection_scope(&anchor) {
                 continue;
             }
             let b = entry.layout.bounds();
+            let dx = if position.x < b.left() {
+                f32::from(b.left() - position.x)
+            } else if position.x > b.right() {
+                f32::from(position.x - b.right())
+            } else {
+                0.0
+            };
             let dy = if position.y < b.top() {
                 f32::from(b.top() - position.y)
             } else if position.y > b.bottom() {
@@ -1528,14 +1537,14 @@ fn registry_point(position: gpui::Point<gpui::Pixels>) -> Option<(usize, usize)>
             } else {
                 0.0
             };
-            if best.is_none_or(|(_, d)| dy < d) {
-                best = Some((ei, dy));
+            if best.is_none_or(|(_, best_dy, best_dx)| (dy, dx) < (best_dy, best_dx)) {
+                best = Some((ei, dy, dx));
             }
-            if dy == 0.0 {
+            if dy == 0.0 && dx == 0.0 {
                 break;
             }
         }
-        let (ei, _) = best?;
+        let (ei, _, _) = best?;
         let ix = match reg[ei].layout.index_for_position(position) {
             Ok(ix) | Err(ix) => ix,
         };
@@ -2559,6 +2568,238 @@ mod tests {
         }
     }
 
+    struct MarkdownSelectionHarness;
+
+    impl Render for MarkdownSelectionHarness {
+        fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+            let theme = Theme::of(cx).clone();
+            let source = "# Heading\n\nBefore **bold** and *italic* with `code`.\n\n\
+                | Agent | Branch | Target |\n\
+                | --- | --- | --- |\n\
+                | linux | `lab-linux` | Linux jobs, ten minutes or less. This long target wraps across several visual lines in its cell. |\n\
+                | macos | `lab-macos` | macOS jobs |\n\n\
+                > A **quoted** paragraph.\n\n\
+                - A list with `inline code`.\n\n\
+                After the table.";
+            div()
+                .size_full()
+                .child(selection_frame_reset())
+                .child(render_tree(
+                    &parse_full(source),
+                    &RenderOptions::settled("markdown-selection-test".into()),
+                    &theme,
+                    window,
+                    &|_| None,
+                ))
+        }
+    }
+
+    fn selection_key_for_text(text: &str) -> String {
+        REGISTRY.with(|registry| {
+            registry
+                .borrow()
+                .iter()
+                .find(|entry| entry.text.as_ref() == text)
+                .unwrap_or_else(|| panic!("missing painted text: {text}"))
+                .key
+                .to_string()
+        })
+    }
+
+    fn selection_position(key: &str, ix: usize) -> gpui::Point<gpui::Pixels> {
+        let (_, layout, _) = selection_test_snapshot(key);
+        layout.position_for_index(ix).expect("text position")
+            + point(px(0.1), layout.line_height() / 2.0)
+    }
+
+    #[gpui::test]
+    fn markdown_drag_tracks_each_table_column_and_wrapped_cell(cx: &mut TestAppContext) {
+        let _selection = super::super::selection::test_state_lock();
+        cx.update(|cx| cx.set_global(Theme::dark()));
+        let (_, cx) = cx.add_window_view(|_, _| MarkdownSelectionHarness);
+        cx.simulate_resize(size(px(560.0), px(800.0)));
+        cx.update(|window, cx| {
+            window.refresh();
+            window.draw(cx).clear();
+        });
+
+        let target = "Linux jobs, ten minutes or less. This long target wraps across several visual lines in its cell.";
+        let target_key = selection_key_for_text(target);
+        assert!(selection_test_bounds(&target_key).size.height > px(MD_LINE_HEIGHT));
+        // Every column must track the pointer, including later visual lines
+        // in a wrapped cell, and a drag must contract and reverse normally.
+        for text in ["linux", "lab-linux", target, "lab-macos", "macOS jobs"] {
+            let key = selection_key_for_text(text);
+            let start = selection_position(&key, 1);
+            let end = selection_position(&key, text.len() - 1);
+            cx.simulate_event(gpui::MouseDownEvent {
+                button: gpui::MouseButton::Left,
+                position: start,
+                click_count: 1,
+                ..Default::default()
+            });
+            for (position, expected) in [
+                (end, &text[1..text.len() - 1]),
+                (start, ""),
+                (selection_position(&key, 0), &text[..1]),
+            ] {
+                cx.simulate_event(gpui::MouseMoveEvent {
+                    position,
+                    pressed_button: Some(gpui::MouseButton::Left),
+                    ..Default::default()
+                });
+                assert_eq!(
+                    super::super::selection::selected_text().unwrap_or_default(),
+                    expected,
+                    "drag inside {text}"
+                );
+            }
+            cx.simulate_event(gpui::MouseUpEvent {
+                button: gpui::MouseButton::Left,
+                position: selection_position(&key, 0),
+                ..Default::default()
+            });
+            super::super::selection::clear_if_owner(&key);
+        }
+    }
+
+    #[gpui::test]
+    fn markdown_drag_clamps_in_cell_padding_and_outside_paragraphs(cx: &mut TestAppContext) {
+        let _selection = super::super::selection::test_state_lock();
+        cx.update(|cx| cx.set_global(Theme::dark()));
+        let (_, cx) = cx.add_window_view(|_, _| MarkdownSelectionHarness);
+        cx.simulate_resize(size(px(560.0), px(800.0)));
+        cx.update(|window, cx| {
+            window.refresh();
+            window.draw(cx).clear();
+        });
+        for text in [
+            "linux",
+            "lab-linux",
+            "lab-macos",
+            "macOS jobs",
+            "A quoted paragraph.",
+        ] {
+            let key = selection_key_for_text(text);
+            let bounds = selection_test_bounds(&key);
+            // Padding belongs to the nearest cell, even if an earlier column
+            // has text at the same y. Each side clamps to that cell's endpoint.
+            for (position, expected) in [
+                (
+                    point(
+                        bounds.right() + px(4.0),
+                        selection_position(&key, text.len()).y,
+                    ),
+                    &text[1..],
+                ),
+                (
+                    point(bounds.left() - px(4.0), selection_position(&key, 0).y),
+                    &text[..1],
+                ),
+            ] {
+                cx.simulate_event(gpui::MouseDownEvent {
+                    button: gpui::MouseButton::Left,
+                    position: selection_position(&key, 1),
+                    click_count: 1,
+                    ..Default::default()
+                });
+                cx.simulate_event(gpui::MouseMoveEvent {
+                    position,
+                    pressed_button: Some(gpui::MouseButton::Left),
+                    ..Default::default()
+                });
+                let selected = super::super::selection::selected_text();
+                super::super::selection::end_active_drag();
+                super::super::selection::clear_if_owner(&key);
+                assert_eq!(selected.as_deref(), Some(expected), "padding beside {text}");
+            }
+        }
+        // A far-right drag on a short heading must stay on that line instead
+        // of jumping to a wider paragraph below (Euclidean nearest is wrong).
+        let key = selection_key_for_text("Heading");
+        cx.simulate_event(gpui::MouseDownEvent {
+            button: gpui::MouseButton::Left,
+            position: selection_position(&key, 0),
+            click_count: 1,
+            ..Default::default()
+        });
+        cx.simulate_event(gpui::MouseMoveEvent {
+            position: selection_position(&key, 0) + point(px(1000.0), px(0.0)),
+            pressed_button: Some(gpui::MouseButton::Left),
+            ..Default::default()
+        });
+        let selected = super::super::selection::selected_text();
+        super::super::selection::end_active_drag();
+        super::super::selection::clear_if_owner(&key);
+        assert_eq!(selected.as_deref(), Some("Heading"));
+    }
+
+    #[gpui::test]
+    fn markdown_drag_crosses_cells_and_formatted_blocks_in_document_order(cx: &mut TestAppContext) {
+        let _selection = super::super::selection::test_state_lock();
+        cx.update(|cx| cx.set_global(Theme::dark()));
+        let (_, cx) = cx.add_window_view(|_, _| MarkdownSelectionHarness);
+        cx.simulate_resize(size(px(560.0), px(800.0)));
+        cx.update(|window, cx| {
+            window.refresh();
+            window.draw(cx).clear();
+        });
+        let branch_key = selection_key_for_text("lab-linux");
+        let target = "Linux jobs, ten minutes or less. This long target wraps across several visual lines in its cell.";
+        let target_key = selection_key_for_text(target);
+        let macos_key = selection_key_for_text("lab-macos");
+        let before_key = selection_key_for_text("Before bold and italic with code.");
+        let after_key = selection_key_for_text("After the table.");
+        for (anchor_key, anchor_ix, head_key, head_ix, expected) in [
+            (
+                &branch_key,
+                4,
+                &target_key,
+                10,
+                "linux\nLinux jobs".to_string(),
+            ),
+            (
+                &target_key,
+                10,
+                &branch_key,
+                4,
+                "linux\nLinux jobs".to_string(),
+            ),
+            (
+                &branch_key,
+                4,
+                &macos_key,
+                3,
+                format!("linux\n{target}\nmacos\nlab"),
+            ),
+            (
+                &before_key,
+                0,
+                &after_key,
+                16,
+                format!(
+                    "Before bold and italic with code.\nAgent\nBranch\nTarget\nlinux\nlab-linux\n{target}\nmacos\nlab-macos\nmacOS jobs\nA quoted paragraph.\nA list with inline code.\nAfter the table."
+                ),
+            ),
+        ] {
+            cx.simulate_event(gpui::MouseDownEvent {
+                button: gpui::MouseButton::Left,
+                position: selection_position(anchor_key, anchor_ix),
+                click_count: 1,
+                ..Default::default()
+            });
+            cx.simulate_event(gpui::MouseMoveEvent {
+                position: selection_position(head_key, head_ix),
+                pressed_button: Some(gpui::MouseButton::Left),
+                ..Default::default()
+            });
+            let selected = super::super::selection::selected_text();
+            super::super::selection::end_active_drag();
+            super::super::selection::clear_if_owner(anchor_key);
+            assert_eq!(selected.as_deref(), Some(expected.as_str()));
+        }
+    }
+
     #[gpui::test]
     fn code_block_lines_participate_in_text_selection(cx: &mut TestAppContext) {
         let _selection = super::super::selection::test_state_lock();

From 0fab030fcacae566356d319679f4a5e13b823c1e Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Wed, 30 Sep 2026 15:52:04 -0700
Subject: [PATCH 03/74] Question panel: paint an opaque background (#669)

* Question panel: paint an opaque background so the transcript doesn't show through

* Question panel: frost it like the composer pill instead of a new opaque fill

The panel stands in for the composer pill but was the only input surface
painting a translucent fill without the backdrop blur, so the transcript
showed through unblurred. Wrap it in frost::frosted and use the pill's
composer_surface_bg, matching the pill and queue tray on every material
and wallpaper tint, and drop the separate input_solid_bg token.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/composer.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index ee8eaba92e..fcb7c0c18b 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -8692,16 +8692,20 @@ impl Composer {
                 })
         });
 
-        div()
+        // Stands in for the composer pill, so it is the same frosted surface:
+        // without the backdrop blur the translucent fill let the transcript
+        // show through unblurred.
+        let panel = div()
             .id("question-panel")
             .track_focus(&self.wizard_focus)
             .on_key_down(cx.listener(|this, event: &KeyDownEvent, window, cx| {
                 this.on_wizard_key(event, window, cx)
             }))
+            .occlude()
             .rounded(px(COMPOSER_RADIUS))
             .border_1()
             .border_color(theme.border)
-            .bg(theme.input_glass_bg())
+            .bg(theme.composer_surface_bg())
             .when(!theme.is_frost(), |el| el.shadow_lg())
             .flex()
             .flex_col()
@@ -8806,8 +8810,8 @@ impl Composer {
                             .when(!can_advance, |el| el.opacity(0.4))
                             .on_click(cx.listener(|this, _, _, cx| this.wizard_advance(cx))),
                     ),
-            )
-            .into_any_element()
+            );
+        crate::frost::frosted(COMPOSER_RADIUS, crate::frost::MENU_BLUR, panel).into_any_element()
     }
 
     fn render_send_button(

From 651aa7a95d5a65ce45406b7ad29d3975f7b8df0b Mon Sep 17 00:00:00 2001
From: sen <102120097+senxd@users.noreply.github.com>
Date: Wed, 30 Sep 2026 23:54:27 +0100
Subject: [PATCH 04/74] Providers: update Homebrew-installed CLIs with brew
 (#661)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A provider CLI installed as a Homebrew cask or formula
(Caskroom/<token>/<version>/… or Cellar/<token>/<version>/{bin,libexec}/…)
gets an Update action that runs `<prefix>/bin/brew upgrade --cask|--formula
<token>` as argv. The brew binary is the one in the prefix that owns the CLI.
The installable version comes from formulae.brew.sh and `brew info`. When an
upstream release is newer than Homebrew's, the row names the brew command.
Update still runs it, but idle auto-update waits for Homebrew. npm globals
under Homebrew's Node keep their own updaters. Detection is macOS/Linux only.

Co-Authored-By: grahamwinter <wwinterr@pm.me>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/harness_updates.rs | 555 +++++++++++++++++++++++++--
 crates/ui/src/settings/harnesses.rs  |  16 +-
 2 files changed, 538 insertions(+), 33 deletions(-)

diff --git a/crates/engine/src/harness_updates.rs b/crates/engine/src/harness_updates.rs
index 24557fe2d2..92a90613c6 100644
--- a/crates/engine/src/harness_updates.rs
+++ b/crates/engine/src/harness_updates.rs
@@ -72,6 +72,33 @@ struct CodexStandaloneInstall {
     target: String,
 }
 
+/// A Homebrew cask or formula that owns the resolved CLI. The token is taken
+/// from the `Caskroom` or `Cellar` directory, never from installer output.
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct HomebrewPackage {
+    brew: PathBuf,
+    cask: bool,
+    token: String,
+}
+
+impl HomebrewPackage {
+    fn upgrade_command(&self) -> String {
+        if self.cask {
+            format!("brew upgrade --cask {}", self.token)
+        } else {
+            format!("brew upgrade --formula {}", self.token)
+        }
+    }
+
+    fn upgrade_args(&self) -> Vec<&str> {
+        if self.cask {
+            vec!["upgrade", "--cask", self.token.as_str()]
+        } else {
+            vec!["upgrade", "--formula", self.token.as_str()]
+        }
+    }
+}
+
 enum UpdatePlan {
     Command {
         executable: PathBuf,
@@ -79,6 +106,7 @@ enum UpdatePlan {
     },
     AntigravityArchive,
     CodexStandalone(CodexStandaloneInstall),
+    Homebrew(HomebrewPackage),
 }
 
 struct ReleaseAsset {
@@ -195,9 +223,8 @@ fn provider(id: HarnessId) -> ProviderSpec {
                 repository: "openai/codex",
                 tag_prefix: "rust-v",
             },
-            // Codex has no self-update command. npm/Homebrew remain manual;
-            // `update_plan` separately recognizes the official standalone
-            // release layout, where an atomic in-place update is unambiguous.
+            // npm stays manual. Homebrew casks and formulae are upgraded with
+            // `brew upgrade`; the official standalone layout is updated in place.
             update_args: None,
             manual_command: "Update Codex with its original installer or package manager",
         },
@@ -255,6 +282,9 @@ fn provider(id: HarnessId) -> ProviderSpec {
 }
 
 fn update_plan(harness: HarnessId, executable: &Path) -> Result<UpdatePlan, String> {
+    if let Some(package) = homebrew_package(executable) {
+        return Ok(UpdatePlan::Homebrew(package));
+    }
     if harness == HarnessId::ClaudeCode && claude_package_manager_command(executable).is_some() {
         return Err("update Claude Code with its package manager".into());
     }
@@ -534,6 +564,13 @@ impl HarnessUpdateCoordinator {
             && status.policy == HarnessUpdatePolicy::AutoWhenIdle
             && status.phase == HarnessUpdatePhase::Available
             && status.can_apply
+            // The Update button can still run `brew upgrade` when Homebrew has
+            // not published the upstream release. Automatic installs wait until
+            // Homebrew itself reports a newer package.
+            && !status
+                .manual_command
+                .as_deref()
+                .is_some_and(unpublished_homebrew_upgrade)
     }
 
     fn schedule_automatic_update(&self, harness: HarnessId) {
@@ -609,6 +646,11 @@ impl HarnessUpdateCoordinator {
         if self.settle_if_unmonitored(harness) {
             return Ok(());
         }
+        if let Some(package) = homebrew_package(&executable) {
+            return self
+                .finish_homebrew_check(harness, &executable, installed, source, package)
+                .await;
+        }
         let latest = match spec.latest {
             LatestSource::AntigravityAcp => self
                 .antigravity_acp_latest()
@@ -750,6 +792,148 @@ impl HarnessUpdateCoordinator {
         Ok(())
     }
 
+    /// Homebrew owns this binary, so the installable release is the cask or
+    /// formula version. An upstream release that Homebrew has not published yet
+    /// still gets an Update button — it runs `brew upgrade` — but is not
+    /// installed automatically.
+    async fn finish_homebrew_check(
+        &self,
+        harness: HarnessId,
+        executable: &Path,
+        installed: String,
+        source: HarnessInstallSource,
+        package: HomebrewPackage,
+    ) -> Result<(), String> {
+        let brew_version = match self.homebrew_latest(&package).await {
+            Ok(version) => version,
+            Err(error) => {
+                return self.fail_check_with_installed(harness, installed, source, error);
+            }
+        };
+        let upstream = self
+            .upstream_version(harness, &installed)
+            .await
+            .ok()
+            .filter(|version| version_is_newer(version, &installed));
+        let brew_newer = version_is_newer(&brew_version, &installed);
+        let (latest, note) = if brew_newer {
+            (brew_version, None)
+        } else if let Some(upstream) =
+            upstream.filter(|version| version_is_newer(version, &brew_version))
+        {
+            (upstream, Some(package.upgrade_command()))
+        } else {
+            (brew_version, None)
+        };
+        if self.settle_if_unmonitored(harness) {
+            return Ok(());
+        }
+        let dismissed = lock(&self.inner.prefs)
+            .dismissed_versions
+            .get(&harness)
+            .is_some_and(|dismissed| dismissed == &latest);
+        let available = version_is_newer(&latest, &installed) && !dismissed;
+        let manual_command = if available { note } else { None };
+        let channel = (harness == HarnessId::ClaudeCode)
+            .then(|| claude_cask_channel(executable))
+            .flatten()
+            .map(str::to_owned);
+        let registry = self.inner.registry.clone();
+        self.mutate(harness, |status| {
+            status.installed_version = Some(installed);
+            status.latest_version = Some(latest);
+            if channel.is_some() {
+                status.channel = channel.clone();
+            }
+            status.source = source;
+            status.can_apply = true;
+            status.manual_command = manual_command;
+            status.phase = if status.policy == HarnessUpdatePolicy::Off
+                || !registry.enabled_set().contains(&harness)
+            {
+                HarnessUpdatePhase::Dormant
+            } else if available {
+                HarnessUpdatePhase::Available
+            } else {
+                HarnessUpdatePhase::Current
+            };
+            status.checked_at = Some(now_ms());
+            status.error = None;
+        });
+        Ok(())
+    }
+
+    async fn homebrew_latest(&self, package: &HomebrewPackage) -> Result<String, String> {
+        let api = self.homebrew_api_version(package).await;
+        let local = self.homebrew_local_version(package).await;
+        match (api, local) {
+            (Ok(api), Ok(local)) => Ok(if version_is_newer(&local, &api) {
+                local
+            } else {
+                api
+            }),
+            (Ok(version), Err(_)) | (Err(_), Ok(version)) => Ok(version),
+            (Err(api), Err(local)) => Err(format!("{api}; {local}")),
+        }
+    }
+
+    async fn homebrew_api_version(&self, package: &HomebrewPackage) -> Result<String, String> {
+        let kind = if package.cask { "cask" } else { "formula" };
+        let url = format!(
+            "https://formulae.brew.sh/api/{kind}/{}.json",
+            homebrew_url_component(&package.token)
+        );
+        let response = self
+            .inner
+            .client
+            .get(url)
+            .send()
+            .await
+            .map_err(|error| format!("Homebrew version check failed: {error}"))?
+            .error_for_status()
+            .map_err(|error| format!("Homebrew version check failed: {error}"))?;
+        let body = response
+            .text()
+            .await
+            .map_err(|error| format!("Homebrew version response was invalid: {error}"))?;
+        parse_homebrew_version(package.cask, &body)
+    }
+
+    async fn homebrew_local_version(&self, package: &HomebrewPackage) -> Result<String, String> {
+        let brew = resolve_brew(&package.brew)?;
+        let token = package.token.as_str();
+        let args: &[&str] = if package.cask {
+            &["info", "--cask", "--json=v2", token]
+        } else {
+            &["info", "--formula", "--json=v2", token]
+        };
+        // Don't refresh taps on a probe. `brew upgrade` does that when applying.
+        let output = run_command_output_env(&brew, args, COMMAND_TIMEOUT, BREW_INFO_ENV).await?;
+        parse_homebrew_version(package.cask, &output)
+    }
+
+    /// Release feeds that do not spawn the CLI. A failure here only hides the
+    /// "published upstream, not yet in Homebrew" note.
+    async fn upstream_version(
+        &self,
+        harness: HarnessId,
+        installed: &str,
+    ) -> Result<String, String> {
+        match provider(harness).latest {
+            LatestSource::Github {
+                repository,
+                tag_prefix,
+            } => self.github_latest(repository, tag_prefix).await,
+            LatestSource::Npm(package) => self.npm_latest(package).await,
+            LatestSource::Opencode => self.npm_latest(opencode_release_package(installed)).await,
+            LatestSource::AntigravityAcp => self.antigravity_acp_latest().await,
+            LatestSource::Claude
+            | LatestSource::Command(_)
+            | LatestSource::Hermes
+            | LatestSource::Manual => Err("no separate upstream feed".into()),
+        }
+    }
+
     /// Apply one known release. Cancellation is honored while waiting for the
     /// exclusive lease and before mutation; once the vendor updater starts,
     /// the installation phase is intentionally non-interruptible. The owned
@@ -876,6 +1060,20 @@ impl HarnessUpdateCoordinator {
                 self.install_codex_standalone(harness, &current, install, &cancel)
                     .await
             }
+            UpdatePlan::Homebrew(package) => match resolve_brew(&package.brew) {
+                Ok(brew) => {
+                    let args = package.upgrade_args();
+                    match self.begin_install(harness, &cancel) {
+                        Ok(()) => {
+                            run_command_output_env(&brew, &args, UPDATE_TIMEOUT, BREW_UPGRADE_ENV)
+                                .await
+                                .map(drop)
+                        }
+                        Err(error) => Err(error),
+                    }
+                }
+                Err(error) => Err(error),
+            },
         };
         if let Err(error) = applied {
             drop(lease);
@@ -893,18 +1091,32 @@ impl HarnessUpdateCoordinator {
         });
         let verified = match self.executable(harness) {
             Ok(executable) => {
-                run_version_command(harness, &executable, provider(harness).version_args).await
+                run_version_command(harness, &executable, provider(harness).version_args)
+                    .await
+                    .map(|version| (version, executable))
             }
             Err(error) => Err(error),
         };
         let result = match verified {
-            Ok(version) => {
+            Ok((version, executable)) => {
                 let expected = current.latest_version.as_deref();
-                if expected.is_some_and(|latest| version_is_newer(latest, &version)) {
-                    Err(format!(
-                        "verification returned {version}, older than expected {}",
-                        expected.unwrap_or_default()
-                    ))
+                if let Some(latest) = expected.filter(|latest| version_is_newer(latest, &version)) {
+                    let lag = current
+                        .manual_command
+                        .as_deref()
+                        .is_some_and(unpublished_homebrew_upgrade);
+                    Err(match homebrew_package(&executable) {
+                        Some(package) if lag => format!(
+                            "Homebrew is still on {version}. {latest} is not available from `{}` yet",
+                            package.upgrade_command()
+                        ),
+                        Some(_) => format!(
+                            "Homebrew upgrade left the CLI on {version}, older than expected {latest}"
+                        ),
+                        None => {
+                            format!("verification returned {version}, older than expected {latest}")
+                        }
+                    })
                 } else {
                     lock(&self.inner.prefs).dismissed_versions.remove(&harness);
                     self.persist_preferences();
@@ -1697,6 +1909,134 @@ fn activate_codex_release(
     Err("automatic Codex standalone updates are not supported on this platform".into())
 }
 
+fn unpublished_homebrew_upgrade(command: &str) -> bool {
+    command
+        .trim()
+        .trim_matches('`')
+        .starts_with("brew upgrade ")
+}
+
+fn homebrew_token_ok(token: &str) -> bool {
+    let Some(first) = token.chars().next() else {
+        return false;
+    };
+    first.is_ascii_alphanumeric()
+        && token.len() <= 128
+        && token
+            .chars()
+            .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '+' | '-' | '_' | '.' | '@'))
+        // brew loads a `.rb` or `.json` argument as a local package file.
+        && !token.ends_with(".rb")
+        && !token.ends_with(".json")
+}
+
+fn homebrew_url_component(token: &str) -> String {
+    let mut encoded = String::new();
+    for byte in token.bytes() {
+        match byte {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                encoded.push(byte as char);
+            }
+            _ => encoded.push_str(&format!("%{byte:02X}")),
+        }
+    }
+    encoded
+}
+
+/// `Caskroom/<token>/<version>/…` and `Cellar/<token>/<version>/{bin,libexec}/…`
+/// are Homebrew's own layout. Anything else under a Homebrew prefix is not a
+/// Homebrew-owned CLI: npm packages in `lib/node_modules`, including globals
+/// that a keg-only runtime such as `node@20` keeps inside its own keg, belong
+/// to that package manager, and upgrading the runtime would not update them.
+fn homebrew_package(path: &Path) -> Option<HomebrewPackage> {
+    // Homebrew runs only on macOS and Linux.
+    if !cfg!(unix) {
+        return None;
+    }
+    let canonical = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
+    let components: Vec<_> = canonical.components().collect();
+    let (index, cask) =
+        components
+            .iter()
+            .enumerate()
+            .find_map(|(index, component)| match component.as_os_str().to_str()? {
+                "Caskroom" => Some((index, true)),
+                "Cellar" => Some((index, false)),
+                _ => None,
+            })?;
+    let token = components.get(index + 1)?.as_os_str().to_str()?;
+    if !homebrew_token_ok(token) {
+        return None;
+    }
+    let is_normal = |offset: usize| {
+        matches!(
+            components.get(index + offset),
+            Some(std::path::Component::Normal(_))
+        )
+    };
+    // The executable must live inside a versioned install of the package.
+    if !is_normal(2) || !is_normal(3) {
+        return None;
+    }
+    if !cask
+        && !matches!(
+            components[index + 3].as_os_str().to_str(),
+            Some("bin" | "libexec")
+        )
+    {
+        return None;
+    }
+    let mut prefix = PathBuf::new();
+    for component in &components[..index] {
+        prefix.push(component);
+    }
+    if prefix.as_os_str().is_empty() {
+        return None;
+    }
+    Some(HomebrewPackage {
+        brew: prefix.join("bin").join("brew"),
+        cask,
+        token: token.to_string(),
+    })
+}
+
+fn resolve_brew(preferred: &Path) -> Result<PathBuf, String> {
+    if preferred.is_file() {
+        Ok(preferred.to_path_buf())
+    } else {
+        // A different prefix's brew would upgrade the wrong install.
+        Err(format!("Homebrew was not found at {}", preferred.display()))
+    }
+}
+
+fn parse_homebrew_version(cask: bool, body: &str) -> Result<String, String> {
+    let json: serde_json::Value = serde_json::from_str(body)
+        .map_err(|error| format!("Homebrew version response was invalid: {error}"))?;
+    let version = if cask {
+        json.get("version")
+            .and_then(serde_json::Value::as_str)
+            .or_else(|| {
+                json.pointer("/casks/0/version")
+                    .and_then(serde_json::Value::as_str)
+            })
+    } else {
+        json.pointer("/versions/stable")
+            .and_then(serde_json::Value::as_str)
+            .or_else(|| {
+                json.pointer("/formulae/0/versions/stable")
+                    .and_then(serde_json::Value::as_str)
+            })
+    }
+    .map(str::trim)
+    .filter(|version| !version.is_empty())
+    .ok_or_else(|| "Homebrew version response contained no version".to_string())?;
+    let comparable = version.split(',').next().unwrap_or(version).trim();
+    if version_numbers(comparable).is_none() {
+        return Err(format!("Homebrew version {version} is not comparable"));
+    }
+    Ok(comparable.to_string())
+}
+
 fn classify_source(path: &Path) -> HarnessInstallSource {
     let canonical = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
     let text = format!("{}\n{}", path.display(), canonical.display()).to_ascii_lowercase();
@@ -1724,17 +2064,14 @@ fn claude_package_manager_command_for(harness: HarnessId, path: &Path) -> Option
 }
 
 fn claude_package_manager_command(path: &Path) -> Option<String> {
+    if let Some(package) = homebrew_package(path) {
+        return Some(package.upgrade_command());
+    }
     let canonical = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
     let text = format!("{}\n{}", path.display(), canonical.display())
         .replace('\\', "/")
         .to_ascii_lowercase();
-    if let Some(channel) = claude_cask_channel(path) {
-        Some(if channel == "latest" {
-            "brew upgrade claude-code@latest".into()
-        } else {
-            "brew upgrade claude-code".into()
-        })
-    } else if text.contains("/winget/") || text.contains("/microsoft/winget/") {
+    if text.contains("/winget/") || text.contains("/microsoft/winget/") {
         Some("winget upgrade Anthropic.ClaudeCode".into())
     } else if canonical.starts_with("/usr/bin")
         || canonical.starts_with("/nix/store")
@@ -1806,6 +2143,21 @@ async fn run_command(executable: &Path, args: &[&str], timeout: Duration) -> Res
         .map(drop)
 }
 
+const BREW_UPGRADE_ENV: &[(&str, &str)] = &[
+    ("NONINTERACTIVE", "1"),
+    ("HOMEBREW_NO_ANALYTICS", "1"),
+    ("HOMEBREW_NO_ENV_HINTS", "1"),
+    ("HOMEBREW_NO_EMOJI", "1"),
+];
+
+const BREW_INFO_ENV: &[(&str, &str)] = &[
+    ("NONINTERACTIVE", "1"),
+    ("HOMEBREW_NO_ANALYTICS", "1"),
+    ("HOMEBREW_NO_ENV_HINTS", "1"),
+    ("HOMEBREW_NO_EMOJI", "1"),
+    ("HOMEBREW_NO_AUTO_UPDATE", "1"),
+];
+
 /// Unix updaters can delegate installation to npm, pip, or a shell. Own
 /// their process group as well as the leader, including on future cancellation.
 #[cfg(unix)]
@@ -1823,6 +2175,15 @@ async fn run_command_output(
     executable: &Path,
     args: &[&str],
     timeout: Duration,
+) -> Result<String, String> {
+    run_command_output_env(executable, args, timeout, &[]).await
+}
+
+async fn run_command_output_env(
+    executable: &Path,
+    args: &[&str],
+    timeout: Duration,
+    env: &[(&str, &str)],
 ) -> Result<String, String> {
     let mut command = Command::new(executable);
     command
@@ -1832,6 +2193,9 @@ async fn run_command_output(
         .stderr(Stdio::piped())
         .kill_on_drop(true)
         .env("NO_COLOR", "1");
+    for (key, value) in env {
+        command.env(*key, *value);
+    }
     zeron_harness::compose_child_path(&mut command, executable);
     #[cfg(unix)]
     command.process_group(0);
@@ -3103,22 +3467,25 @@ esac
         for (path, command, channel) in [
             (
                 "/opt/homebrew/Caskroom/claude-code/2.1.100/claude",
-                "brew upgrade claude-code",
+                "brew upgrade --cask claude-code",
                 "stable",
             ),
             (
                 "/opt/homebrew/Caskroom/claude-code@latest/2.1.110/claude",
-                "brew upgrade claude-code@latest",
+                "brew upgrade --cask claude-code@latest",
                 "latest",
             ),
         ] {
             let path = std::path::Path::new(path);
-            assert!(!super::can_apply_update(HarnessId::ClaudeCode, path));
-            assert_eq!(
-                super::claude_package_manager_command(path).as_deref(),
-                Some(command)
-            );
             assert_eq!(super::claude_cask_channel(path).unwrap(), channel);
+            // Homebrew runs only on macOS and Linux.
+            if cfg!(unix) {
+                assert!(super::can_apply_update(HarnessId::ClaudeCode, path));
+                assert_eq!(
+                    super::claude_package_manager_command(path).as_deref(),
+                    Some(command)
+                );
+            }
         }
         assert!(!super::can_apply_update(
             HarnessId::ClaudeCode,
@@ -3179,4 +3546,144 @@ esac
         );
         coordinator.shutdown().await;
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn homebrew_layout_selects_cask_or_formula_upgrade() {
+        let codex = super::homebrew_package(std::path::Path::new(
+            "/opt/homebrew/Caskroom/codex/0.159.0/bin/codex",
+        ))
+        .unwrap();
+        assert!(codex.cask);
+        assert_eq!(codex.token, "codex");
+        assert_eq!(
+            codex.brew,
+            std::path::PathBuf::from("/opt/homebrew/bin/brew")
+        );
+        assert_eq!(codex.upgrade_command(), "brew upgrade --cask codex");
+        assert_eq!(codex.upgrade_args(), ["upgrade", "--cask", "codex"]);
+        assert!(super::can_apply_update(
+            HarnessId::Codex,
+            std::path::Path::new("/opt/homebrew/Caskroom/codex/0.159.0/bin/codex")
+        ));
+
+        let devin = super::homebrew_package(std::path::Path::new(
+            "/opt/homebrew/Caskroom/devin-cli/3000.10.21/bin/devin",
+        ))
+        .unwrap();
+        assert_eq!(devin.upgrade_command(), "brew upgrade --cask devin-cli");
+
+        let formula = super::homebrew_package(std::path::Path::new(
+            "/home/linuxbrew/.linuxbrew/Cellar/pi-coding-agent/1.2.3/bin/pi",
+        ))
+        .unwrap();
+        assert!(!formula.cask);
+        assert_eq!(formula.token, "pi-coding-agent");
+        assert_eq!(
+            formula.upgrade_command(),
+            "brew upgrade --formula pi-coding-agent"
+        );
+        assert_eq!(
+            formula.upgrade_args(),
+            ["upgrade", "--formula", "pi-coding-agent"]
+        );
+        assert_eq!(
+            formula.brew,
+            std::path::PathBuf::from("/home/linuxbrew/.linuxbrew/bin/brew")
+        );
+
+        assert!(
+            super::homebrew_package(std::path::Path::new(
+                "/opt/homebrew/lib/node_modules/@openai/codex/bin/codex"
+            ))
+            .is_none()
+        );
+        assert!(
+            super::homebrew_package(std::path::Path::new(
+                "/opt/homebrew/Caskroom/../not-a-real-codex"
+            ))
+            .is_none()
+        );
+        // npm globals of a keg-only Node live inside the runtime's keg. Brew
+        // must never upgrade node@20 on behalf of the CLI installed with it.
+        assert!(
+            super::homebrew_package(std::path::Path::new(
+                "/opt/homebrew/Cellar/node@20/20.18.0/lib/node_modules/@openai/codex/bin/codex.js"
+            ))
+            .is_none()
+        );
+        assert!(
+            super::homebrew_package(std::path::Path::new(
+                "/usr/local/Cellar/python@3.12/3.12.7/Frameworks/Python.framework/Versions/3.12/bin/hermes"
+            ))
+            .is_none()
+        );
+        // Formulae that vendor a Node package keep it under libexec.
+        let gemini = super::homebrew_package(std::path::Path::new(
+            "/usr/local/Cellar/gemini-cli/0.9.0/libexec/lib/node_modules/@google/gemini-cli/dist/index.js",
+        ))
+        .unwrap();
+        assert_eq!(
+            gemini.upgrade_args(),
+            ["upgrade", "--formula", "gemini-cli"]
+        );
+        assert_eq!(gemini.brew, std::path::PathBuf::from("/usr/local/bin/brew"));
+        for unversioned in [
+            "/opt/homebrew/Caskroom/codex",
+            "/opt/homebrew/Cellar/codex/bin",
+        ] {
+            assert!(super::homebrew_package(std::path::Path::new(unversioned)).is_none());
+        }
+        // A leading dash would be read as a brew option.
+        assert!(
+            super::homebrew_package(std::path::Path::new(
+                "/opt/homebrew/Caskroom/--force/1.0.0/codex"
+            ))
+            .is_none()
+        );
+        // brew would load these as local package files.
+        for token in ["codex.rb", "codex.json"] {
+            assert!(
+                super::homebrew_package(
+                    &std::path::Path::new("/opt/homebrew/Cellar")
+                        .join(token)
+                        .join("1.0.0/bin/codex")
+                )
+                .is_none()
+            );
+        }
+        assert!(
+            !super::can_apply_update(
+                HarnessId::Codex,
+                std::path::Path::new("/tmp/zeron-not-installed/codex")
+            ),
+            "an unclassified codex binary stays manual"
+        );
+
+        assert_eq!(
+            super::parse_homebrew_version(true, r#"{"version":"0.159.1"}"#).unwrap(),
+            "0.159.1"
+        );
+        assert_eq!(
+            super::parse_homebrew_version(true, r#"{"casks":[{"version":"0.159.1"}]}"#).unwrap(),
+            "0.159.1"
+        );
+        assert_eq!(
+            super::parse_homebrew_version(false, r#"{"versions":{"stable":"1.2.3"}}"#).unwrap(),
+            "1.2.3"
+        );
+        assert_eq!(
+            super::parse_homebrew_version(
+                false,
+                r#"{"formulae":[{"versions":{"stable":"1.2.3"}}]}"#
+            )
+            .unwrap(),
+            "1.2.3"
+        );
+        assert!(super::parse_homebrew_version(true, r#"{"version":"latest"}"#).is_err());
+        assert_eq!(
+            super::homebrew_url_component("claude-code@latest"),
+            "claude-code%40latest"
+        );
+    }
 }
diff --git a/crates/ui/src/settings/harnesses.rs b/crates/ui/src/settings/harnesses.rs
index 81c70d38d0..6367679d73 100644
--- a/crates/ui/src/settings/harnesses.rs
+++ b/crates/ui/src/settings/harnesses.rs
@@ -131,15 +131,13 @@ fn harness_update_label(status: &HarnessUpdateStatus, theme: &Theme) -> (SharedS
                 Some(latest) => format!("{installed} · v{latest} available"),
                 None => format!("{installed} · Update available"),
             };
-            if status.can_apply {
-                available
-            } else {
-                status
-                    .manual_command
-                    .as_deref()
-                    .map(|instruction| format!("{available} · {instruction}"))
-                    .unwrap_or(available)
-            }
+            // Applicable Homebrew updates still name the brew command when the
+            // cask or formula has not published the upstream release yet.
+            status
+                .manual_command
+                .as_deref()
+                .map(|instruction| format!("{available} · {instruction}"))
+                .unwrap_or(available)
         }
         HarnessUpdatePhase::WaitingForIdle => format!("{installed} · Waiting for agent to be idle"),
         HarnessUpdatePhase::Preparing => format!("{installed} · Preparing update…"),

From cc8b147a3ccce7f3bf57697cd5ef41dd06f489f5 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Wed, 30 Sep 2026 16:02:39 -0700
Subject: [PATCH 05/74] Fix subagent lifecycle identity and restart recovery
 (#676)

* Fix subagent spawn identity across resumes and recover stale chips

* Claude resume: scan native history off the runtime, skip sidechains

Long sessions' transcripts reach 100+ MB; parsing every line as JSON on a
tokio worker before each cold resume stalled the runtime. Read with std I/O
under spawn_blocking, parse only lines that can name a spawn or its agent,
stop on read errors, and ignore a subagent's own nested spawns.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/doc_host.rs          |  30 ++-
 crates/engine/src/sessions.rs          |  21 +-
 crates/engine/tests/e2e.rs             | 156 ++++++++++++++-
 crates/harness/src/claude/mod.rs       |  13 +-
 crates/harness/src/claude/normalize.rs | 258 ++++++++++++++++++++++++-
 crates/harness/src/claude/wire.rs      |   9 +-
 6 files changed, 456 insertions(+), 31 deletions(-)

diff --git a/crates/engine/src/doc_host.rs b/crates/engine/src/doc_host.rs
index e581310069..bffa3545f0 100644
--- a/crates/engine/src/doc_host.rs
+++ b/crates/engine/src/doc_host.rs
@@ -31,8 +31,8 @@ use tokio_util::task::TaskTracker;
 use zeron_doc::{
     COMMAND_DEFAULT_TTL_MS, CommandBasedOn, CommandDisposition, DocError, EvaluationContext,
     MessagePart, MessageRole, MessageStatus, QueueDeliveryGate, QueuedMessage, SessionCommandEntry,
-    SessionCommandPayload, SessionCommandStatus, SessionDoc, SessionMessageEntry, evaluate_command,
-    join_continuation_entries,
+    SessionCommandPayload, SessionCommandStatus, SessionDoc, SessionMessageEntry, SubagentStatus,
+    evaluate_command, join_continuation_entries,
 };
 use zeron_proto::{ConversationSourceContext, HarnessId, UserInputAnswer, UserInputQuestion};
 use zeron_sync::DocsStore;
@@ -786,17 +786,33 @@ impl ChatDocHandle {
         })
     }
 
-    /// Recovery sweep: stamp this device's abandoned `streaming` entries `aborted`, appending
+    /// Recovery sweep: settle this device's running subagent chips (including
+    /// chips in completed parent turns), then stamp abandoned `streaming`
+    /// entries `aborted`, appending
     /// `note` as a visible error part so the transcript says WHY the turn
     /// ended (zeron folded "Run interrupted by backend restart" the same
     /// way). Returns the stamped entries' `(id, created_at)` — recovery uses
     /// them for the resume-freshness check.
     pub fn mark_abandoned_streams(&self, note: &str) -> Result<Vec<(String, i64)>, DocError> {
         let mut stamped = Vec::new();
+        let mut chips_changed = false;
         for entry in self.doc.read_entries()? {
-            if entry.role == MessageRole::Assistant
-                && entry.status == Some(MessageStatus::Streaming)
-                && entry.device_id == self.device_id
+            if entry.role != MessageRole::Assistant || entry.device_id != self.device_id {
+                continue;
+            }
+            for part in &entry.parts {
+                if let MessagePart::Tool {
+                    id,
+                    subagent_status: Some(SubagentStatus::Running),
+                    ..
+                } = part
+                {
+                    chips_changed |=
+                        self.doc
+                            .update_subagent_chip(id, None, Some("failed"), None)?;
+                }
+            }
+            if entry.status == Some(MessageStatus::Streaming)
                 && self
                     .doc
                     .set_message_status(&entry.id, MessageStatus::Aborted)?
@@ -808,7 +824,7 @@ impl ChatDocHandle {
                 stamped.push((entry.id.clone(), entry.created_at));
             }
         }
-        if !stamped.is_empty() {
+        if chips_changed || !stamped.is_empty() {
             self.publish_messages();
         }
         Ok(stamped)
diff --git a/crates/engine/src/sessions.rs b/crates/engine/src/sessions.rs
index fb342c8c3e..eaaf6dd8d4 100644
--- a/crates/engine/src/sessions.rs
+++ b/crates/engine/src/sessions.rs
@@ -2350,6 +2350,17 @@ async fn drive_run(
             let done = matches!(sub_event.as_ref(), AgentEvent::Done { .. });
             if done {
                 settled_subagents.insert(parent_tool_use_id.clone());
+                if !chip_streaming {
+                    // A resumed run can finish an older chip without ever
+                    // opening a sink. The chip's lifecycle is independent of
+                    // whether this run received transcript content.
+                    let _ = doc_ref.update_subagent_chip(
+                        parent_tool_use_id,
+                        None,
+                        subagent_chip_update(sub_event),
+                        None,
+                    );
+                }
             }
             if let Some(sink) = subagents.get_mut(parent_tool_use_id) {
                 if let AgentEvent::UserMessage { text } = sub_event.as_ref() {
@@ -2370,16 +2381,6 @@ async fn drive_run(
                     flush_at = tokio::time::Instant::now()
                         + std::time::Duration::from_millis(STREAM_COMMIT_MS);
                 }
-                if !chip_streaming && done {
-                    // In-place chip refresh on lifecycle transitions only —
-                    // content never rewrites the parent doc.
-                    let _ = doc_ref.update_subagent_chip(
-                        parent_tool_use_id,
-                        None,
-                        subagent_chip_update(sub_event),
-                        None,
-                    );
-                }
                 if done {
                     let status = match sub_event.as_ref() {
                         AgentEvent::Done {
diff --git a/crates/engine/tests/e2e.rs b/crates/engine/tests/e2e.rs
index 2c2ccca088..693f58fbc1 100644
--- a/crates/engine/tests/e2e.rs
+++ b/crates/engine/tests/e2e.rs
@@ -11,7 +11,7 @@ use futures::stream::BoxStream;
 
 use zeron_doc::{
     MessagePart, MessageRole, MessageStatus, SegmentWriter, SessionCommandEntry,
-    SessionCommandPayload, SessionCommandStatus, SessionDoc, SessionMessageEntry,
+    SessionCommandPayload, SessionCommandStatus, SessionDoc, SessionMessageEntry, SubagentStatus,
 };
 use zeron_engine::{EngineCore, HarnessRegistry, RunJournal};
 use zeron_harness::mock::MockHarness;
@@ -1281,6 +1281,160 @@ async fn recover_stale_journal_stamps_aborted_on_boot() {
     );
 }
 
+fn spawn_chip(id: &str, status: SubagentStatus) -> MessagePart {
+    MessagePart::Tool {
+        id: id.into(),
+        call: ToolCall::Unknown {
+            name: "Agent: scout".into(),
+            input: None,
+        },
+        output: None,
+        diff: None,
+        is_error: false,
+        resolved: true,
+        output_ref: None,
+        output_bytes: None,
+        diff_ref: None,
+        diff_stats: None,
+        subagent_ref: Some(format!("{CHAT}--sub--{id}")),
+        subagent_status: Some(status),
+        subagent_tail: None,
+    }
+}
+
+#[tokio::test]
+async fn recover_stale_journal_settles_chips_in_completed_local_entries() {
+    let dir = tempfile::tempdir().unwrap();
+    let device_id = "dev-host-fixed";
+    std::fs::write(dir.path().join("device-id"), device_id).unwrap();
+    let journal = RunJournal::open(dir.path().join("orgs/dev-org/dev-user/journals")).unwrap();
+    journal
+        .append(
+            CHAT,
+            &AgentEvent::Subagent {
+                parent_tool_use_id: "spawn-running".into(),
+                event: Box::new(AgentEvent::TextDelta {
+                    text: "working".into(),
+                }),
+            },
+        )
+        .unwrap();
+    let doc = SessionDoc::init(CHAT).unwrap();
+    for (id, device) in [("local", device_id), ("remote", "other-device")] {
+        doc.push_message(&SessionMessageEntry {
+            id: id.into(),
+            role: MessageRole::Assistant,
+            parts: vec![
+                spawn_chip(&format!("{id}-running"), SubagentStatus::Running),
+                spawn_chip(&format!("{id}-done"), SubagentStatus::Done),
+            ],
+            created_at: 1,
+            device_id: device.into(),
+            status: Some(MessageStatus::Complete),
+            continuation_of: None,
+            duration_ms: None,
+        })
+        .unwrap();
+    }
+    let store = DocsStore::open(dir.path().join("orgs/dev-org/dev-user")).unwrap();
+    store
+        .save_snapshot(CHAT, &doc.export_snapshot().unwrap())
+        .unwrap();
+    let core = assemble(
+        dir.path(),
+        Arc::new(MockHarness {
+            script: mock_script(),
+        }),
+    );
+    let all = entries(&core);
+    let statuses: Vec<_> = all
+        .iter()
+        .flat_map(|e| &e.parts)
+        .filter_map(|p| match p {
+            MessagePart::Tool {
+                subagent_status, ..
+            } => *subagent_status,
+            _ => None,
+        })
+        .collect();
+    assert_eq!(
+        statuses,
+        [
+            SubagentStatus::Failed,
+            SubagentStatus::Done,
+            SubagentStatus::Running,
+            SubagentStatus::Done
+        ]
+    );
+    assert!(
+        all.iter()
+            .all(|e| e.status == Some(MessageStatus::Complete))
+    );
+    core.shutdown().await;
+}
+
+#[tokio::test]
+async fn subagent_done_without_a_live_sink_updates_a_persisted_chip() {
+    let dir = tempfile::tempdir().unwrap();
+    let core = assemble(
+        dir.path(),
+        Arc::new(MockHarness {
+            script: vec![
+                AgentEvent::Subagent {
+                    parent_tool_use_id: "old-spawn".into(),
+                    event: Box::new(done(DoneStatus::Completed)),
+                },
+                done(DoneStatus::Completed),
+            ],
+        }),
+    );
+    core.doc_host
+        .open(CHAT)
+        .unwrap()
+        .doc()
+        .push_message(&SessionMessageEntry {
+            id: "old-assistant".into(),
+            role: MessageRole::Assistant,
+            parts: vec![spawn_chip("old-spawn", SubagentStatus::Running)],
+            created_at: 1,
+            device_id: core.device_id.clone(),
+            status: Some(MessageStatus::Complete),
+            continuation_of: None,
+            duration_ms: None,
+        })
+        .unwrap();
+    core.sessions
+        .dispatch(CHAT, HarnessId::Mock, run_request("resume"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || {
+            core.sessions
+                .session_status(CHAT)
+                .is_some_and(|s| s.status == SessionStatus::Idle)
+        },
+        "resumed turn completes",
+    )
+    .await;
+    let all = entries(&core);
+    let chip = all
+        .iter()
+        .flat_map(|e| &e.parts)
+        .find(|p| matches!(p, MessagePart::Tool { id, .. } if id == "old-spawn"))
+        .unwrap();
+    assert!(
+        matches!(
+            chip,
+            MessagePart::Tool {
+                subagent_status: Some(SubagentStatus::Done),
+                ..
+            }
+        ),
+        "{chip:?}"
+    );
+    core.shutdown().await;
+}
+
 #[tokio::test]
 async fn rpc_surface_over_in_memory_transport() {
     let dir = tempfile::tempdir().unwrap();
diff --git a/crates/harness/src/claude/mod.rs b/crates/harness/src/claude/mod.rs
index 9e4d792f89..a5be1d7245 100644
--- a/crates/harness/src/claude/mod.rs
+++ b/crates/harness/src/claude/mod.rs
@@ -544,6 +544,15 @@ impl ClaudeHarness {
             // config with settings-sourced ones.
             cmd.args(["--mcp-config", &mcp_config_arg(mcp)]);
         }
+        let normalizer = if let Some(session_id) = &request.resume {
+            let config = crate::model_context::root(
+                "CLAUDE_CONFIG_DIR",
+                crate::executable::home_or_current_dir().join(".claude"),
+            );
+            Normalizer::for_resume(&config, session_id).await
+        } else {
+            Normalizer::new()
+        };
         let mut child = cmd.spawn().map_err(|e| {
             if e.kind() == std::io::ErrorKind::NotFound {
                 HarnessError::NotInstalled(crate::executable::binary_hint(&exe))
@@ -590,6 +599,7 @@ impl ClaudeHarness {
 
         let (event_tx, event_rx) = mpsc::channel::<Result<AgentEvent, HarnessError>>(256);
         tokio::spawn(run_session(Session {
+            normalizer,
             title_only,
             child,
             stdout_lines: BufReader::new(stdout).lines(),
@@ -714,6 +724,7 @@ async fn stdin_writer(mut stdin: ChildStdin, mut rx: mpsc::UnboundedReceiver<Std
 }
 
 struct Session {
+    normalizer: Normalizer,
     title_only: bool,
     child: Child,
     stdout_lines: tokio::io::Lines<BufReader<crate::process::ChildStdout>>,
@@ -731,6 +742,7 @@ struct Session {
 /// mailbox, the interrupt token, and consumer liveness.
 async fn run_session(session: Session) {
     let Session {
+        normalizer: mut norm,
         title_only,
         mut child,
         mut stdout_lines,
@@ -750,7 +762,6 @@ async fn run_session(session: Session) {
     } = controls;
     let request_input = Arc::new(request_input);
 
-    let mut norm = Normalizer::new();
     let mut pending_steers = std::collections::VecDeque::new();
     // Top-level tool calls in flight: a steer must not abort them (see
     // `wire::steer_message_line`).
diff --git a/crates/harness/src/claude/normalize.rs b/crates/harness/src/claude/normalize.rs
index d49aa07afc..2d20c6edd5 100644
--- a/crates/harness/src/claude/normalize.rs
+++ b/crates/harness/src/claude/normalize.rs
@@ -191,6 +191,8 @@ pub(crate) struct Normalizer {
     /// re-keys them onto the spawn chip's feed (the wire never echoes the
     /// steer on the child feed — live-verified 2.1.228).
     agent_tasks: std::collections::HashMap<String, String>,
+    /// Later tool calls that wake the same task → its original spawn.
+    agent_tool_spawns: std::collections::HashMap<String, String>,
     /// tool_use ids of Agent/Task spawn calls, recorded from their own
     /// assistant frames (plus `task_started`'s agent-task pairing). Gates
     /// `task_notification`: background SHELL tasks settle through the same
@@ -212,12 +214,116 @@ impl Normalizer {
             saw_init: false,
             last_model: None,
             agent_tasks: std::collections::HashMap::new(),
+            agent_tool_spawns: std::collections::HashMap::new(),
             agent_spawn_tools: std::collections::HashSet::new(),
             assistant_message_id: new_message_id(),
             session_id: None,
         }
     }
 
+    /// Restore only spawn identity from Claude's native history. The CLI
+    /// does not replay task_started when --resume starts a new process.
+    /// Session ids are global; search project directories rather than
+    /// duplicating the CLI's cwd encoding (including long-path hashing).
+    /// Long sessions' histories run to hundreds of MB: the scan runs off the
+    /// runtime and only parses lines that can name a spawn or its agent.
+    pub async fn for_resume(config_root: &std::path::Path, session_id: &str) -> Self {
+        let config_root = config_root.to_owned();
+        let session_id = session_id.to_owned();
+        tokio::task::spawn_blocking(move || Self::restore_spawns(&config_root, &session_id))
+            .await
+            .unwrap_or_else(|_| Self::new())
+    }
+
+    fn restore_spawns(config_root: &std::path::Path, session_id: &str) -> Self {
+        use std::io::BufRead as _;
+        let mut norm = Self::new();
+        if session_id.is_empty()
+            || !session_id
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '-')
+        {
+            return norm;
+        }
+        let Ok(projects) = std::fs::read_dir(config_root.join("projects")) else {
+            return norm;
+        };
+        let Some(file) = projects.flatten().find_map(|project| {
+            std::fs::File::open(project.path().join(format!("{session_id}.jsonl"))).ok()
+        }) else {
+            return norm;
+        };
+        let mut reader = std::io::BufReader::with_capacity(1 << 16, file);
+        let mut line = Vec::new();
+        loop {
+            line.clear();
+            match reader.read_until(b'\n', &mut line) {
+                Ok(0) | Err(_) => break,
+                Ok(_) => {}
+            }
+            // Torn lines and older/newer unknown shapes are harmless.
+            let Ok(text) = std::str::from_utf8(&line) else {
+                continue;
+            };
+            if !(text.contains("\"Agent\"")
+                || text.contains("\"Task\"")
+                || text.contains("agentId"))
+            {
+                continue;
+            }
+            let Ok(record) = serde_json::from_str::<Value>(text) else {
+                continue;
+            };
+            // A subagent's own nested spawns are not chips on this chat.
+            if record.get("isSidechain").and_then(Value::as_bool) == Some(true)
+                || !record.get("parent_tool_use_id").is_none_or(Value::is_null)
+            {
+                continue;
+            }
+            let Some(blocks) = record.pointer("/message/content").and_then(Value::as_array) else {
+                continue;
+            };
+            match record.get("type").and_then(Value::as_str) {
+                Some("assistant") => {
+                    for block in blocks {
+                        if block.get("type").and_then(Value::as_str) == Some("tool_use")
+                            && matches!(
+                                block.get("name").and_then(Value::as_str),
+                                Some("Agent" | "Task")
+                            )
+                            && let Some(id) = block
+                                .get("id")
+                                .and_then(Value::as_str)
+                                .filter(|id| !id.is_empty())
+                        {
+                            norm.agent_spawn_tools.insert(id.to_owned());
+                        }
+                    }
+                }
+                Some("user") => {
+                    if let Some(agent) = record
+                        .pointer("/toolUseResult/agentId")
+                        .and_then(Value::as_str)
+                        .filter(|id| !id.is_empty())
+                        && let Some(spawn) = blocks
+                            .iter()
+                            .filter(|b| {
+                                b.get("type").and_then(Value::as_str) == Some("tool_result")
+                            })
+                            .filter_map(|b| b.get("tool_use_id").and_then(Value::as_str))
+                            .find(|id| norm.agent_spawn_tools.contains(*id))
+                    {
+                        norm.agent_tasks
+                            .entry(agent.to_owned())
+                            .or_insert_with(|| spawn.to_owned());
+                    }
+                }
+                _ => {}
+            }
+        }
+        norm
+    }
+
     /// Rotate the assistant message id for a steer boundary; returns
     /// (previous, next) for the `Steered` event.
     pub fn rotate_for_steer(&mut self) -> (String, String) {
@@ -237,16 +343,22 @@ impl Normalizer {
                 // Surface it as the subagent's tagged Done so the chip flips
                 // done/failed and the transcript freezes.
                 if f.subtype == "task_notification" {
-                    let Some(parent) = f.tool_use_id.as_deref().filter(|t| !t.is_empty()) else {
+                    // A resumed task's notification may carry SendMessage's
+                    // id, or omit the tool id entirely. Its task id is stable.
+                    let parent = f
+                        .task_id
+                        .as_deref()
+                        .and_then(|task| self.agent_tasks.get(task).map(String::as_str))
+                        .or_else(|| f.tool_use_id.as_deref().filter(|t| !t.is_empty()));
+                    let Some(parent) = parent else {
                         return Vec::new();
                     };
                     // Only a KNOWN spawn settles as a subagent. Background
                     // SHELL tasks (`Bash` with `run_in_background`) settle
                     // through this same subtype carrying the Bash call's id —
                     // tagging that Done would bind a subagent ref onto an
-                    // ordinary Run chip. A real spawn's tool_use frame always
-                    // precedes its notification on the wire, so the set is
-                    // populated by the time a genuine one arrives.
+                    // ordinary Run chip. Spawn ids are learned from live
+                    // calls/task starts or restored from the native history.
                     if !self.agent_spawn_tools.contains(parent) {
                         return Vec::new();
                     }
@@ -279,8 +391,13 @@ impl Normalizer {
                         f.tool_use_id.as_deref().filter(|t| !t.is_empty()),
                     )
                 {
-                    self.agent_tasks.insert(task.to_owned(), tool.to_owned());
-                    self.agent_spawn_tools.insert(tool.to_owned());
+                    let spawn = self
+                        .agent_tasks
+                        .entry(task.to_owned())
+                        .or_insert_with(|| tool.to_owned());
+                    self.agent_spawn_tools.insert(spawn.clone());
+                    self.agent_tool_spawns
+                        .insert(tool.to_owned(), spawn.clone());
                     return Vec::new();
                 }
                 if f.subtype != "init" || self.saw_init {
@@ -311,6 +428,7 @@ impl Normalizer {
                     return Vec::new();
                 }
                 if let Some(parent) = &f.parent_tool_use_id {
+                    let parent = self.agent_tool_spawns.get(parent).unwrap_or(parent);
                     return match f.event.delta.kind.as_str() {
                         "text_delta" => vec![tag(
                             parent,
@@ -350,6 +468,7 @@ impl Normalizer {
 
             Frame::Assistant(f) => {
                 if let Some(parent) = &f.parent_tool_use_id {
+                    let parent = self.agent_tool_spawns.get(parent).unwrap_or(parent);
                     // Subagent content, attributed. The 2.1.x wire streams NO
                     // tagged partial deltas (live-verified): a subagent's text
                     // arrives only as full text blocks on its tagged
@@ -386,7 +505,7 @@ impl Normalizer {
                     return out;
                 }
                 // Record spawn tool ids up front: `task_notification` keys on
-                // them, and only foreground spawns ever get a `task_started`.
+                // them; a task may finish before a `task_started` arrives.
                 for b in f.message.blocks() {
                     if b.kind == "tool_use" && matches!(b.name.as_str(), "Agent" | "Task") {
                         self.agent_spawn_tools.insert(b.id.clone());
@@ -485,6 +604,7 @@ impl Normalizer {
 
             Frame::User(f) => {
                 if let Some(parent) = &f.parent_tool_use_id {
+                    let parent = self.agent_tool_spawns.get(parent).unwrap_or(parent);
                     // A subagent's tool results echo on the main channel too;
                     // they belong to its transcript, attributed like its calls.
                     let mut out: Vec<AgentEvent> = f
@@ -1025,6 +1145,130 @@ mod tests {
         );
     }
 
+    #[test]
+    fn resumed_task_notifications_settle_the_original_spawn() {
+        for notification in [
+            r#"{"type":"system","subtype":"task_notification","task_id":"a1","tool_use_id":"toolu_send","status":"completed"}"#,
+            r#"{"type":"system","subtype":"task_notification","task_id":"a1","status":"stopped"}"#,
+        ] {
+            let mut norm = Normalizer::new();
+            for raw in [
+                r#"{"type":"system","subtype":"task_started","task_id":"a1","tool_use_id":"toolu_spawn","subagent_type":"general-purpose"}"#,
+                r#"{"type":"assistant","message":{"content":[{"type":"tool_use","id":"toolu_send","name":"SendMessage","input":{"to":"a1","message":"Keep going."}}]}}"#,
+                r#"{"type":"system","subtype":"task_started","task_id":"a1","tool_use_id":"toolu_send","subagent_type":"general-purpose"}"#,
+            ] {
+                norm.normalize(crate::claude::wire::parse_frame(raw).unwrap(), false);
+            }
+            let events = norm.normalize(
+                crate::claude::wire::parse_frame(notification).unwrap(),
+                false,
+            );
+            let expected = if notification.contains("completed") {
+                DoneStatus::Completed
+            } else {
+                DoneStatus::Interrupted
+            };
+            assert_eq!(
+                events,
+                vec![tag(
+                    "toolu_spawn",
+                    AgentEvent::Done {
+                        status: expected,
+                        result: None,
+                        error: None,
+                        session_id: None,
+                    }
+                )]
+            );
+            // The next steer must still use the original transcript too.
+            let events = norm.normalize(crate::claude::wire::parse_frame(
+                r#"{"type":"assistant","message":{"content":[{"type":"tool_use","id":"toolu_send2","name":"SendMessage","input":{"to":"a1","message":"One more check."}}]}}"#,
+            ).unwrap(), false);
+            assert!(
+                events.iter().any(|e| matches!(e,
+                    AgentEvent::Subagent { parent_tool_use_id, event }
+                        if parent_tool_use_id == "toolu_spawn"
+                            && matches!(event.as_ref(), AgentEvent::UserMessage { .. })
+                )),
+                "{events:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn resumed_child_frames_use_the_original_transcript() {
+        let mut norm = Normalizer::new();
+        for raw in [
+            r#"{"type":"system","subtype":"task_started","task_id":"a1","tool_use_id":"toolu_spawn","subagent_type":"general-purpose"}"#,
+            r#"{"type":"system","subtype":"task_started","task_id":"a1","tool_use_id":"toolu_send","subagent_type":"general-purpose"}"#,
+        ] {
+            norm.normalize(crate::claude::wire::parse_frame(raw).unwrap(), false);
+        }
+        for raw in [
+            r#"{"type":"stream_event","parent_tool_use_id":"toolu_send","event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"working"}}}"#,
+            r#"{"type":"assistant","parent_tool_use_id":"toolu_send","message":{"content":[{"type":"text","text":"finished"}]}}"#,
+            r#"{"type":"user","parent_tool_use_id":"toolu_send","message":{"content":[{"type":"tool_result","tool_use_id":"child-tool"}]}}"#,
+        ] {
+            let events = norm.normalize(crate::claude::wire::parse_frame(raw).unwrap(), false);
+            assert!(!events.is_empty());
+            assert!(events.iter().all(|e| matches!(e,
+                AgentEvent::Subagent { parent_tool_use_id, .. } if parent_tool_use_id == "toolu_spawn"
+            )), "{events:?}");
+        }
+    }
+
+    #[tokio::test]
+    async fn resumed_session_restores_task_ids_from_the_native_transcript() {
+        let root = tempfile::tempdir().unwrap();
+        let project = root.path().join("projects/encoded-project");
+        std::fs::create_dir_all(&project).unwrap();
+        std::fs::write(project.join("session-1.jsonl"), concat!(
+            "not json\n",
+            r#"{"type":"assistant","message":{"content":[{"type":"tool_use","id":"toolu_spawn","name":"Agent","input":{"description":"scout"}}]}}"#,
+            "\n",
+            r#"{"type":"user","toolUseResult":{"agentId":"a1","status":"async_launched"},"message":{"content":[{"type":"tool_result","tool_use_id":"toolu_spawn"}]}}"#,
+            "\n",
+            r#"{"type":"assistant","message":{"content":[{"type":"tool_use","id":"toolu_send","name":"SendMessage","input":{"to":"a1","message":"continue"}}]}}"#,
+            "\n",
+            r#"{"type":"user","toolUseResult":{"agentId":"a1"},"message":{"content":[{"type":"tool_result","tool_use_id":"toolu_send"}]}}"#,
+            "\n",
+            // A subagent's own nested spawn is not a chip on this chat.
+            r#"{"type":"assistant","isSidechain":true,"message":{"content":[{"type":"tool_use","id":"toolu_nested","name":"Agent","input":{"description":"deeper"}}]}}"#,
+            "\n",
+            r#"{"type":"user","isSidechain":true,"toolUseResult":{"agentId":"a2"},"message":{"content":[{"type":"tool_result","tool_use_id":"toolu_nested"}]}}"#,
+            "\n{torn tail"
+        )).unwrap();
+        let mut norm = Normalizer::for_resume(root.path(), "session-1").await;
+        assert!(!norm.agent_spawn_tools.contains("toolu_nested"));
+        assert!(!norm.agent_tasks.contains_key("a2"));
+        // The revived process has no original spawn frame on its wire.
+        norm.normalize(crate::claude::wire::parse_frame(
+            r#"{"type":"system","subtype":"task_started","task_id":"a1","tool_use_id":"toolu_send","subagent_type":"general-purpose"}"#,
+        ).unwrap(), false);
+        let events = norm.normalize(crate::claude::wire::parse_frame(
+            r#"{"type":"system","subtype":"task_notification","task_id":"a1","tool_use_id":"toolu_send","status":"completed"}"#,
+        ).unwrap(), false);
+        assert_eq!(
+            events,
+            vec![tag(
+                "toolu_spawn",
+                AgentEvent::Done {
+                    status: DoneStatus::Completed,
+                    result: None,
+                    error: None,
+                    session_id: None,
+                }
+            )]
+        );
+        assert!(!norm.saw_init, "history must not consume the live init");
+        assert!(
+            Normalizer::for_resume(root.path(), "missing")
+                .await
+                .agent_tasks
+                .is_empty()
+        );
+    }
+
     #[test]
     fn shell_task_notification_never_settles_a_subagent() {
         // `Bash` with `run_in_background` settles through the SAME
diff --git a/crates/harness/src/claude/wire.rs b/crates/harness/src/claude/wire.rs
index 828c4f18d9..af75a6ab62 100644
--- a/crates/harness/src/claude/wire.rs
+++ b/crates/harness/src/claude/wire.rs
@@ -33,16 +33,15 @@ pub(crate) struct SystemFrame {
     pub cwd: String,
     #[serde(default)]
     pub session_id: String,
-    /// `task_notification` (a background subagent settling): the spawning
-    /// Agent tool's id — the only TAGGED terminal signal the 2.1.x wire has
-    /// for a background subagent (its frames otherwise just stop).
+    /// `task_notification`: the spawning Agent tool's id, or the latest
+    /// SendMessage id after a resume. Stop notifications may omit it.
     #[serde(default, alias = "toolUseId")]
     pub tool_use_id: Option<String>,
     /// `task_notification` terminal status (`completed`/`failed`/`killed`…).
     #[serde(default)]
     pub status: Option<String>,
-    /// `task_started`: the agent/task id (`SendMessage`'s `to:` address) —
-    /// with `tool_use_id`, the agentId→spawn mapping steers need.
+    /// `task_started` / `task_notification`: stable agent/task id
+    /// (`SendMessage`'s `to:` address), used to retain spawn identity.
     #[serde(default, alias = "taskId")]
     pub task_id: Option<String>,
     /// `task_started`: present only for AGENT tasks (a subagent spawning),

From 626bccc85cb59bb101cf2274eb172c3db6cb7f1f Mon Sep 17 00:00:00 2001
From: Mohammed <93622996+Mohaddz@users.noreply.github.com>
Date: Thu, 1 Oct 2026 02:05:07 +0300
Subject: [PATCH 06/74] Appearance: add background positioning and zoom (#660)

* Appearance: add background positioning and zoom

* Wallpaper: keep the preload queue when a background's framing changes

The preload key compared the whole background setting, so applying a crop
or zoom flushed three decoded wallpapers and re-decoded them. Key on the
managed path instead, and extend the warm-switch test to cover it. Also
rustfmt the new background-mask code.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/examples/new-project-fixture.rs     |    6 +-
 .../ui/src/new_thread_background_effects.rs   |  113 +-
 crates/ui/src/new_thread_background_mask.rs   |  406 ++++++-
 crates/ui/src/settings.rs                     |  180 ++-
 crates/ui/src/settings/appearance.rs          | 1000 ++++++++++++++++-
 crates/ui/src/settings/wallpaper.rs           |   71 +-
 crates/ui/src/settings/wallpaper_colors.rs    |    1 +
 crates/ui/src/shell.rs                        |   14 +-
 8 files changed, 1747 insertions(+), 44 deletions(-)

diff --git a/crates/ui/examples/new-project-fixture.rs b/crates/ui/examples/new-project-fixture.rs
index 40ea092f89..a41f523027 100644
--- a/crates/ui/examples/new-project-fixture.rs
+++ b/crates/ui/examples/new-project-fixture.rs
@@ -13,7 +13,11 @@ fn main() -> anyhow::Result<()> {
         let mut settings = settings::UiSettings::default();
         settings.sidebar_show_branch = true;
         if let Ok(path) = std::env::var("ZERON_FIXTURE_BACKGROUND") {
-            settings.new_thread_composer_background = Some(settings::NewThreadComposerBackground { path, name: "Uploaded background".into() });
+            settings.new_thread_composer_background = Some(settings::NewThreadComposerBackground {
+                path,
+                name: "Uploaded background".into(),
+                adjustment: settings::NewThreadBackgroundAdjustment::default(),
+            });
         }
         if let Some(folder) = std::env::var_os("ZERON_FIXTURE_WALLPAPER_FOLDER") {
             settings.wallpaper_folder = Some(folder.into());
diff --git a/crates/ui/src/new_thread_background_effects.rs b/crates/ui/src/new_thread_background_effects.rs
index abd0eee26c..bedcd0af4c 100644
--- a/crates/ui/src/new_thread_background_effects.rs
+++ b/crates/ui/src/new_thread_background_effects.rs
@@ -1,5 +1,5 @@
 //! Effects remain cached source-space images; a separate alpha mask follows layout.
-use crate::settings::NewThreadBackgroundEffect;
+use crate::settings::{NewThreadBackgroundAdjustment, NewThreadBackgroundEffect};
 use crate::theme::Theme;
 use gpui::{Pixels, px};
 use std::path::{Path, PathBuf};
@@ -12,12 +12,18 @@ use std::time::Instant;
 pub(crate) struct Readiness {
     current: Option<Arc<gpui::RenderImage>>,
     previous: Option<Arc<gpui::RenderImage>>,
+    current_adjustment: NewThreadBackgroundAdjustment,
+    previous_adjustment: NewThreadBackgroundAdjustment,
+    current_path: Option<PathBuf>,
+    previous_path: Option<PathBuf>,
     started: Option<Instant>,
 }
 
 pub(crate) struct ArtworkFrame {
     pub current: Option<Arc<gpui::RenderImage>>,
     pub previous: Option<Arc<gpui::RenderImage>>,
+    pub current_adjustment: NewThreadBackgroundAdjustment,
+    pub previous_adjustment: NewThreadBackgroundAdjustment,
     pub mix: f32,
     pub active: bool,
 }
@@ -32,6 +38,8 @@ impl Readiness {
     pub fn frame(
         &mut self,
         image: Option<Arc<gpui::RenderImage>>,
+        path: Option<&Path>,
+        adjustment: NewThreadBackgroundAdjustment,
         enabled: bool,
         reduced: bool,
         now: Instant,
@@ -39,17 +47,31 @@ impl Readiness {
         let progress = self.started.map_or(1.0, |start| crossfade_mix(start, now));
         if reduced || progress >= 1.0 {
             self.previous = None;
+            self.previous_path = None;
             self.started = None;
         }
+        // Effects may still be loading, but a crop belongs to the source path,
+        // not its effect raster. Replacement images keep their own framing.
+        if path.is_some() && path == self.current_path.as_deref() {
+            self.current_adjustment = adjustment.normalized();
+        }
+        if path.is_some() && path == self.previous_path.as_deref() {
+            self.previous_adjustment = adjustment.normalized();
+        }
         // None while enabled means "still loading", not "remove artwork".
         if self.started.is_none() && (!enabled || image.is_some()) {
             let target = if enabled { image } else { None };
             if self.current.as_ref().map(|image| image.id) != target.as_ref().map(|image| image.id)
             {
                 self.previous = self.current.take();
+                self.previous_adjustment = self.current_adjustment;
+                self.previous_path = self.current_path.take();
                 self.current = target;
+                self.current_adjustment = adjustment.normalized();
+                self.current_path = path.map(Path::to_path_buf);
                 if reduced {
                     self.previous = None;
+                    self.previous_path = None;
                 } else {
                     self.started = Some(now);
                 }
@@ -58,6 +80,8 @@ impl Readiness {
         ArtworkFrame {
             current: self.current.clone(),
             previous: self.previous.clone(),
+            current_adjustment: self.current_adjustment,
+            previous_adjustment: self.previous_adjustment,
             mix: self.started.map_or(1.0, |start| crossfade_mix(start, now)),
             active: self.started.is_some(),
         }
@@ -414,11 +438,13 @@ mod tests {
         let latest = artwork();
         let mut ready = Readiness::default();
         let now = Instant::now();
-        ready.frame(Some(first.clone()), true, true, now);
-        let loading = ready.frame(None, true, false, now);
+        let path = Some(Path::new("background.png"));
+        let adjustment = NewThreadBackgroundAdjustment::default();
+        ready.frame(Some(first.clone()), path, adjustment, true, true, now);
+        let loading = ready.frame(None, path, adjustment, true, false, now);
         assert_eq!(loading.current.unwrap().id, first.id);
         assert!(!loading.active);
-        let start = ready.frame(Some(next.clone()), true, false, now);
+        let start = ready.frame(Some(next.clone()), path, adjustment, true, false, now);
         assert_eq!(start.mix, 0.0);
         assert_eq!(start.previous.unwrap().id, first.id);
         let halfway = now
@@ -427,22 +453,93 @@ mod tests {
                     * crate::motion::speed_scale()
                     * 0.5,
             );
-        let frame = ready.frame(Some(latest.clone()), true, false, halfway);
+        let frame = ready.frame(Some(latest.clone()), path, adjustment, true, false, halfway);
         assert!((frame.mix - 0.875).abs() < 0.001);
         assert_eq!(frame.current.unwrap().id, next.id);
         let done = now + std::time::Duration::from_secs(1);
-        let frame = ready.frame(Some(latest.clone()), true, false, done);
+        let frame = ready.frame(Some(latest.clone()), path, adjustment, true, false, done);
         assert_eq!(frame.previous.unwrap().id, next.id);
         assert_eq!(frame.current.unwrap().id, latest.id);
         assert_eq!(frame.mix, 0.0);
-        let frame = ready.frame(Some(latest), true, true, done);
+        let frame = ready.frame(Some(latest), path, adjustment, true, true, done);
         assert!(!frame.active);
         assert!(frame.previous.is_none());
         assert_eq!(frame.mix, 1.0);
-        let removed = ready.frame(None, false, true, done);
+        let removed = ready.frame(None, None, adjustment, false, true, done);
         assert!(removed.current.is_none() && removed.previous.is_none());
     }
 
+    #[test]
+    fn wallpaper_replacement_and_removal_keep_the_departing_crop() {
+        let first = artwork();
+        let next = artwork();
+        let first_path = Some(Path::new("first.png"));
+        let next_path = Some(Path::new("next.png"));
+        let cropped = NewThreadBackgroundAdjustment {
+            focal_x: 0.2,
+            focal_y: 0.8,
+            zoom: 2.0,
+        };
+        let centered = NewThreadBackgroundAdjustment::default();
+        let mut ready = Readiness::default();
+        let now = Instant::now();
+        ready.frame(Some(first.clone()), first_path, cropped, true, true, now);
+        let loading = ready.frame(None, next_path, centered, true, false, now);
+        assert_eq!(loading.current.as_ref().unwrap().id, first.id);
+        assert_eq!(loading.current_adjustment, cropped);
+        let start = ready.frame(Some(next), next_path, centered, true, false, now);
+        assert_eq!(start.previous_adjustment, cropped);
+        assert_eq!(start.current_adjustment, centered);
+        let latest = artwork();
+        let latest_path = Some(Path::new("latest.png"));
+        let waiting = ready.frame(Some(latest.clone()), latest_path, cropped, true, false, now);
+        assert_eq!(waiting.previous_adjustment, cropped);
+        assert_eq!(waiting.current_adjustment, centered);
+        let done = now + std::time::Duration::from_secs(1);
+        let adopted = ready.frame(Some(latest), latest_path, cropped, true, false, done);
+        assert_eq!(adopted.previous_adjustment, centered);
+        assert_eq!(adopted.current_adjustment, cropped);
+
+        let mut ready = Readiness::default();
+        ready.frame(Some(first), first_path, cropped, true, true, now);
+        let removed = ready.frame(None, None, centered, false, false, now);
+        assert!(removed.current.is_none());
+        assert!(removed.previous.is_some());
+        assert_eq!(removed.previous_adjustment, cropped);
+    }
+
+    #[test]
+    fn applying_crop_during_effect_loading_updates_the_same_source_without_a_fade() {
+        let first = artwork();
+        let effect = artwork();
+        let path = Some(Path::new("background.png"));
+        let centered = NewThreadBackgroundAdjustment::default();
+        let cropped = NewThreadBackgroundAdjustment {
+            zoom: 2.0,
+            ..centered
+        };
+        let latest = NewThreadBackgroundAdjustment {
+            zoom: 3.0,
+            ..centered
+        };
+        let mut ready = Readiness::default();
+        let now = Instant::now();
+        ready.frame(Some(first), path, centered, true, true, now);
+        let loading = ready.frame(None, path, cropped, true, false, now);
+        assert_eq!(loading.current_adjustment, cropped);
+        assert!(!loading.active);
+        let start = ready.frame(Some(effect.clone()), path, cropped, true, false, now);
+        assert_eq!(start.previous_adjustment, cropped);
+        assert_eq!(start.current_adjustment, cropped);
+        let applied = ready.frame(Some(effect.clone()), path, latest, true, false, now);
+        assert_eq!(applied.previous_adjustment, latest);
+        assert_eq!(applied.current_adjustment, latest);
+        let done = now + std::time::Duration::from_secs(1);
+        let applied = ready.frame(Some(effect), path, cropped, true, false, done);
+        assert_eq!(applied.current_adjustment, cropped);
+        assert!(!applied.active);
+    }
+
     #[gpui::test]
     fn prewarming_decodes_off_thread_and_reuses_artwork_without_hero_geometry(
         cx: &mut gpui::TestAppContext,
diff --git a/crates/ui/src/new_thread_background_mask.rs b/crates/ui/src/new_thread_background_mask.rs
index d36ba347b7..303fefde6d 100644
--- a/crates/ui/src/new_thread_background_mask.rs
+++ b/crates/ui/src/new_thread_background_mask.rs
@@ -1,6 +1,7 @@
 //! Paint-time source-alpha feather. Resizing changes only GPU parameters, not
 //! the image identity, pixels, atlas entry, or an asynchronous raster job.
-use gpui::{Bounds, ImageAlphaMask, Pixels, RenderImage, Window, point, px, size};
+use crate::settings::NewThreadBackgroundAdjustment;
+use gpui::{Bounds, Corners, ImageAlphaMask, Pixels, Point, RenderImage, Window, point, px, size};
 use std::{cell::Cell, rc::Rc, sync::Arc};
 
 // Reveal half-strength artwork through the cutout's darkest area. The main
@@ -9,6 +10,122 @@ pub(crate) const CUTOUT_REVEAL_OPACITY: f32 = 0.5;
 
 pub(crate) type SurfaceBounds = Rc<Cell<Option<Bounds<Pixels>>>>;
 
+#[derive(Clone, Copy)]
+struct FittedGeometry {
+    bounds: Bounds<Pixels>,
+    width: f32,
+    height: f32,
+    overflow_x: f32,
+    overflow_y: f32,
+}
+
+fn fitted_geometry(
+    source_width: f32,
+    source_height: f32,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+) -> Option<FittedGeometry> {
+    let width = f32::from(bounds.size.width);
+    let height = f32::from(bounds.size.height);
+    if width <= 0.0
+        || height <= 0.0
+        || !width.is_finite()
+        || !height.is_finite()
+        || source_width <= 0.0
+        || source_height <= 0.0
+        || !source_width.is_finite()
+        || !source_height.is_finite()
+    {
+        return None;
+    }
+
+    let adjustment = adjustment.normalized();
+    let cover = (width / source_width).max(height / source_height);
+    let fitted_width = (source_width * cover * adjustment.zoom).max(width);
+    let fitted_height = (source_height * cover * adjustment.zoom).max(height);
+    let overflow_x = (fitted_width - width).max(0.0);
+    let overflow_y = (fitted_height - height).max(0.0);
+    let fitted = Bounds::new(
+        point(
+            bounds.left() - px(overflow_x * adjustment.focal_x),
+            bounds.top() - px(overflow_y * adjustment.focal_y),
+        ),
+        size(px(fitted_width), px(fitted_height)),
+    );
+    Some(FittedGeometry {
+        bounds: fitted,
+        width: fitted_width,
+        height: fitted_height,
+        overflow_x,
+        overflow_y,
+    })
+}
+
+fn source_geometry(
+    source: &RenderImage,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+) -> Option<FittedGeometry> {
+    let source_size = source.size(0);
+    fitted_geometry(
+        source_size.width.0 as f32,
+        source_size.height.0 as f32,
+        bounds,
+        adjustment,
+    )
+}
+
+/// Translate a direct-manipulation drag into viewport-independent framing.
+pub(crate) fn pan_adjustment(
+    source: &RenderImage,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+    delta: Point<Pixels>,
+) -> NewThreadBackgroundAdjustment {
+    let adjustment = adjustment.normalized();
+    let Some(geometry) = source_geometry(source, bounds, adjustment) else {
+        return adjustment;
+    };
+    let mut next = adjustment;
+    if geometry.overflow_x > 0.0 {
+        next.focal_x -= f32::from(delta.x) / geometry.overflow_x;
+    }
+    if geometry.overflow_y > 0.0 {
+        next.focal_y -= f32::from(delta.y) / geometry.overflow_y;
+    }
+    next.normalized()
+}
+
+/// Preserve the source pixel beneath `anchor` while changing magnification.
+pub(crate) fn zoom_adjustment_around(
+    source: &RenderImage,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+    zoom: f32,
+    anchor: Point<Pixels>,
+) -> NewThreadBackgroundAdjustment {
+    let adjustment = adjustment.normalized();
+    let Some(previous) = source_geometry(source, bounds, adjustment) else {
+        return adjustment;
+    };
+    let mut next = NewThreadBackgroundAdjustment { zoom, ..adjustment }.normalized();
+    let Some(fitted) = source_geometry(source, bounds, next) else {
+        return adjustment;
+    };
+
+    let source_x = f32::from(anchor.x - previous.bounds.left()) / previous.width;
+    let source_y = f32::from(anchor.y - previous.bounds.top()) / previous.height;
+    if fitted.overflow_x > 0.0 {
+        let desired_left = f32::from(anchor.x) - source_x * fitted.width;
+        next.focal_x = (f32::from(bounds.left()) - desired_left) / fitted.overflow_x;
+    }
+    if fitted.overflow_y > 0.0 {
+        let desired_top = f32::from(anchor.y) - source_y * fitted.height;
+        next.focal_y = (f32::from(bounds.top()) - desired_top) / fitted.overflow_y;
+    }
+    next.normalized()
+}
+
 fn mask(bounds: Bounds<Pixels>, composer: Bounds<Pixels>, cutout: bool) -> ImageAlphaMask {
     let height = f32::from(bounds.size.height);
     // Keep the cleared area open through the hero's bottom. A taller image
@@ -46,6 +163,44 @@ fn mask(bounds: Bounds<Pixels>, composer: Bounds<Pixels>, cutout: bool) -> Image
     }
 }
 
+fn adjusted_image_paint(
+    source: &RenderImage,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+    corner_radii: Corners<Pixels>,
+) -> Option<(Bounds<Pixels>, Bounds<Pixels>, Corners<Pixels>)> {
+    let fitted = source_geometry(source, bounds, adjustment)?;
+    Some((bounds, fitted.bounds, corner_radii))
+}
+
+fn paint_adjusted_with_mask(
+    source: Arc<RenderImage>,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+    corner_radii: Corners<Pixels>,
+    mask: Option<ImageAlphaMask>,
+    window: &mut Window,
+) {
+    let Some((visible, fitted, corner_radii)) =
+        adjusted_image_paint(&source, bounds, adjustment, corner_radii)
+    else {
+        return;
+    };
+    let _ = window.paint_image_fitted_masked(visible, fitted, corner_radii, source, 0, false, mask);
+}
+
+/// Paint the exact responsive crop used by the new-thread hero, without its
+/// composer mask. Appearance uses this for a faithful adjustment preview.
+pub(crate) fn paint_adjusted(
+    source: Arc<RenderImage>,
+    bounds: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
+    corner_radii: Corners<Pixels>,
+    window: &mut Window,
+) {
+    paint_adjusted_with_mask(source, bounds, adjustment, corner_radii, None, window);
+}
+
 /// All elements have finished prepaint before this reads the measured surface,
 /// so the first visible frame uses the current composer, including on sidebar
 /// resize and right-panel handoffs. Object-fit cropping is independent.
@@ -53,32 +208,17 @@ pub(crate) fn paint(
     source: Arc<RenderImage>,
     bounds: Bounds<Pixels>,
     composer: Bounds<Pixels>,
+    adjustment: NewThreadBackgroundAdjustment,
     cutout: bool,
     window: &mut Window,
 ) {
-    let width = f32::from(bounds.size.width);
-    let height = f32::from(bounds.size.height);
-    let source_size = source.size(0);
-    if width <= 0.0 || height <= 0.0 || source_size.width.0 <= 0 || source_size.height.0 <= 0 {
-        return;
-    }
-    let scale = (width / source_size.width.0 as f32).max(height / source_size.height.0 as f32);
-    let fitted_size = size(
-        px(source_size.width.0 as f32 * scale),
-        px(source_size.height.0 as f32 * scale),
-    );
-    let fitted = Bounds::new(
-        bounds.center() - point(fitted_size.width * 0.5, fitted_size.height * 0.5),
-        fitted_size,
-    );
-    let _ = window.paint_image_fitted_masked(
+    paint_adjusted_with_mask(
+        source,
         bounds,
-        fitted,
+        adjustment,
         Default::default(),
-        source,
-        0,
-        false,
         Some(mask(bounds, composer, cutout)),
+        window,
     );
 }
 
@@ -87,6 +227,221 @@ mod tests {
     use super::*;
     use gpui::{Context, Render, canvas, div, prelude::*};
 
+    fn hero(width: f32, height: f32) -> Bounds<Pixels> {
+        Bounds::new(point(px(40.0), px(24.0)), size(px(width), px(height)))
+    }
+
+    fn fitted(
+        source: (f32, f32),
+        viewport: Bounds<Pixels>,
+        adjustment: NewThreadBackgroundAdjustment,
+    ) -> FittedGeometry {
+        fitted_geometry(source.0, source.1, viewport, adjustment).unwrap()
+    }
+
+    fn assert_near(actual: Pixels, expected: Pixels) {
+        assert!(
+            (f32::from(actual - expected)).abs() < 0.001,
+            "expected {expected:?}, got {actual:?}"
+        );
+    }
+
+    fn source(width: u32, height: u32) -> RenderImage {
+        RenderImage::new([image::Frame::new(image::RgbaImage::from_pixel(
+            width,
+            height,
+            image::Rgba([79, 151, 233, 180]),
+        ))])
+    }
+
+    #[test]
+    fn default_adjustment_is_the_existing_centered_cover_crop() {
+        let viewport = hero(1000.0, 500.0);
+        let crop = fitted(
+            (1600.0, 900.0),
+            viewport,
+            NewThreadBackgroundAdjustment::default(),
+        );
+        assert_eq!(crop.bounds.size.width, px(1000.0));
+        assert_eq!(crop.bounds.size.height, px(562.5));
+        assert_eq!(crop.bounds.left(), viewport.left());
+        assert_eq!(crop.bounds.top(), viewport.top() - px(31.25));
+        assert_eq!(crop.bounds.center(), viewport.center());
+    }
+
+    #[test]
+    fn focal_extremes_align_the_overflowing_image_edges() {
+        let viewport = hero(1000.0, 500.0);
+        let start = fitted(
+            (1600.0, 900.0),
+            viewport,
+            NewThreadBackgroundAdjustment {
+                focal_x: 0.0,
+                focal_y: 0.0,
+                zoom: 2.0,
+            },
+        );
+        assert_eq!(start.bounds.left(), viewport.left());
+        assert_eq!(start.bounds.top(), viewport.top());
+
+        let end = fitted(
+            (1600.0, 900.0),
+            viewport,
+            NewThreadBackgroundAdjustment {
+                focal_x: 1.0,
+                focal_y: 1.0,
+                zoom: 2.0,
+            },
+        );
+        assert_near(end.bounds.right(), viewport.right());
+        assert_near(end.bounds.bottom(), viewport.bottom());
+    }
+
+    #[test]
+    fn zoom_multiplies_cover_before_positioning() {
+        let viewport = hero(1000.0, 500.0);
+        let base = fitted(
+            (1600.0, 900.0),
+            viewport,
+            NewThreadBackgroundAdjustment::default(),
+        );
+        let zoomed = fitted(
+            (1600.0, 900.0),
+            viewport,
+            NewThreadBackgroundAdjustment {
+                zoom: 2.0,
+                ..Default::default()
+            },
+        );
+        assert_near(zoomed.bounds.size.width, base.bounds.size.width * 2.0);
+        assert_near(zoomed.bounds.size.height, base.bounds.size.height * 2.0);
+        assert_eq!(zoomed.bounds.center(), viewport.center());
+    }
+
+    #[test]
+    fn resizing_preserves_the_normalized_focal_alignment() {
+        let adjustment = NewThreadBackgroundAdjustment {
+            focal_x: 0.23,
+            focal_y: 0.71,
+            zoom: 2.2,
+        };
+        for viewport in [hero(420.0, 300.0), hero(960.0, 420.0), hero(1200.0, 760.0)] {
+            let crop = fitted((1600.0, 900.0), viewport, adjustment);
+            let x = f32::from(viewport.left() - crop.bounds.left()) / crop.overflow_x;
+            let y = f32::from(viewport.top() - crop.bounds.top()) / crop.overflow_y;
+            assert!((x - adjustment.focal_x).abs() < 0.0001);
+            assert!((y - adjustment.focal_y).abs() < 0.0001);
+        }
+    }
+
+    #[test]
+    fn every_supported_crop_covers_the_entire_viewport() {
+        for source in [(900.0, 1600.0), (1600.0, 900.0), (1000.0, 1000.0)] {
+            for viewport in [hero(360.0, 760.0), hero(1000.0, 500.0), hero(640.0, 640.0)] {
+                for focal_x in [0.0, 0.37, 1.0] {
+                    for focal_y in [0.0, 0.61, 1.0] {
+                        for zoom in [1.0, 1.8, NewThreadBackgroundAdjustment::MAX_ZOOM] {
+                            let crop = fitted(
+                                source,
+                                viewport,
+                                NewThreadBackgroundAdjustment {
+                                    focal_x,
+                                    focal_y,
+                                    zoom,
+                                },
+                            );
+                            assert!(crop.bounds.left() <= viewport.left());
+                            assert!(crop.bounds.top() <= viewport.top());
+                            assert!(crop.bounds.right() >= viewport.right());
+                            assert!(crop.bounds.bottom() >= viewport.bottom());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn masked_passes_share_identical_adjusted_geometry() {
+        let viewport = hero(1000.0, 500.0);
+        let composer = Bounds::new(point(px(180.0), px(320.0)), size(px(720.0), px(124.0)));
+        let adjustment = NewThreadBackgroundAdjustment {
+            focal_x: 0.17,
+            focal_y: 0.82,
+            zoom: 1.7,
+        };
+        let main = fitted((1600.0, 900.0), viewport, adjustment);
+        let reveal = fitted((1600.0, 900.0), viewport, adjustment);
+        assert_eq!(main.bounds, reveal.bounds);
+        let main_mask = mask(viewport, composer, true);
+        let reveal_mask = mask(viewport, composer, false);
+        assert_ne!(main_mask.bounds, reveal_mask.bounds);
+        assert_eq!(main_mask.bottom_fade, reveal_mask.bottom_fade);
+    }
+
+    #[test]
+    fn pan_adjustment_tracks_direct_pointer_movement() {
+        let source = source(16, 9);
+        let viewport = hero(100.0, 50.0);
+        let adjustment = NewThreadBackgroundAdjustment {
+            zoom: 2.0,
+            ..Default::default()
+        };
+        let before = source_geometry(&source, viewport, adjustment).unwrap();
+        let next = pan_adjustment(&source, viewport, adjustment, point(px(10.0), px(-5.0)));
+        let after = source_geometry(&source, viewport, next).unwrap();
+        assert_near(after.bounds.left(), before.bounds.left() + px(10.0));
+        assert_near(after.bounds.top(), before.bounds.top() - px(5.0));
+    }
+
+    #[test]
+    fn pointer_anchored_zoom_keeps_the_same_source_pixel_underneath() {
+        let source = source(16, 9);
+        let viewport = hero(100.0, 50.0);
+        let adjustment = NewThreadBackgroundAdjustment {
+            zoom: 1.5,
+            ..Default::default()
+        };
+        let anchor = point(viewport.left() + px(60.0), viewport.top() + px(30.0));
+        let before = source_geometry(&source, viewport, adjustment).unwrap();
+        let source_x = f32::from(anchor.x - before.bounds.left()) / before.width;
+        let source_y = f32::from(anchor.y - before.bounds.top()) / before.height;
+
+        let next = zoom_adjustment_around(&source, viewport, adjustment, 2.4, anchor);
+        let after = source_geometry(&source, viewport, next).unwrap();
+        let next_source_x = f32::from(anchor.x - after.bounds.left()) / after.width;
+        let next_source_y = f32::from(anchor.y - after.bounds.top()) / after.height;
+        assert!((next_source_x - source_x).abs() < 0.0001);
+        assert!((next_source_y - source_y).abs() < 0.0001);
+    }
+
+    #[test]
+    fn preview_paint_keeps_rounded_viewport_corners_when_panning_and_zooming() {
+        let source = source(16, 9);
+        let viewport = hero(100.0, 50.0);
+        let rounded = Corners::all(px(11.0));
+        let initial = NewThreadBackgroundAdjustment::default();
+        let zoomed = zoom_adjustment_around(&source, viewport, initial, 2.0, viewport.center());
+        let panned = pan_adjustment(&source, viewport, zoomed, point(px(10.0), px(-5.0)));
+
+        for adjustment in [initial, zoomed, panned] {
+            let (visible, fitted, corners) =
+                adjusted_image_paint(&source, viewport, adjustment, rounded).unwrap();
+            let (hero_visible, hero_fitted, hero_corners) =
+                adjusted_image_paint(&source, viewport, adjustment, Default::default()).unwrap();
+            assert_eq!(visible, viewport);
+            assert_eq!(corners, rounded);
+            assert_eq!(hero_corners, Corners::all(px(0.0)));
+            assert_eq!((visible, fitted), (hero_visible, hero_fitted));
+            assert_eq!(
+                fitted,
+                source_geometry(&source, viewport, adjustment)
+                    .unwrap()
+                    .bounds
+            );
+        }
+    }
+
     #[gpui::test]
     fn background_paint_sees_same_frame_composer_bounds_even_when_painted_first(
         cx: &mut gpui::TestAppContext,
@@ -113,7 +468,14 @@ mod tests {
                             move |bounds, _, window, _| {
                                 painted.set(surface.get());
                                 if let Some(composer) = surface.get() {
-                                    paint(source, bounds, composer, true, window);
+                                    paint(
+                                        source,
+                                        bounds,
+                                        composer,
+                                        NewThreadBackgroundAdjustment::default(),
+                                        true,
+                                        window,
+                                    );
                                 }
                             },
                         )
diff --git a/crates/ui/src/settings.rs b/crates/ui/src/settings.rs
index b3d9a63f2c..e142454e63 100644
--- a/crates/ui/src/settings.rs
+++ b/crates/ui/src/settings.rs
@@ -65,13 +65,50 @@ pub const FILES_AUTOSAVE_DELAY_MAX_MS: u64 = 10_000;
 const FILE_NAME: &str = "ui-settings.json";
 const NEW_THREAD_BACKGROUND_DIR: &str = "new-thread-backgrounds";
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct NewThreadComposerBackground {
     /// Managed copy inside Zeron's device-local data directory.
     pub path: String,
     /// Original file name shown in Appearance settings.
     pub name: String,
+    /// Viewport-relative framing, kept with the image it belongs to.
+    #[serde(default)]
+    pub adjustment: NewThreadBackgroundAdjustment,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct NewThreadBackgroundAdjustment {
+    /// Normalized horizontal alignment of the overflowing image: 0 left, 1 right.
+    pub focal_x: f32,
+    /// Normalized vertical alignment of the overflowing image: 0 top, 1 bottom.
+    pub focal_y: f32,
+    /// Multiplier applied after the image has been scaled to cover the viewport.
+    pub zoom: f32,
+}
+
+impl NewThreadBackgroundAdjustment {
+    pub const MIN_ZOOM: f32 = 1.0;
+    pub const MAX_ZOOM: f32 = 4.0;
+
+    pub fn normalized(mut self) -> Self {
+        let defaults = Self::default();
+        self.focal_x = clamp_or(self.focal_x, 0.0, 1.0, defaults.focal_x);
+        self.focal_y = clamp_or(self.focal_y, 0.0, 1.0, defaults.focal_y);
+        self.zoom = clamp_or(self.zoom, Self::MIN_ZOOM, Self::MAX_ZOOM, defaults.zoom);
+        self
+    }
+}
+
+impl Default for NewThreadBackgroundAdjustment {
+    fn default() -> Self {
+        Self {
+            focal_x: 0.5,
+            focal_y: 0.5,
+            zoom: 1.0,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -390,6 +427,7 @@ fn prepare_background_file(
     let replacement = NewThreadComposerBackground {
         path: destination.to_string_lossy().into_owned(),
         name: staged.name,
+        adjustment: NewThreadBackgroundAdjustment::default(),
     };
     Ok(PreparedBackgroundFile(Some(replacement)))
 }
@@ -471,6 +509,19 @@ pub fn set_new_thread_background_effect(effect: NewThreadBackgroundEffect, cx: &
     }
 }
 
+pub fn set_new_thread_background_adjustment(
+    adjustment: NewThreadBackgroundAdjustment,
+    cx: &mut App,
+) {
+    if update(SavePolicy::Immediate, cx, |settings| {
+        if let Some(background) = settings.new_thread_composer_background.as_mut() {
+            background.adjustment = adjustment.normalized();
+        }
+    }) {
+        cx.refresh_windows();
+    }
+}
+
 fn remove_managed_new_thread_background(
     background: Option<&NewThreadComposerBackground>,
     backgrounds_dir: &Path,
@@ -1564,6 +1615,9 @@ impl UiSettings {
         self.git_history_column_widths = self.git_history_column_widths.clamped();
         self.git_history_column_order = self.git_history_column_order.normalized();
         self.ui_font_size = self.ui_font_size.normalized();
+        if let Some(background) = self.new_thread_composer_background.as_mut() {
+            background.adjustment = background.adjustment.normalized();
+        }
         self.keymap.heal_jump_slots();
         self.keymap.heal_reserved_composer_shortcuts();
         self
@@ -2177,6 +2231,7 @@ mod tests {
             Some(&NewThreadComposerBackground {
                 path: unrelated.to_string_lossy().into_owned(),
                 name: "keep.png".into(),
+                adjustment: NewThreadBackgroundAdjustment::default(),
             }),
             &backgrounds,
         );
@@ -2185,12 +2240,115 @@ mod tests {
             Some(&NewThreadComposerBackground {
                 path: managed.to_string_lossy().into_owned(),
                 name: "owned.png".into(),
+                adjustment: NewThreadBackgroundAdjustment::default(),
             }),
             &backgrounds,
         );
         assert!(!managed.exists());
     }
 
+    #[test]
+    fn legacy_background_defaults_to_centered_cover_adjustment() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(
+            UiSettings::path(dir.path()),
+            r#"{"newThreadComposerBackground":{"path":"managed.png","name":"background.png"}}"#,
+        )
+        .unwrap();
+
+        let loaded = UiSettings::load(dir.path());
+        assert_eq!(
+            loaded.new_thread_composer_background.unwrap().adjustment,
+            NewThreadBackgroundAdjustment::default()
+        );
+    }
+
+    #[test]
+    fn background_adjustment_normalizes_invalid_and_out_of_range_values() {
+        let normalized = NewThreadBackgroundAdjustment {
+            focal_x: f32::NAN,
+            focal_y: 2.0,
+            zoom: f32::INFINITY,
+        }
+        .normalized();
+        assert_eq!(
+            normalized,
+            NewThreadBackgroundAdjustment {
+                focal_x: 0.5,
+                focal_y: 1.0,
+                zoom: 1.0,
+            }
+        );
+
+        let clamped = UiSettings {
+            new_thread_composer_background: Some(NewThreadComposerBackground {
+                path: "managed.png".into(),
+                name: "background.png".into(),
+                adjustment: NewThreadBackgroundAdjustment {
+                    focal_x: -1.0,
+                    focal_y: 0.25,
+                    zoom: 99.0,
+                },
+            }),
+            ..Default::default()
+        }
+        .clamped();
+        assert_eq!(
+            clamped.new_thread_composer_background.unwrap().adjustment,
+            NewThreadBackgroundAdjustment {
+                focal_x: 0.0,
+                focal_y: 0.25,
+                zoom: NewThreadBackgroundAdjustment::MAX_ZOOM,
+            }
+        );
+    }
+
+    #[gpui::test]
+    fn background_adjustment_setter_normalizes_and_persists_immediately(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            let settings = UiSettings {
+                new_thread_composer_background: Some(NewThreadComposerBackground {
+                    path: "managed.png".into(),
+                    name: "background.png".into(),
+                    adjustment: NewThreadBackgroundAdjustment::default(),
+                }),
+                ..Default::default()
+            };
+            init(settings, dir.path(), cx);
+            set_new_thread_background_adjustment(
+                NewThreadBackgroundAdjustment {
+                    focal_x: -0.5,
+                    focal_y: 0.7,
+                    zoom: 2.25,
+                },
+                cx,
+            );
+
+            let expected = NewThreadBackgroundAdjustment {
+                focal_x: 0.0,
+                focal_y: 0.7,
+                zoom: 2.25,
+            };
+            assert_eq!(
+                current(cx)
+                    .new_thread_composer_background
+                    .unwrap()
+                    .adjustment,
+                expected
+            );
+            assert_eq!(
+                UiSettings::load(dir.path())
+                    .new_thread_composer_background
+                    .unwrap()
+                    .adjustment,
+                expected
+            );
+        });
+    }
+
     #[gpui::test]
     fn invalid_background_replacement_preserves_previous_image_and_settings(
         cx: &mut gpui::TestAppContext,
@@ -2245,6 +2403,14 @@ mod tests {
             };
             init(initial, dir.path(), cx);
             install_new_thread_composer_background(&first, cx).unwrap();
+            set_new_thread_background_adjustment(
+                NewThreadBackgroundAdjustment {
+                    focal_x: 0.2,
+                    focal_y: 0.8,
+                    zoom: 2.0,
+                },
+                cx,
+            );
             let old_path = current(cx).new_thread_composer_background.unwrap().path;
             install_new_thread_composer_background(&second, cx).unwrap();
             let settings = current(cx);
@@ -2259,6 +2425,10 @@ mod tests {
                 settings.new_thread_background_effect,
                 NewThreadBackgroundEffect::Ascii
             );
+            assert_eq!(
+                replacement.adjustment,
+                NewThreadBackgroundAdjustment::default()
+            );
             assert!(!Path::new(&old_path).exists());
             assert!(first.exists() && second.exists());
             assert_eq!(
@@ -2416,6 +2586,11 @@ mod tests {
             new_thread_composer_background: Some(NewThreadComposerBackground {
                 path: "/tmp/zeron/new-thread-background.png".into(),
                 name: "background.png".into(),
+                adjustment: NewThreadBackgroundAdjustment {
+                    focal_x: 0.25,
+                    focal_y: 0.75,
+                    zoom: 1.8,
+                },
             }),
             wallpaper_folder: Some("/tmp/wallpapers".into()),
             wallpaper_source: Some("/tmp/wallpapers/background.png".into()),
@@ -2434,6 +2609,9 @@ mod tests {
         assert!(json.contains(r#""codeFencesFitContent": true"#));
         assert!(json.contains(r#""openWebLinksInZeron": false"#));
         assert!(json.contains(r#""newThreadBackgroundEffect": "ascii""#));
+        assert!(json.contains(r#""focalX": 0.25"#));
+        assert!(json.contains(r#""focalY": 0.75"#));
+        assert!(json.contains(r#""zoom": 1.8"#));
         assert!(json.contains(r#""reduceMotion": "on""#));
         assert!(json.contains(r#""pauseAnimationsInBackground": true"#));
         assert!(json.contains(r#""terminalFontFamily": "installed:Menlo""#));
diff --git a/crates/ui/src/settings/appearance.rs b/crates/ui/src/settings/appearance.rs
index 9b25d004c6..3fc10efcce 100644
--- a/crates/ui/src/settings/appearance.rs
+++ b/crates/ui/src/settings/appearance.rs
@@ -5,11 +5,12 @@ use std::cell::Cell;
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
+use std::sync::Arc;
 
 use gpui::{
-    AnyElement, Context, Entity, EventEmitter, FocusHandle, Focusable, Hsla, IntoElement,
-    KeyDownEvent, ObjectFit, Render, SharedString, StyledImage as _, Subscription, Window, div,
-    img, prelude::*, px,
+    AnyElement, Bounds, Context, Entity, EventEmitter, FocusHandle, Focusable, Hsla, IntoElement,
+    KeyDownEvent, ObjectFit, Pixels, Point, Render, ScrollDelta, SharedString, StyledImage as _,
+    Subscription, Window, div, img, point, prelude::*, px,
 };
 use zeron_theme::vscode::{ImportReport, SourceCompilation};
 use zeron_theme::{
@@ -39,6 +40,91 @@ struct ImportDialog {
     error: Option<SharedString>,
 }
 
+struct BackgroundAdjustmentDialog {
+    focus: FocusHandle,
+    zoom_focus: FocusHandle,
+    end_focus: FocusHandle,
+    return_focus: Option<FocusHandle>,
+    path: String,
+    source: Option<Arc<gpui::RenderImage>>,
+    draft: crate::settings::NewThreadBackgroundAdjustment,
+    preview_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
+    zoom_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
+    drag: Option<(
+        Point<Pixels>,
+        crate::settings::NewThreadBackgroundAdjustment,
+    )>,
+    pinch: Option<(f32, f32)>,
+}
+
+#[derive(Clone)]
+struct BackgroundAdjustmentDrag;
+
+impl Render for BackgroundAdjustmentDrag {
+    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+        gpui::Empty
+    }
+}
+
+#[derive(Clone)]
+struct BackgroundAdjustmentZoomDrag;
+
+impl Render for BackgroundAdjustmentZoomDrag {
+    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+        gpui::Empty
+    }
+}
+
+const BACKGROUND_ZOOM_STEP: f32 = 0.1;
+
+fn background_pinch_factor(factor: f32, delta: f32, relative_delta: bool) -> f32 {
+    if !delta.is_finite() {
+        return factor;
+    }
+    // Direct Manipulation reports a ratio to the last scale; the other
+    // native backends report an additive change to the gesture's scale.
+    let next = if relative_delta {
+        factor * (1.0 + delta)
+    } else {
+        factor + delta
+    };
+    next.max(0.001)
+}
+
+fn background_zoom_fraction(zoom: f32) -> f32 {
+    let minimum = crate::settings::NewThreadBackgroundAdjustment::MIN_ZOOM;
+    let maximum = crate::settings::NewThreadBackgroundAdjustment::MAX_ZOOM;
+    ((zoom - minimum) / (maximum - minimum)).clamp(0.0, 1.0)
+}
+
+fn background_zoom_at_x(bounds: Bounds<Pixels>, x: Pixels) -> f32 {
+    let minimum = crate::settings::NewThreadBackgroundAdjustment::MIN_ZOOM;
+    let maximum = crate::settings::NewThreadBackgroundAdjustment::MAX_ZOOM;
+    let fraction = ((f32::from(x - bounds.left()) - 7.0)
+        / (f32::from(bounds.size.width) - 14.0).max(1.0))
+    .clamp(0.0, 1.0);
+    minimum + fraction * (maximum - minimum)
+}
+
+fn background_preview_size(
+    viewport: gpui::Size<Pixels>,
+    sidebar_width: f32,
+    sidebar_collapsed: bool,
+) -> gpui::Size<Pixels> {
+    let hero_width = (f32::from(viewport.width)
+        - if sidebar_collapsed {
+            0.0
+        } else {
+            sidebar_width
+        })
+    .max(1.0);
+    let hero_height =
+        crate::shell::new_thread_background_height(f32::from(viewport.height)).max(1.0);
+    let max_width = (f32::from(viewport.width) - 84.0).clamp(1.0, 556.0);
+    let scale = (max_width / hero_width).min(258.0 / hero_height);
+    gpui::size(px(hero_width * scale), px(hero_height * scale))
+}
+
 /// The three independently configurable font slots. Interface and code/diff
 /// draw from the whole catalog — proportional faces are legal there. The
 /// terminal draws from the fixed-width subset only.
@@ -227,6 +313,7 @@ pub struct AppearancePage {
     background_effect_select: widgets::SelectState,
     reduce_motion_select: widgets::SelectState,
     import_dialog: Option<ImportDialog>,
+    background_adjustment_dialog: Option<BackgroundAdjustmentDialog>,
     review_entry: Option<String>,
     library_error: Option<SharedString>,
     background_error: Option<SharedString>,
@@ -490,6 +577,7 @@ impl AppearancePage {
             background_effect_select: widgets::SelectState::default(),
             reduce_motion_select: widgets::SelectState::default(),
             import_dialog: None,
+            background_adjustment_dialog: None,
             review_entry: None,
             library_error: None,
             background_error: None,
@@ -968,6 +1056,163 @@ impl AppearancePage {
         cx.notify();
     }
 
+    fn open_background_adjustment(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(background) = crate::settings::current(cx).new_thread_composer_background else {
+            return;
+        };
+        let focus = cx.focus_handle();
+        let zoom_focus = cx.focus_handle();
+        let return_focus = window.focused(cx);
+        window.focus(&focus, cx);
+        self.background_adjustment_dialog = Some(BackgroundAdjustmentDialog {
+            focus,
+            zoom_focus,
+            end_focus: cx.focus_handle(),
+            return_focus,
+            path: background.path,
+            source: None,
+            draft: background.adjustment.normalized(),
+            preview_bounds: Rc::default(),
+            zoom_bounds: Rc::default(),
+            drag: None,
+            pinch: None,
+        });
+        cx.notify();
+    }
+
+    fn dismiss_background_adjustment(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(dialog) = self.background_adjustment_dialog.take()
+            && let Some(focus) = dialog.return_focus
+        {
+            window.focus(&focus, cx);
+        }
+        cx.notify();
+    }
+
+    fn apply_background_adjustment(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(dialog) = self.background_adjustment_dialog.as_ref() else {
+            return;
+        };
+        // A shuffle or replacement must not receive a draft for another image.
+        if dialog.source.is_none()
+            || crate::settings::current(cx)
+                .new_thread_composer_background
+                .as_ref()
+                .is_none_or(|background| background.path != dialog.path)
+        {
+            return;
+        }
+        crate::settings::set_new_thread_background_adjustment(dialog.draft, cx);
+        self.dismiss_background_adjustment(window, cx);
+    }
+
+    fn reset_background_adjustment(&mut self, cx: &mut Context<Self>) {
+        if let Some(dialog) = self.background_adjustment_dialog.as_mut() {
+            dialog.draft = Default::default();
+            dialog.drag = None;
+            dialog.pinch = None;
+        }
+        cx.notify();
+    }
+
+    fn set_background_zoom(&mut self, zoom: f32, cx: &mut Context<Self>) {
+        self.zoom_background_around(zoom, None, cx);
+    }
+
+    fn set_background_zoom_from_x(&mut self, x: Pixels, cx: &mut Context<Self>) {
+        let Some(bounds) = self
+            .background_adjustment_dialog
+            .as_ref()
+            .and_then(|dialog| dialog.zoom_bounds.get())
+        else {
+            return;
+        };
+        self.set_background_zoom(background_zoom_at_x(bounds, x), cx);
+    }
+
+    fn zoom_background_around(
+        &mut self,
+        zoom: f32,
+        anchor: Option<Point<Pixels>>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(dialog) = self.background_adjustment_dialog.as_mut() else {
+            return;
+        };
+        if dialog.source.is_none() {
+            return;
+        }
+        let zoom = zoom.clamp(
+            crate::settings::NewThreadBackgroundAdjustment::MIN_ZOOM,
+            crate::settings::NewThreadBackgroundAdjustment::MAX_ZOOM,
+        );
+        let next = match (dialog.preview_bounds.get(), dialog.source.as_ref()) {
+            (Some(bounds), Some(source)) => {
+                crate::new_thread_background_mask::zoom_adjustment_around(
+                    source,
+                    bounds,
+                    dialog.draft,
+                    zoom,
+                    anchor.unwrap_or_else(|| bounds.center()),
+                )
+            }
+            _ => crate::settings::NewThreadBackgroundAdjustment {
+                zoom,
+                ..dialog.draft
+            },
+        };
+        if dialog.draft != next {
+            dialog.draft = next;
+            dialog.drag = None;
+            cx.notify();
+        }
+    }
+
+    fn pan_background(&mut self, delta: Point<f32>, cx: &mut Context<Self>) {
+        let Some(dialog) = self.background_adjustment_dialog.as_mut() else {
+            return;
+        };
+        let (Some(bounds), Some(source)) = (dialog.preview_bounds.get(), dialog.source.as_ref())
+        else {
+            return;
+        };
+        let before = dialog.draft;
+        dialog.draft = crate::new_thread_background_mask::pan_adjustment(
+            source,
+            bounds,
+            dialog.draft,
+            point(px(delta.x), px(delta.y)),
+        );
+        if dialog.draft != before {
+            cx.notify();
+        }
+    }
+
+    fn drag_background(&mut self, position: Point<Pixels>, cx: &mut Context<Self>) {
+        let Some(dialog) = self.background_adjustment_dialog.as_ref() else {
+            return;
+        };
+        let Some((start, initial)) = dialog.drag else {
+            return;
+        };
+        let delta = point(
+            f32::from(position.x - start.x),
+            f32::from(position.y - start.y),
+        );
+        if let Some(dialog) = self.background_adjustment_dialog.as_mut() {
+            dialog.draft = initial;
+        }
+        self.pan_background(delta, cx);
+    }
+
+    fn finish_background_drag(&mut self, cx: &mut Context<Self>) {
+        if let Some(dialog) = self.background_adjustment_dialog.as_mut()
+            && dialog.drag.take().is_some()
+        {
+            cx.notify();
+        }
+    }
+
     fn finish_import(&mut self, cx: &mut Context<Self>) {
         let Some(dialog) = self.import_dialog.as_mut() else {
             return;
@@ -2334,6 +2579,523 @@ impl AppearancePage {
         Some(popover::modal("theme-import-dialog", viewport, card))
     }
 
+    fn render_background_adjustment_dialog(
+        &mut self,
+        viewport: gpui::Size<Pixels>,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        let dialog = self.background_adjustment_dialog.as_ref()?;
+        let focus = dialog.focus.clone();
+        let zoom_focus = dialog.zoom_focus.clone();
+        let end_focus = dialog.end_focus.clone();
+        let tab_start = focus.clone();
+        let tab_end = end_focus.clone();
+        let path = dialog.path.clone();
+        let draft = dialog.draft;
+        let preview_bounds = dialog.preview_bounds.clone();
+        let zoom_bounds = dialog.zoom_bounds.clone();
+        let dragging = dialog.drag.is_some();
+        let settings = crate::settings::current(cx);
+        let same_image = settings
+            .new_thread_composer_background
+            .as_ref()
+            .is_some_and(|background| background.path == path);
+        let available = Path::new(&path).is_file();
+        let source = (same_image && available)
+            .then(|| {
+                crate::new_thread_background_effects::prepare(
+                    settings.new_thread_background_effect,
+                    theme,
+                    Path::new(&path),
+                    cx,
+                )
+            })
+            .flatten();
+        let ready = source.is_some();
+        let preview_size =
+            background_preview_size(viewport, settings.sidebar_width, settings.sidebar_collapsed);
+        if let Some(dialog) = self.background_adjustment_dialog.as_mut() {
+            dialog.source = source.clone();
+        }
+
+        let paint_source = source.clone();
+        let measured_bounds = preview_bounds.clone();
+        let preview = div()
+            .id("new-thread-background-adjustment-preview")
+            .relative()
+            .w(preview_size.width + px(2.0))
+            .h(preview_size.height + px(2.0))
+            .overflow_hidden()
+            .rounded(px(12.0))
+            .border_1()
+            .border_color(crate::theme::hairline(0.12))
+            .bg(theme.bg)
+            .cursor(if !ready {
+                gpui::CursorStyle::Arrow
+            } else if dragging {
+                gpui::CursorStyle::ClosedHand
+            } else {
+                gpui::CursorStyle::OpenHand
+            })
+            .on_scroll_wheel(
+                cx.listener(|this, event: &gpui::ScrollWheelEvent, window, cx| {
+                    let delta = match event.delta {
+                        ScrollDelta::Pixels(delta) => f32::from(delta.y),
+                        ScrollDelta::Lines(delta) => delta.y * 40.0,
+                    };
+                    let Some(dialog) = this.background_adjustment_dialog.as_ref() else {
+                        return;
+                    };
+                    let zoom = dialog.draft.zoom * (delta * 0.0025).clamp(-2.0, 2.0).exp();
+                    this.zoom_background_around(zoom, Some(event.position), cx);
+                    cx.stop_propagation();
+                    window.prevent_default();
+                }),
+            )
+            .on_pinch(cx.listener(|this, event: &gpui::PinchEvent, window, cx| {
+                let Some(dialog) = this.background_adjustment_dialog.as_mut() else {
+                    return;
+                };
+                if event.phase == gpui::TouchPhase::Ended {
+                    dialog.pinch = None;
+                    return;
+                }
+                if event.phase == gpui::TouchPhase::Started {
+                    dialog.pinch = Some((dialog.draft.zoom, 1.0));
+                }
+                let current_zoom = dialog.draft.zoom;
+                let (start, factor) = dialog.pinch.get_or_insert((current_zoom, 1.0));
+                *factor =
+                    background_pinch_factor(*factor, event.delta, cfg!(target_os = "windows"));
+                let zoom = *start * *factor;
+                this.zoom_background_around(zoom, Some(event.position), cx);
+                cx.stop_propagation();
+                window.prevent_default();
+            }))
+            .on_mouse_down(
+                gpui::MouseButton::Left,
+                cx.listener(|this, event: &gpui::MouseDownEvent, window, cx| {
+                    let Some(dialog) = this.background_adjustment_dialog.as_mut() else {
+                        return;
+                    };
+                    if dialog.source.is_none() {
+                        return;
+                    }
+                    window.focus(&dialog.focus, cx);
+                    dialog.drag = Some((event.position, dialog.draft));
+                    cx.notify();
+                    cx.stop_propagation();
+                }),
+            )
+            .on_drag(BackgroundAdjustmentDrag, |drag, _, _, cx| {
+                cx.stop_propagation();
+                cx.new(|_| drag.clone())
+            })
+            .child(
+                gpui::canvas(
+                    move |bounds, _, _| measured_bounds.set(Some(bounds)),
+                    move |bounds, _, window, _| {
+                        if let Some(source) = paint_source.clone() {
+                            crate::new_thread_background_mask::paint_adjusted(
+                                source,
+                                bounds,
+                                draft,
+                                // Canvas content masks are rectangular; round the image
+                                // itself to the frame's 12px radius inside its 1px border.
+                                gpui::Corners::all(px(11.0)),
+                                window,
+                            );
+                        }
+                    },
+                )
+                .w(preview_size.width)
+                .h(preview_size.height),
+            )
+            .when(source.is_none(), |preview| {
+                preview.child(
+                    div()
+                        .absolute()
+                        .inset_0()
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .text_size(typography::ui_rems(11.5))
+                        .text_color(theme.text_muted)
+                        .child(if !same_image {
+                            "Background changed. Close and adjust the new image."
+                        } else if !available {
+                            "Image unavailable. Choose a replacement or remove it."
+                        } else {
+                            "Preparing preview…"
+                        }),
+                )
+            })
+            .when(dragging, |preview| {
+                preview
+                    .child(
+                        div()
+                            .absolute()
+                            .left(gpui::relative(1.0 / 3.0))
+                            .top_0()
+                            .bottom_0()
+                            .w(px(1.0))
+                            .bg(gpui::white().opacity(0.22)),
+                    )
+                    .child(
+                        div()
+                            .absolute()
+                            .left(gpui::relative(2.0 / 3.0))
+                            .top_0()
+                            .bottom_0()
+                            .w(px(1.0))
+                            .bg(gpui::white().opacity(0.22)),
+                    )
+                    .child(
+                        div()
+                            .absolute()
+                            .top(gpui::relative(1.0 / 3.0))
+                            .left_0()
+                            .right_0()
+                            .h(px(1.0))
+                            .bg(gpui::white().opacity(0.22)),
+                    )
+                    .child(
+                        div()
+                            .absolute()
+                            .top(gpui::relative(2.0 / 3.0))
+                            .left_0()
+                            .right_0()
+                            .h(px(1.0))
+                            .bg(gpui::white().opacity(0.22)),
+                    )
+            });
+
+        let zoom_fraction = background_zoom_fraction(draft.zoom);
+        let measured_zoom_bounds = zoom_bounds.clone();
+        let zoom_slider = div()
+            .id("new-thread-background-adjustment-zoom")
+            .track_focus(&zoom_focus)
+            .tab_index(0)
+            .role(gpui::Role::Slider)
+            .aria_label("Background zoom")
+            .aria_numeric_value(f64::from(draft.zoom * 100.0))
+            .aria_min_numeric_value(f64::from(
+                crate::settings::NewThreadBackgroundAdjustment::MIN_ZOOM * 100.0,
+            ))
+            .aria_max_numeric_value(f64::from(
+                crate::settings::NewThreadBackgroundAdjustment::MAX_ZOOM * 100.0,
+            ))
+            .aria_numeric_value_step(f64::from(BACKGROUND_ZOOM_STEP * 100.0))
+            .aria_value(format!("{:.0}%", draft.zoom * 100.0))
+            .focus_visible(|s| s.border_2().border_color(theme.accent))
+            .relative()
+            .w(px(168.0))
+            .h(px(28.0))
+            .cursor_pointer()
+            .on_mouse_down(
+                gpui::MouseButton::Left,
+                cx.listener(|this, event: &gpui::MouseDownEvent, window, cx| {
+                    if let Some(dialog) = this.background_adjustment_dialog.as_ref() {
+                        window.focus(&dialog.zoom_focus, cx);
+                    }
+                    this.set_background_zoom_from_x(event.position.x, cx);
+                    cx.stop_propagation();
+                    window.prevent_default();
+                }),
+            )
+            .on_drag(BackgroundAdjustmentZoomDrag, |drag, _, _, cx| {
+                cx.stop_propagation();
+                cx.new(|_| drag.clone())
+            })
+            .on_key_down(cx.listener(|this, event: &KeyDownEvent, window, cx| {
+                let Some(current) = this
+                    .background_adjustment_dialog
+                    .as_ref()
+                    .map(|dialog| dialog.draft.zoom)
+                else {
+                    return;
+                };
+                let next = match event.keystroke.key.as_str() {
+                    "left" | "down" => current - BACKGROUND_ZOOM_STEP,
+                    "right" | "up" => current + BACKGROUND_ZOOM_STEP,
+                    "home" => crate::settings::NewThreadBackgroundAdjustment::MIN_ZOOM,
+                    "end" => crate::settings::NewThreadBackgroundAdjustment::MAX_ZOOM,
+                    _ => return,
+                };
+                this.set_background_zoom(next, cx);
+                cx.stop_propagation();
+                window.prevent_default();
+            }))
+            .child(
+                gpui::canvas(
+                    move |bounds, _, _| measured_zoom_bounds.set(Some(bounds)),
+                    |_, _, _, _| {},
+                )
+                .absolute()
+                .inset_0(),
+            )
+            .child(
+                div()
+                    .absolute()
+                    .left(px(7.0))
+                    .right(px(7.0))
+                    .top(px(12.0))
+                    .h(px(4.0))
+                    .rounded_full()
+                    .bg(theme.border)
+                    .child(
+                        div()
+                            .h_full()
+                            .w(gpui::relative(zoom_fraction))
+                            .rounded_full()
+                            .bg(theme.accent),
+                    )
+                    .child(
+                        div()
+                            .absolute()
+                            .left(gpui::relative(zoom_fraction))
+                            .ml(px(-7.0))
+                            .top(px(-5.0))
+                            .size(px(14.0))
+                            .rounded_full()
+                            .bg(theme.accent),
+                    ),
+            );
+        let controls = div()
+            .mt(px(14.0))
+            .flex()
+            .items_center()
+            .justify_between()
+            .gap(px(12.0))
+            .child(
+                compact_action(theme, "Reset", "new-thread-background-adjustment-reset")
+                    .tab_index(0)
+                    .role(gpui::Role::Button)
+                    .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+                    .on_click(cx.listener(|this, _, _, cx| this.reset_background_adjustment(cx))),
+            )
+            .child(
+                div()
+                    .flex()
+                    .items_center()
+                    .gap(px(6.0))
+                    .child(
+                        compact_action(theme, "−", "new-thread-background-adjustment-zoom-out")
+                            .tab_index(0)
+                            .role(gpui::Role::Button)
+                            .aria_label("Zoom out")
+                            .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+                            .on_click(cx.listener(move |this, _, _, cx| {
+                                let Some(dialog) = this.background_adjustment_dialog.as_ref()
+                                else {
+                                    return;
+                                };
+                                this.set_background_zoom(
+                                    dialog.draft.zoom - BACKGROUND_ZOOM_STEP,
+                                    cx,
+                                );
+                            })),
+                    )
+                    .child(zoom_slider)
+                    .child(
+                        div()
+                            .w(px(52.0))
+                            .text_center()
+                            .text_size(typography::ui_rems(11.5))
+                            .text_color(theme.text_muted)
+                            .child(format!("{:.0}%", draft.zoom * 100.0)),
+                    )
+                    .child(
+                        compact_action(theme, "+", "new-thread-background-adjustment-zoom-in")
+                            .tab_index(0)
+                            .role(gpui::Role::Button)
+                            .aria_label("Zoom in")
+                            .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+                            .on_click(cx.listener(move |this, _, _, cx| {
+                                let Some(dialog) = this.background_adjustment_dialog.as_ref()
+                                else {
+                                    return;
+                                };
+                                this.set_background_zoom(
+                                    dialog.draft.zoom + BACKGROUND_ZOOM_STEP,
+                                    cx,
+                                );
+                            })),
+                    ),
+            );
+
+        let footer = div()
+            .mt(px(18.0))
+            .pt(px(12.0))
+            .border_t_1()
+            .border_color(theme.border)
+            .flex()
+            .items_center()
+            .justify_end()
+            .gap(px(8.0))
+            .child(
+                compact_action(theme, "Cancel", "new-thread-background-adjustment-cancel")
+                    .h(px(34.0))
+                    .px(px(13.0))
+                    .tab_index(0)
+                    .role(gpui::Role::Button)
+                    .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+                    .on_click(cx.listener(|this, _, window, cx| {
+                        this.dismiss_background_adjustment(window, cx)
+                    })),
+            )
+            .child(
+                widgets::text_action(theme, widgets::ActionTone::Solid, "Apply")
+                    .id("new-thread-background-adjustment-apply")
+                    .h(px(34.0))
+                    .px(px(14.0))
+                    .py(px(0.0))
+                    .flex()
+                    .items_center()
+                    .when(!ready, |button| button.opacity(0.45))
+                    .when(ready, |button| {
+                        button
+                            .tab_index(0)
+                            .role(gpui::Role::Button)
+                            .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                this.apply_background_adjustment(window, cx)
+                            }))
+                    }),
+            );
+
+        let header = div()
+            .flex()
+            .items_start()
+            .gap(px(16.0))
+            .child(
+                div()
+                    .flex_1()
+                    .min_w_0()
+                    .child(popover::dialog_title(theme, "Adjust background"))
+                    .child(
+                        popover::dialog_body(theme, "Drag to reposition. Scroll or pinch to zoom.")
+                            .mt(px(4.0)),
+                    ),
+            )
+            .child(
+                div()
+                    .id("new-thread-background-adjustment-close")
+                    .size(px(28.0))
+                    .rounded(px(7.0))
+                    .border_1()
+                    .border_color(theme.border)
+                    .bg(theme.surface_raised.opacity(0.28))
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .cursor_pointer()
+                    .hover(|style| style.bg(theme.surface_raised_hover))
+                    .tab_index(0)
+                    .role(gpui::Role::Button)
+                    .aria_label("Close background adjustment")
+                    .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+                    .on_click(cx.listener(|this, _, window, cx| {
+                        this.dismiss_background_adjustment(window, cx)
+                    }))
+                    .child(
+                        icons::icon(icons::CLOSE)
+                            .size(px(12.0))
+                            .text_color(theme.text_muted),
+                    ),
+            );
+
+        let card = popover::dialog_card(theme)
+            .id("new-thread-background-adjustment-card")
+            .w(px((f32::from(viewport.width) - 40.0).clamp(1.0, 600.0)))
+            .p(px(20.0))
+            .track_focus(&focus)
+            .tab_group()
+            .tab_index(0)
+            .tab_stop(false)
+            .on_key_down(
+                cx.listener(move |this, event: &gpui::KeyDownEvent, window, cx| {
+                    let step = if event.keystroke.modifiers.shift {
+                        24.0
+                    } else {
+                        8.0
+                    };
+                    match popover::classify_key(
+                        event.keystroke.key.as_str(),
+                        event.keystroke.modifiers.platform,
+                        event.keystroke.modifiers.control,
+                    ) {
+                        popover::MenuKey::Escape => this.dismiss_background_adjustment(window, cx),
+                        popover::MenuKey::ModEnter => this.apply_background_adjustment(window, cx),
+                        _ => match event.keystroke.key.as_str() {
+                            "tab" => {
+                                if event.keystroke.modifiers.shift {
+                                    window.focus_prev(cx);
+                                } else {
+                                    window.focus_next(cx);
+                                }
+                                if !tab_start.contains_focused(window, cx) {
+                                    if event.keystroke.modifiers.shift {
+                                        window.focus(&tab_end, cx);
+                                        window.focus_prev(cx);
+                                    } else {
+                                        window.focus(&tab_start, cx);
+                                        window.focus_next(cx);
+                                    }
+                                }
+                            }
+                            "left" => this.pan_background(point(step, 0.0), cx),
+                            "right" => this.pan_background(point(-step, 0.0), cx),
+                            "up" => this.pan_background(point(0.0, step), cx),
+                            "down" => this.pan_background(point(0.0, -step), cx),
+                            "+" | "=" => {
+                                let zoom = this
+                                    .background_adjustment_dialog
+                                    .as_ref()
+                                    .map_or(1.0, |dialog| dialog.draft.zoom + BACKGROUND_ZOOM_STEP);
+                                this.set_background_zoom(zoom, cx);
+                            }
+                            "-" => {
+                                let zoom = this
+                                    .background_adjustment_dialog
+                                    .as_ref()
+                                    .map_or(1.0, |dialog| dialog.draft.zoom - BACKGROUND_ZOOM_STEP);
+                                this.set_background_zoom(zoom, cx);
+                            }
+                            _ => return,
+                        },
+                    }
+                    cx.stop_propagation();
+                    window.prevent_default();
+                }),
+            )
+            .on_mouse_down_out(
+                cx.listener(|this, _, window, cx| this.dismiss_background_adjustment(window, cx)),
+            )
+            .child(header)
+            .child(div().h(px(16.0)))
+            .child(
+                div()
+                    .w_full()
+                    .h(px(260.0))
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .child(preview),
+            )
+            .child(controls)
+            .child(footer)
+            .child(div().track_focus(&end_focus).tab_index(0).tab_stop(false))
+            .into_any_element();
+
+        Some(popover::modal(
+            "new-thread-background-adjustment-dialog",
+            viewport,
+            card,
+        ))
+    }
+
     fn render_review_dialog(
         &mut self,
         viewport: gpui::Size<gpui::Pixels>,
@@ -2847,6 +3609,25 @@ impl Render for AppearancePage {
                         .gap(px(8.0))
                         .when(current_background.is_some(), |actions| {
                             actions
+                                .when(background_available, |actions| {
+                                    actions.child(
+                                        compact_action(
+                                            &theme,
+                                            "Adjust",
+                                            "new-thread-background-adjust",
+                                        )
+                                        .tab_index(0)
+                                        .role(gpui::Role::Button)
+                                        .focus_visible(|s| {
+                                            s.border_2().border_color(theme.accent).opacity(1.0)
+                                        })
+                                        .on_click(
+                                            cx.listener(|this, _, window, cx| {
+                                                this.open_background_adjustment(window, cx)
+                                            }),
+                                        ),
+                                    )
+                                })
                                 .child(
                                     compact_action(
                                         &theme,
@@ -3099,7 +3880,8 @@ impl Render for AppearancePage {
             .clone()
             .or_else(|| theme_library::load_warning(cx).map(SharedString::from));
         let modal = self
-            .render_import_dialog(window.viewport_size(), &theme, window, cx)
+            .render_background_adjustment_dialog(window.viewport_size(), &theme, cx)
+            .or_else(|| self.render_import_dialog(window.viewport_size(), &theme, window, cx))
             .or_else(|| self.render_review_dialog(window.viewport_size(), &theme, cx));
 
         let ui_picker = self.render_font_picker(
@@ -3197,6 +3979,16 @@ impl Render for AppearancePage {
                     this.drag_width(event.event.position.x, window, cx);
                 },
             ))
+            .on_drag_move(cx.listener(
+                |this, event: &gpui::DragMoveEvent<BackgroundAdjustmentDrag>, _, cx| {
+                    this.drag_background(event.event.position, cx);
+                },
+            ))
+            .on_drag_move(cx.listener(
+                |this, event: &gpui::DragMoveEvent<BackgroundAdjustmentZoomDrag>, _, cx| {
+                    this.set_background_zoom_from_x(event.event.position.x, cx);
+                },
+            ))
             .on_mouse_up(
                 gpui::MouseButton::Left,
                 cx.listener(|this, _: &gpui::MouseUpEvent, _, cx| {
@@ -3205,6 +3997,7 @@ impl Render for AppearancePage {
                         cx.notify();
                     }
                     this.apply_pending_width(cx);
+                    this.finish_background_drag(cx);
                 }),
             )
             .on_mouse_up_out(
@@ -3215,6 +4008,7 @@ impl Render for AppearancePage {
                         cx.notify();
                     }
                     this.apply_pending_width(cx);
+                    this.finish_background_drag(cx);
                 }),
             )
             .relative()
@@ -3285,6 +4079,204 @@ impl Render for AppearancePage {
 mod tests {
     use super::*;
 
+    fn background_settings() -> crate::settings::UiSettings {
+        crate::settings::UiSettings {
+            new_thread_composer_background: Some(crate::settings::NewThreadComposerBackground {
+                path: "background.png".into(),
+                name: "Background".into(),
+                adjustment: crate::settings::NewThreadBackgroundAdjustment {
+                    focal_x: 0.25,
+                    focal_y: 0.75,
+                    zoom: 2.0,
+                },
+            }),
+            ..Default::default()
+        }
+    }
+
+    fn ready_background_preview(page: &mut AppearancePage) {
+        page.background_adjustment_dialog.as_mut().unwrap().source = Some(Arc::new(
+            gpui::RenderImage::new([image::Frame::new(image::RgbaImage::new(4, 4))]),
+        ));
+    }
+
+    #[gpui::test]
+    fn background_adjustment_cancel_and_reset_leave_saved_settings_untouched(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        let original = background_settings();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            crate::settings::init(original.clone(), dir.path(), cx);
+        });
+        let window = cx.add_window(|_, cx| AppearancePage::new(cx));
+        window
+            .update(cx, |page, window, cx| {
+                window.focus(&page.width_focus, cx);
+                page.open_background_adjustment(window, cx);
+                let dialog = page.background_adjustment_dialog.as_mut().unwrap();
+                dialog.drag = Some((point(px(0.0), px(0.0)), dialog.draft));
+                dialog.pinch = Some((2.0, 1.0));
+                page.reset_background_adjustment(cx);
+                let dialog = page.background_adjustment_dialog.as_ref().unwrap();
+                assert_eq!(dialog.draft, Default::default());
+                assert!(dialog.drag.is_none());
+                assert!(dialog.pinch.is_none());
+                assert_eq!(crate::settings::current(cx), original);
+                page.dismiss_background_adjustment(window, cx);
+                assert!(page.background_adjustment_dialog.is_none());
+                assert!(page.width_focus.is_focused(window));
+                assert_eq!(crate::settings::current(cx), original);
+                assert!(!crate::settings::UiSettings::path(dir.path()).exists());
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn background_adjustment_apply_waits_for_preview_and_persists_only_the_draft(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        let original = background_settings();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            crate::settings::init(original.clone(), dir.path(), cx);
+        });
+        let window = cx.add_window(|_, cx| AppearancePage::new(cx));
+        window
+            .update(cx, |page, window, cx| {
+                window.focus(&page.width_focus, cx);
+                page.open_background_adjustment(window, cx);
+                page.apply_background_adjustment(window, cx);
+                assert!(page.background_adjustment_dialog.is_some());
+                assert_eq!(crate::settings::current(cx), original);
+                ready_background_preview(page);
+                page.reset_background_adjustment(cx);
+                assert_eq!(crate::settings::current(cx), original);
+                page.apply_background_adjustment(window, cx);
+                assert!(page.background_adjustment_dialog.is_none());
+                assert!(page.width_focus.is_focused(window));
+                let mut expected = original.clone();
+                expected
+                    .new_thread_composer_background
+                    .as_mut()
+                    .unwrap()
+                    .adjustment = Default::default();
+                assert_eq!(crate::settings::current(cx), expected);
+                assert_eq!(crate::settings::UiSettings::load(dir.path()), expected);
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn background_adjustment_does_not_apply_to_a_replaced_or_removed_image(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            crate::settings::init(background_settings(), dir.path(), cx);
+        });
+        let window = cx.add_window(|_, cx| AppearancePage::new(cx));
+        window
+            .update(cx, |page, window, cx| {
+                page.open_background_adjustment(window, cx);
+                ready_background_preview(page);
+                page.reset_background_adjustment(cx);
+                crate::settings::update(crate::settings::SavePolicy::Immediate, cx, |settings| {
+                    settings
+                        .new_thread_composer_background
+                        .as_mut()
+                        .unwrap()
+                        .path = "replacement.png".into();
+                });
+                let replacement = crate::settings::current(cx);
+                page.apply_background_adjustment(window, cx);
+                assert_eq!(crate::settings::current(cx), replacement);
+                assert!(page.background_adjustment_dialog.is_some());
+                crate::settings::update(crate::settings::SavePolicy::Immediate, cx, |settings| {
+                    settings.new_thread_composer_background = None;
+                });
+                page.apply_background_adjustment(window, cx);
+                assert!(
+                    crate::settings::current(cx)
+                        .new_thread_composer_background
+                        .is_none()
+                );
+                assert!(page.background_adjustment_dialog.is_some());
+            })
+            .unwrap();
+    }
+
+    #[test]
+    fn background_preview_matches_the_runtime_hero_aspect_ratio() {
+        for viewport in [
+            gpui::size(px(1440.0), px(900.0)),
+            gpui::size(px(800.0), px(1200.0)),
+        ] {
+            for collapsed in [false, true] {
+                let preview = background_preview_size(viewport, 260.0, collapsed);
+                let hero_width = f32::from(viewport.width) - if collapsed { 0.0 } else { 260.0 };
+                let hero_height =
+                    crate::shell::new_thread_background_height(f32::from(viewport.height));
+                let aspect = f32::from(preview.width) / f32::from(preview.height);
+                assert!((aspect - hero_width / hero_height).abs() < 0.00001);
+                assert!(f32::from(preview.width) <= 556.0);
+                assert!(f32::from(preview.height) <= 260.0);
+            }
+        }
+    }
+
+    #[test]
+    fn background_pinch_preserves_native_scale_and_round_trips() {
+        for relative_delta in [false, true] {
+            let mut previous = 1.0;
+            let mut factor = 1.0;
+            for scale in [1.5, 2.0, 1.5, 1.0] {
+                let delta = if relative_delta {
+                    scale / previous - 1.0
+                } else {
+                    scale - previous
+                };
+                factor = background_pinch_factor(factor, delta, relative_delta);
+                assert!((factor - scale).abs() < 0.00001);
+                previous = scale;
+            }
+            assert!((factor - 1.0).abs() < 0.00001);
+        }
+    }
+
+    #[test]
+    fn background_pinch_clamps_degenerate_scales_and_ignores_invalid_deltas() {
+        for relative_delta in [false, true] {
+            assert_eq!(background_pinch_factor(1.0, -1.0, relative_delta), 0.001);
+            assert_eq!(background_pinch_factor(1.0, -2.0, relative_delta), 0.001);
+            for delta in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
+                assert_eq!(background_pinch_factor(1.5, delta, relative_delta), 1.5);
+            }
+        }
+    }
+
+    #[test]
+    fn background_zoom_slider_matches_its_inset_track_and_clamps() {
+        let bounds = Bounds::new(point(px(100.0), px(20.0)), gpui::size(px(168.0), px(28.0)));
+        let minimum = crate::settings::NewThreadBackgroundAdjustment::MIN_ZOOM;
+        let maximum = crate::settings::NewThreadBackgroundAdjustment::MAX_ZOOM;
+
+        assert_eq!(background_zoom_at_x(bounds, px(90.0)), minimum);
+        assert_eq!(background_zoom_at_x(bounds, px(107.0)), minimum);
+        assert_eq!(background_zoom_at_x(bounds, px(261.0)), maximum);
+        assert_eq!(background_zoom_at_x(bounds, px(280.0)), maximum);
+        assert_eq!(background_zoom_at_x(bounds, px(184.0)), 2.5);
+        assert_eq!(background_zoom_fraction(minimum), 0.0);
+        assert_eq!(background_zoom_fraction(2.5), 0.5);
+        assert_eq!(background_zoom_fraction(maximum), 1.0);
+    }
+
     #[test]
     fn every_mode_gets_a_card() {
         assert_eq!(AppearanceMode::ALL.len(), 3);
diff --git a/crates/ui/src/settings/wallpaper.rs b/crates/ui/src/settings/wallpaper.rs
index 2bbff9664a..1fa61fdc93 100644
--- a/crates/ui/src/settings/wallpaper.rs
+++ b/crates/ui/src/settings/wallpaper.rs
@@ -72,7 +72,9 @@ const LOOKAHEAD: usize = 3;
 struct QueueKey {
     folder: Option<PathBuf>,
     history: Vec<PathBuf>,
-    background: Option<super::NewThreadComposerBackground>,
+    /// Managed path only: adjusting the active image's framing must not
+    /// discard the decoded lookahead.
+    background: Option<String>,
     effect: super::NewThreadBackgroundEffect,
     light: bool,
     data_dir: PathBuf,
@@ -88,7 +90,9 @@ impl QueueKey {
         Self {
             folder: settings.wallpaper_folder,
             history,
-            background: settings.new_thread_composer_background,
+            background: settings
+                .new_thread_composer_background
+                .map(|background| background.path),
             effect: settings.new_thread_background_effect,
             light: cx
                 .try_global::<crate::theme::Theme>()
@@ -152,11 +156,10 @@ fn remove_orphaned_preloads(key: &QueueKey) {
     };
     // Compare names, not full paths, so a differently spelled data directory
     // can never make the active image look orphaned.
-    let active = key.background.as_ref().and_then(|background| {
-        Path::new(&background.path)
-            .file_name()
-            .map(|name| name.to_owned())
-    });
+    let active = key
+        .background
+        .as_deref()
+        .and_then(|path| Path::new(path).file_name().map(|name| name.to_owned()));
     for entry in entries.flatten() {
         let name = entry.file_name();
         let managed = name
@@ -358,6 +361,59 @@ mod tests {
         cx.run_until_parked();
     }
 
+    #[gpui::test]
+    fn warm_switch_resets_previous_background_adjustment(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        let folder = wallpaper_folder(dir.path());
+        let data = dir.path().join("data");
+        cx.update(|cx| {
+            cx.set_global(crate::theme::Theme::default());
+            super::super::init(
+                super::super::UiSettings {
+                    wallpaper_folder: Some(folder.clone()),
+                    ..Default::default()
+                },
+                &data,
+                cx,
+            );
+            super::super::install_new_thread_composer_background(&folder.join("0.png"), cx)
+                .unwrap();
+            preload(cx);
+        });
+        cx.run_until_parked();
+        cx.update(|cx| {
+            // Framing belongs to the active image; it must not flush the
+            // decoded lookahead for the next shuffle.
+            let generation = cx.global::<PreloadQueue>().generation;
+            super::super::set_new_thread_background_adjustment(
+                super::super::NewThreadBackgroundAdjustment {
+                    focal_x: 0.2,
+                    focal_y: 0.8,
+                    zoom: 2.0,
+                },
+                cx,
+            );
+            preload(cx);
+            assert_eq!(cx.global::<PreloadQueue>().generation, generation);
+            assert_eq!(cx.global::<PreloadQueue>().ready.len(), LOOKAHEAD);
+            let expected = cx.global::<PreloadQueue>().ready[0].source.clone();
+            randomize(cx).detach();
+            assert_eq!(cx.global::<PreloadQueue>().ready.len(), LOOKAHEAD - 1);
+            let settings = super::super::current(cx);
+            assert_eq!(settings.wallpaper_source.as_ref(), Some(&expected));
+            assert_eq!(
+                settings
+                    .new_thread_composer_background
+                    .as_ref()
+                    .unwrap()
+                    .adjustment,
+                super::super::NewThreadBackgroundAdjustment::default(),
+            );
+            assert_eq!(super::super::UiSettings::load(&data), settings);
+        });
+        cx.run_until_parked();
+    }
+
     #[gpui::test]
     fn first_preload_retires_copies_left_by_a_previous_session(cx: &mut gpui::TestAppContext) {
         let dir = tempfile::tempdir().unwrap();
@@ -377,6 +433,7 @@ mod tests {
                         super::super::NewThreadComposerBackground {
                             path: active.to_string_lossy().into_owned(),
                             name: "active.png".into(),
+                            adjustment: super::super::NewThreadBackgroundAdjustment::default(),
                         },
                     ),
                     ..Default::default()
diff --git a/crates/ui/src/settings/wallpaper_colors.rs b/crates/ui/src/settings/wallpaper_colors.rs
index 60ca76477b..6f5e092bf3 100644
--- a/crates/ui/src/settings/wallpaper_colors.rs
+++ b/crates/ui/src/settings/wallpaper_colors.rs
@@ -252,6 +252,7 @@ mod tests {
                         super::super::NewThreadComposerBackground {
                             path: image.to_string_lossy().into_owned(),
                             name: "existing.png".into(),
+                            adjustment: super::super::NewThreadBackgroundAdjustment::default(),
                         },
                     ),
                     ..Default::default()
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index c763fb3e77..4753a7b604 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -1271,13 +1271,14 @@ fn new_thread_background_opacity(is_frost: bool) -> f32 {
     }
 }
 
-fn new_thread_background_height(viewport_height: f32) -> f32 {
+pub(crate) fn new_thread_background_height(viewport_height: f32) -> f32 {
     (viewport_height.max(0.0) * NEW_THREAD_BACKGROUND_VIEWPORT_RATIO)
         .min(NEW_THREAD_BACKGROUND_MAX_HEIGHT)
 }
 
 fn new_thread_background(
     artwork: Option<std::sync::Arc<gpui::RenderImage>>,
+    adjustment: settings::NewThreadBackgroundAdjustment,
     viewport_height: f32,
     hero_width: f32,
     composer_bounds: crate::new_thread_background_mask::SurfaceBounds,
@@ -1322,6 +1323,7 @@ fn new_thread_background(
                                     artwork.clone(),
                                     bounds,
                                     composer,
+                                    adjustment,
                                     cutout,
                                     window,
                                 );
@@ -9821,6 +9823,10 @@ impl Shell {
         let ui_settings = settings::current(cx);
         let new_thread_background_setting = ui_settings.new_thread_composer_background;
         let new_thread_background_effect = ui_settings.new_thread_background_effect;
+        let new_thread_background_adjustment = new_thread_background_setting
+            .as_ref()
+            .map(|background| background.adjustment)
+            .unwrap_or_default();
         let frame_time = self.render_time.unwrap_or_else(std::time::Instant::now);
         // Prewarm even in an established thread. Decode/effect work is not
         // contingent on a hero measurement or a navigation gesture.
@@ -9836,6 +9842,10 @@ impl Shell {
             });
         let artwork_frame = self.new_thread_artwork_ready.frame(
             artwork,
+            new_thread_background_setting
+                .as_ref()
+                .map(|background| std::path::Path::new(&background.path)),
+            new_thread_background_adjustment,
             new_thread_background_setting.is_some(),
             self.reduced_motion,
             frame_time,
@@ -9883,6 +9893,7 @@ impl Shell {
                 .inset_0()
                 .child(new_thread_background(
                     artwork_frame.previous,
+                    artwork_frame.previous_adjustment,
                     self.viewport_height,
                     width,
                     bounds.clone(),
@@ -9891,6 +9902,7 @@ impl Shell {
                 ))
                 .child(new_thread_background(
                     artwork_frame.current,
+                    artwork_frame.current_adjustment,
                     self.viewport_height,
                     width,
                     bounds,

From 710b06ff854e2bb0e54ec5795e3d665a78923bcf Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 16:33:28 -0700
Subject: [PATCH 07/74] CI: seed the Rust cache from main and stop cancelling
 main runs

PR caches are scoped to their merge ref, so no other PR could read them, and main never saved one because in-progress main runs were cancelled. Only main writes the Rust caches now (PRs restore them), main runs are no longer cancelled, and Cursor compatibility also runs on pushes to main so it seeds its cache.
---
 .github/workflows/cursor-compatibility.yml | 13 +++++++++++++
 .github/workflows/linux-installer.yml      |  2 +-
 .github/workflows/preview-tests.yml        |  5 ++++-
 .github/workflows/ui-tests.yml             | 14 +++++++++++++-
 .github/workflows/windows.yml              |  3 ++-
 5 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/cursor-compatibility.yml b/.github/workflows/cursor-compatibility.yml
index c521f439ee..329443b7c1 100644
--- a/.github/workflows/cursor-compatibility.yml
+++ b/.github/workflows/cursor-compatibility.yml
@@ -9,6 +9,16 @@ on:
       - 'Cargo.lock'
       - 'scripts/*cursor-sdk*'
       - '.github/workflows/cursor-*.yml'
+  push:
+    branches: [main]
+    paths:
+      - 'crates/harness/**'
+      - 'crates/doc/**'
+      - 'crates/engine/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'scripts/*cursor-sdk*'
+      - '.github/workflows/cursor-*.yml'
   workflow_dispatch:
   workflow_call:
 permissions:
@@ -23,6 +33,9 @@ jobs:
         with:
           node-version: '22'
       - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
       - name: Dependency updater validation
         run: python3 scripts/test-update-cursor-sdk.py
       - name: Install the exact SDK selected by this engine
diff --git a/.github/workflows/linux-installer.yml b/.github/workflows/linux-installer.yml
index 71e8d89fae..574f803f36 100644
--- a/.github/workflows/linux-installer.yml
+++ b/.github/workflows/linux-installer.yml
@@ -25,7 +25,7 @@ permissions:
 
 concurrency:
   group: linux-installer-${{ github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 jobs:
   desktop-entry:
diff --git a/.github/workflows/preview-tests.yml b/.github/workflows/preview-tests.yml
index 43487fb3eb..ff8b162392 100644
--- a/.github/workflows/preview-tests.yml
+++ b/.github/workflows/preview-tests.yml
@@ -9,7 +9,7 @@ permissions:
   contents: read
 concurrency:
   group: preview-tests-${{ github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
   networking:
     strategy:
@@ -21,6 +21,9 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
       - run: cargo test --locked -p zeron-preview
   coordinator:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index efe5a97dfb..93a8226a23 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -31,7 +31,7 @@ permissions:
 
 concurrency:
   group: ui-tests-${{ github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 jobs:
   changes:
@@ -75,6 +75,9 @@ jobs:
       - name: Rust toolchain
         run: rustup show active-toolchain || rustup toolchain install
       - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
       - name: OpenCode protocol and permission regressions
         run: |
           cargo test --locked -p zeron-harness --lib opencode::
@@ -102,6 +105,9 @@ jobs:
       - name: Rust toolchain
         run: rustup show active-toolchain || rustup toolchain install
       - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
       - name: UI and headless layout regressions
         run: cargo test --release --locked -p zeron-ui --lib -- --test-threads=1
 
@@ -122,6 +128,7 @@ jobs:
           git -C frame-source-tests checkout --detach FETCH_HEAD
       - uses: Swatinem/rust-cache@v2
         with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
           cache-on-failure: true
           workspaces: |
             .
@@ -199,6 +206,8 @@ jobs:
           rustup target add aarch64-apple-ios aarch64-apple-ios-sim
       - uses: Swatinem/rust-cache@v2
         with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
           key: ios-core
       - name: Rust mobile core tests
         run: cargo test --locked -p zeron-text -p zeron-markdown -p zeron-client -p zeron-mobile
@@ -239,6 +248,9 @@ jobs:
       - name: Rust toolchain
         run: rustup show active-toolchain || rustup toolchain install
       - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
       - name: Build browser fixture
         run: cargo build --release --locked -p zeron-ui --example browser-fixture --features browser-fixture
       - name: X11 and Wayland browser regressions
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 5b00048499..b9a96c6ddd 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -36,7 +36,7 @@ permissions:
 
 concurrency:
   group: windows-tests-${{ github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 defaults:
   run:
@@ -58,6 +58,7 @@ jobs:
           "GPUI_FXC_PATH=$($fxc.FullName)" >> $env:GITHUB_ENV
       - uses: Swatinem/rust-cache@v2
         with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
           cache-on-failure: true
           cache-workspace-crates: true
       - name: Native harness security and integration tests

From f4abe69b8805294b96e47606642914319662caa2 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 16:35:50 -0700
Subject: [PATCH 08/74] CI: run Windows tests in three parallel jobs on a
 cheaper profile

---
 .github/actions/windows-ci-setup/action.yml | 54 +++++++++++++++++++++
 .github/workflows/windows.yml               | 52 +++++++++++---------
 2 files changed, 82 insertions(+), 24 deletions(-)
 create mode 100644 .github/actions/windows-ci-setup/action.yml

diff --git a/.github/actions/windows-ci-setup/action.yml b/.github/actions/windows-ci-setup/action.yml
new file mode 100644
index 0000000000..74ddc7e28b
--- /dev/null
+++ b/.github/actions/windows-ci-setup/action.yml
@@ -0,0 +1,54 @@
+name: Windows CI setup
+description: >-
+  Prepare a Windows runner for the Windows test jobs: toolchain, shader
+  compiler, a cheaper release profile for the CI builds, and the Rust cache.
+
+runs:
+  using: composite
+  steps:
+    - name: Disable Defender real-time scanning
+      shell: pwsh
+      # Hosted runners are ephemeral and only build this repository; scanning
+      # every file rustc writes slows builds down. Best effort: warn and carry
+      # on if the runner image does not allow it.
+      run: |
+        try { Set-MpPreference -DisableRealtimeMonitoring $true -ErrorAction Stop }
+        catch { Write-Warning "Could not disable Defender real-time scanning: $_" }
+    - name: Rust toolchain
+      shell: pwsh
+      run: rustup show active-toolchain || rustup toolchain install
+    - name: Locate Windows SDK shader compiler
+      shell: pwsh
+      run: |
+        $fxc = Get-ChildItem "${env:ProgramFiles(x86)}/Windows Kits/10/bin/*/x64/fxc.exe" |
+          Sort-Object FullName -Descending | Select-Object -First 1
+        if (-not $fxc) { throw 'Windows SDK fxc.exe is required for GPUI release shaders' }
+        "GPUI_FXC_PATH=$($fxc.FullName)" >> $env:GITHUB_ENV
+    - name: Cheaper release profile for CI builds
+      shell: pwsh
+      # CI only: the binaries built and tested here are NOT the shipped ones
+      # (release.yml still builds those with the committed profile). Thin LTO is
+      # off and the workspace's own crates are built at opt-level 0; third-party
+      # dependencies (gpui, tokio, ...) keep the release opt-level. Written to
+      # $CARGO_HOME/config.toml so Cargo.toml is untouched and every cargo
+      # invocation in the job, including the ones inside
+      # scripts/package-windows.ps1, picks it up.
+      run: |
+        $members = (cargo metadata --no-deps --format-version 1 | ConvertFrom-Json).packages.name
+        $config = @('[profile.release]', 'lto = false')
+        foreach ($name in $members) {
+          $config += "[profile.release.package.`"$name`"]"
+          $config += 'opt-level = 0'
+        }
+        $cargoHome = if ($env:CARGO_HOME) { $env:CARGO_HOME } else { Join-Path $env:USERPROFILE '.cargo' }
+        Add-Content -LiteralPath (Join-Path $cargoHome 'config.toml') -Value $config
+        Write-Host "opt-level 0 for $($members.Count) workspace crates: $($members -join ', ')"
+    - uses: Swatinem/rust-cache@v2
+      with:
+        # Only main writes the cache; PRs restore it.
+        save-if: ${{ github.ref == 'refs/heads/main' }}
+        cache-on-failure: true
+        # Workspace crates are rebuilt on every change anyway and are cheap at
+        # opt-level 0, so keep them out of the cache. Each job gets its own
+        # cache (rust-cache keys on the job id by default).
+        cache-workspace-crates: false
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index b9a96c6ddd..33e5c69b45 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -43,26 +43,14 @@ defaults:
     shell: pwsh
 
 jobs:
-  tests:
+  # The original single serial job is split into three independent jobs so they
+  # run in parallel. Together they run exactly the commands the single job ran.
+  ui-tests:
     runs-on: windows-2022
-    timeout-minutes: 90
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
-      - name: Rust toolchain
-        run: rustup show active-toolchain || rustup toolchain install
-      - name: Locate Windows SDK shader compiler
-        run: |
-          $fxc = Get-ChildItem "${env:ProgramFiles(x86)}/Windows Kits/10/bin/*/x64/fxc.exe" |
-            Sort-Object FullName -Descending | Select-Object -First 1
-          if (-not $fxc) { throw 'Windows SDK fxc.exe is required for GPUI release shaders' }
-          "GPUI_FXC_PATH=$($fxc.FullName)" >> $env:GITHUB_ENV
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
-          cache-workspace-crates: true
-      - name: Native harness security and integration tests
-        run: cargo test --release --locked -p zeron-harness --features native-fixture --lib --test codex_availability --test windows_native
+      - uses: ./.github/actions/windows-ci-setup
       - name: UI tests
         env:
           RUST_BACKTRACE: '1'
@@ -74,12 +62,15 @@ jobs:
           cargo test --release --locked -p zeron-ui --lib -- --test-threads=1 --skip native_diff_font_geometry --nocapture
           $headlessResult = $LASTEXITCODE
           if ($nativeResult -ne 0 -or $headlessResult -ne 0) { exit 1 }
-      - name: Build application
-        run: cargo build --release --locked -p zeron
-      - name: Verify portable and installer packaging
-        run: ./scripts/package-windows.ps1 -ReleasesUrl "https://github.com/$env:GITHUB_REPOSITORY/releases/latest/download"
-      - name: Installer install/uninstall
-        run: ./scripts/test-windows-installer.ps1
+
+  crate-tests:
+    runs-on: windows-2022
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/windows-ci-setup
+      - name: Native harness security and integration tests
+        run: cargo test --release --locked -p zeron-harness --features native-fixture --lib --test codex_availability --test windows_native
       - name: Shader layout tests
         run: cargo test --release --locked -p gpui_windows --lib layout
       - name: Application and updater tests
@@ -90,6 +81,19 @@ jobs:
         run: cargo test --release --locked -p zeron-engine --test codex_catalog --test codex_login_resolution
       - name: Auth integration tests
         run: cargo test --release --locked -p zeron-engine --test auth
+
+  app:
+    runs-on: windows-2022
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/windows-ci-setup
+      - name: Build application
+        run: cargo build --release --locked -p zeron
+      - name: Verify portable and installer packaging
+        run: ./scripts/package-windows.ps1 -ReleasesUrl "https://github.com/$env:GITHUB_REPOSITORY/releases/latest/download"
+      - name: Installer install/uninstall
+        run: ./scripts/test-windows-installer.ps1
       - name: GUI subsystem and redirected CLI output
         run: ./scripts/test-windows-startup.ps1
       - name: CLI startup without HOME
@@ -143,7 +147,7 @@ jobs:
 
   native-gui:
     if: ${{ github.event_name == 'workflow_dispatch' && inputs.native_gui }}
-    needs: tests
+    needs: app
     runs-on: windows-2022
     timeout-minutes: 10
     steps:

From 52a3481dc5339fb628015857d25a1b4f403f421d Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 16:36:54 -0700
Subject: [PATCH 09/74] CI: add a macOS workflow with one compile and parallel
 jobs

New macos.yml holds all macOS CI work: updater/preview/native UI tests and the WebKit fixtures from one nextest compile on the dev profile, the gpui frame-source test, and the iOS checks (Rust mobile core tests and the Swift bindings check now on Linux, simulator tests on macOS behind the original path filter). scripts/ci/run-macos-fixture.sh wraps the native fixtures with bounded retries.
---
 .github/workflows/macos.yml     | 283 ++++++++++++++++++++++++++++++++
 scripts/ci/run-macos-fixture.sh |  62 +++++++
 2 files changed, 345 insertions(+)
 create mode 100644 .github/workflows/macos.yml
 create mode 100755 scripts/ci/run-macos-fixture.sh

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
new file mode 100644
index 0000000000..16c74e478f
--- /dev/null
+++ b/.github/workflows/macos.yml
@@ -0,0 +1,283 @@
+name: macOS tests
+
+on:
+  pull_request:
+    paths:
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'rust-toolchain.toml'
+      - 'crates/**'
+      - 'edge/**'
+      - 'scripts/run-macos-browser-fixture.sh'
+      - 'scripts/ci/run-macos-fixture.sh'
+      - 'dist/macos/Info.plist'
+      - 'apps/ios/**'
+      - '.github/workflows/macos.yml'
+  push:
+    branches: [main]
+    paths:
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'rust-toolchain.toml'
+      - 'crates/**'
+      - 'edge/**'
+      - 'scripts/run-macos-browser-fixture.sh'
+      - 'scripts/ci/run-macos-fixture.sh'
+      - 'dist/macos/Info.plist'
+      - 'apps/ios/**'
+      - '.github/workflows/macos.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: macos-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  # Tests run on the dev profile (workspace crates at opt-level 0, dependencies at 2 as configured in
+  # Cargo.toml) instead of --release: a cold build is several times cheaper. No debug info is needed.
+  CARGO_PROFILE_DEV_DEBUG: 0
+
+# Every macOS job starts with `rustup update stable`: runner images are not uniform (one image may ship
+# rustc 1.98.0 and another 1.98.1) and rust-cache keys include the rustc version, so a job that lands
+# on an older image would otherwise miss the cache that `main` seeded.
+jobs:
+  changes:
+    runs-on: ubuntu-24.04
+    permissions:
+      pull-requests: read
+    outputs:
+      ios: ${{ steps.filter.outputs.result }}
+    steps:
+      - uses: actions/github-script@v8
+        id: filter
+        with:
+          script: |
+            // Preserve iOS coverage for main pushes and manual runs.
+            if (context.eventName !== 'pull_request') return true;
+            const files = await github.paginate(github.rest.pulls.listFiles, {
+              ...context.repo,
+              pull_number: context.payload.pull_request.number,
+              per_page: 100,
+            });
+            // Run conservatively if the API did not return the full diff.
+            if (files.length < context.payload.pull_request.changed_files) return true;
+            // The app links the Rust mobile core and everything it depends on.
+            const mobileCore = ['crates/mobile/', 'crates/client/', 'crates/text/', 'crates/markdown/',
+              'crates/doc/', 'crates/sync/', 'crates/proto/', 'crates/rpc/', 'crates/syntax/',
+              'scripts/ios/'];
+            const affectsIOS = path => path?.startsWith('apps/ios/')
+              || mobileCore.some(prefix => path?.startsWith(prefix))
+              || path === 'Cargo.lock'
+              || path === 'Cargo.toml'
+              || path === 'rust-toolchain.toml'
+              || path === '.github/workflows/macos.yml';
+            return files.some(file => affectsIOS(file.filename)
+              || affectsIOS(file.previous_filename));
+
+  # Updater and preview tests, native UI regressions and the two native WebKit fixtures. Everything is
+  # compiled once (one cargo invocation, so dependencies are built once) and then run.
+  macos-native:
+    runs-on: macos-14
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - name: Rust toolchain
+        run: |
+          rustup update stable --no-self-update
+          rustup show active-toolchain || rustup toolchain install
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
+      - name: Install cargo-nextest
+        run: |
+          # Pinned release, verified against a checksum.
+          version=0.9.146
+          sha256=39785160b3c2f6ed9a765049cf4fa79f3b39aa02eb7598a5a0e2a1a0b9ffb9a8
+          curl -fsSL -o "$RUNNER_TEMP/nextest.tar.gz" \
+            "https://github.com/nextest-rs/nextest/releases/download/cargo-nextest-$version/cargo-nextest-$version-universal-apple-darwin.tar.gz"
+          echo "$sha256  $RUNNER_TEMP/nextest.tar.gz" | shasum -a 256 -c -
+          tar -xzf "$RUNNER_TEMP/nextest.tar.gz" -C "$HOME/.cargo/bin"
+      - name: Build tests and fixtures
+        run: |
+          cargo nextest run --no-run --locked \
+            -p zeron-update -p zeron-preview -p zeron-ui \
+            --features zeron-ui/browser-fixture --lib --tests
+          cargo build --locked -p zeron-update -p zeron-preview -p zeron-ui \
+            --features zeron-ui/browser-fixture --example browser-fixture --example preview-fixture
+      - name: Check macOS application
+        env:
+          # Match the old `cargo check --release`: no debug assertions.
+          CARGO_PROFILE_DEV_DEBUG_ASSERTIONS: false
+        run: cargo check --locked -p zeron
+      - name: Updater, preview and native UI regressions
+        run: |
+          cargo nextest run --no-fail-fast --locked \
+            -p zeron-update -p zeron-preview -p zeron-ui \
+            --features zeron-ui/browser-fixture --lib --tests \
+            -E 'package(zeron-update) | package(zeron-preview) | (binary_id(zeron-ui) & (test(native_diff_font_geometry) | test(/notify::tests::/)))'
+      - name: Native browser regression and screenshots
+        timeout-minutes: 7
+        env:
+          RUST_BACKTRACE: 1
+          FIXTURE_ATTEMPT_TIMEOUT: 110
+        run: |
+          scripts/ci/run-macos-fixture.sh target/debug/examples/browser-fixture "$RUNNER_TEMP/browser-captures"
+          test -f "$RUNNER_TEMP/browser-captures/result.txt"
+      - name: Upload browser screenshots
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: browser-macos-captures
+          path: ${{ runner.temp }}/browser-captures*
+          if-no-files-found: ignore
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - name: Install preview fixture server
+        run: npm ci --prefix edge
+      - name: Project discovery, stable URLs and HMR in native WebKit
+        timeout-minutes: 5
+        env:
+          ZERON_PREVIEW_AUTO_OPEN: 1
+          PREVIEW_HOSTS: 1
+        run: |
+          VITE_BINARY="$GITHUB_WORKSPACE/edge/node_modules/vite/bin/vite.js" scripts/ci/run-macos-fixture.sh target/debug/examples/preview-fixture "$RUNNER_TEMP/preview-captures"
+          test -f "$RUNNER_TEMP/preview-captures/result.txt"
+      - name: Upload preview screenshots
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: preview-macos-captures
+          path: ${{ runner.temp }}/preview-captures*
+          if-no-files-found: ignore
+
+  # gpui_macos lives in the pinned GPUI checkout, a separate workspace with its own cache.
+  macos-frame-source:
+    runs-on: macos-14
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - name: Rust toolchain
+        run: |
+          rustup update stable --no-self-update
+          rustup show active-toolchain || rustup toolchain install
+      - name: Check out pinned GPUI for native frame-source tests
+        shell: bash
+        run: |
+          rev=$(python3 -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["workspace"]["dependencies"]["gpui"]["rev"])')
+          git init frame-source-tests
+          git -C frame-source-tests remote add origin https://github.com/zeronsh/zui
+          git -C frame-source-tests fetch --depth=1 origin "$rev"
+          git -C frame-source-tests checkout --detach FETCH_HEAD
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
+          workspaces: frame-source-tests
+      - name: Native frame-source recovery regression
+        working-directory: frame-source-tests
+        run: cargo test --locked -p gpui_macos --test frame_source_recovery
+
+  # The iOS checks that do not need Apple tooling run on Linux: Rust mobile core tests, and "the
+  # committed Swift bindings are current" (the UniFFI metadata is identical for any target, so the
+  # bindings are generated from the host build of the library).
+  ios-core:
+    needs: changes
+    if: needs.changes.outputs.ios == 'true'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - name: Rust toolchain
+        run: rustup show active-toolchain || rustup toolchain install
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
+      - name: Rust mobile core tests
+        run: cargo test --locked -p zeron-text -p zeron-markdown -p zeron-client -p zeron-mobile
+      - name: Generated Swift bindings are current
+        run: |
+          cargo build --locked -p zeron-mobile --lib
+          cargo build --locked -p zeron-mobile --bin uniffi-bindgen --features bindgen
+          target/debug/uniffi-bindgen generate --library target/debug/libzeron_mobile.so \
+            --language swift --out-dir "$RUNNER_TEMP/gen" >/dev/null
+          diff -u apps/ios/Zeron/Core/Generated/zeron_core.swift "$RUNNER_TEMP/gen/zeron_core.swift"
+          # The simulator job links these headers instead of regenerating them.
+          mkdir -p "$RUNNER_TEMP/ios-include"
+          cp "$RUNNER_TEMP/gen/zeron_coreFFI.h" "$RUNNER_TEMP/ios-include/zeron_coreFFI.h"
+          cp "$RUNNER_TEMP/gen/zeron_coreFFI.modulemap" "$RUNNER_TEMP/ios-include/module.modulemap"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ios-ffi-include
+          path: ${{ runner.temp }}/ios-include
+          retention-days: 1
+
+  # iOS unit tests in the simulator (only when iOS or the mobile core changed, see `changes`).
+  # Waiting for macos-frame-source keeps a run to two macOS runners at a time.
+  # Do not boot the simulator in the background: hundreds of launchd_sim daemons starve the 3-vCPU
+  # VM and slow every other step down by minutes. xcodebuild boots it when needed.
+  ios-tests:
+    needs: [changes, ios-core, macos-frame-source]
+    if: needs.changes.outputs.ios == 'true'
+    runs-on: macos-15
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - name: Select an available iPhone simulator
+        run: |
+          # The app targets iOS 26: use the newest Xcode 26 and the newest iOS runtime installed.
+          xcode=$(ls -d /Applications/Xcode_26*.app 2>/dev/null | sort -V | tail -1 || true)
+          if [ -n "$xcode" ]; then echo "DEVELOPER_DIR=$xcode/Contents/Developer" >> "$GITHUB_ENV"; fi
+          python3 - <<'PYTHON'
+          import json, os, subprocess
+          devices = json.loads(subprocess.check_output(["xcrun", "simctl", "list", "devices", "available", "--json"]))["devices"]
+          def version(runtime):
+              return [int(part) for part in runtime.split("iOS-")[-1].split("-") if part.isdigit()]
+          iphones = [device for runtime, group in sorted(devices.items(), key=lambda item: version(item[0]), reverse=True)
+                     if "iOS" in runtime for device in group if device["name"].startswith("iPhone")]
+          if not iphones:
+              raise SystemExit("No iPhone simulator is installed")
+          with open(os.environ["GITHUB_ENV"], "a") as env:
+              env.write("IOS_SIMULATOR_ID=" + iphones[0]["udid"] + "\n")
+          PYTHON
+      - name: Rust toolchain + iOS simulator target
+        run: |
+          rustup update stable --no-self-update
+          rustup show active-toolchain || rustup toolchain install
+          rustup target add aarch64-apple-ios-sim
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-on-failure: true
+      - name: Build the Rust core for the simulator
+        run: |
+          # Same build as scripts/ios/build-core.sh iphonesimulator; the bindings came from ios-core.
+          IPHONEOS_DEPLOYMENT_TARGET=26.0 cargo build --locked -p zeron-mobile --lib --profile mobile --target aarch64-apple-ios-sim
+          mkdir -p target/ios-core/iphonesimulator
+          cp target/aarch64-apple-ios-sim/mobile/libzeron_mobile.a target/ios-core/iphonesimulator/
+      - uses: actions/download-artifact@v4
+        with:
+          name: ios-ffi-include
+          path: target/ios-core/iphonesimulator/include
+      - name: Run iOS unit tests
+        working-directory: apps/ios
+        env:
+          # Reuse the core built above instead of rebuilding it in the Xcode build phase.
+          ZERON_SKIP_CORE: 1
+        run: |
+          xcodebuild -project Zeron.xcodeproj -scheme Zeron \
+            -destination "platform=iOS Simulator,id=$IOS_SIMULATOR_ID" \
+            -resultBundlePath "$RUNNER_TEMP/ios-tests.xcresult" \
+            -only-testing:ZeronTests CODE_SIGNING_ALLOWED=NO test
+      - name: Upload iOS test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ios-test-results
+          path: ${{ runner.temp }}/ios-tests.xcresult
+          if-no-files-found: ignore
diff --git a/scripts/ci/run-macos-fixture.sh b/scripts/ci/run-macos-fixture.sh
new file mode 100755
index 0000000000..52b1ed2863
--- /dev/null
+++ b/scripts/ci/run-macos-fixture.sh
@@ -0,0 +1,62 @@
+#!/bin/bash
+# Runs a native macOS GUI fixture (browser-fixture / preview-fixture) with guards against a flaky,
+# heavily loaded GitHub runner VM (3 vCPU). The fixture binary, its arguments and assertions are
+# untouched; only the wrapper changes:
+#  * bounded retries: each attempt has its own timeout (instead of one long hang) and a failed attempt
+#    is reported with a ::warning:: so flakes stay visible. A real regression fails every attempt.
+#  * PREVIEW_HOSTS=1 (preview fixture only): WebKit sometimes fails to resolve *.localhost
+#    (NSURLErrorDomain -1003) although the preview proxy is listening; map the fixture hostnames to
+#    loopback in /etc/hosts so DNS can never be the reason. The fixture still goes through the same
+#    per-domain proxy path; this only removes the DNS race.
+# usage: run-macos-fixture.sh <fixture-binary> <capture-dir>
+set -uo pipefail
+ROOT="${ZERON_ROOT:-$(cd "$(dirname "$0")/../.." && pwd)}"
+BINARY="$1"
+OUT="$2"
+ATTEMPTS="${FIXTURE_ATTEMPTS:-3}"
+ATTEMPT_TIMEOUT="${FIXTURE_ATTEMPT_TIMEOUT:-70}"
+
+if [ -n "${PREVIEW_HOSTS:-}" ]; then
+  # Same slug() as crates/preview/src/catalog.rs: device label = slug(hostname).
+  label=$(hostname | python3 -c 'import re,sys; s=re.sub(r"[^a-z0-9]+","-",sys.stdin.read().strip().lower()).strip("-")[:48].strip("-"); print(s or "project")')
+  for svc in fieldnotes fieldnotes-vite fieldnotes-api fieldnotes-node fieldnotes-web fieldnotes-server; do
+    echo "127.0.0.1 $label.$svc.localhost"
+    echo "::1 $label.$svc.localhost"
+  done | sudo tee -a /etc/hosts >/dev/null
+  echo "hosts entries added for device label '$label'"
+fi
+
+# macOS has no coreutils `timeout`; do it in bash.
+run_with_timeout() {
+  local secs=$1; shift
+  "$@" &
+  local pid=$!
+  ( sleep "$secs"; kill -TERM "$pid" 2>/dev/null; sleep 3; kill -KILL "$pid" 2>/dev/null ) &
+  local watchdog=$!
+  wait "$pid"; local rc=$?
+  kill "$watchdog" 2>/dev/null; wait "$watchdog" 2>/dev/null
+  return $rc
+}
+
+for attempt in $(seq 1 "$ATTEMPTS"); do
+  rm -rf "$OUT"; mkdir -p "$OUT"
+  echo "=== $(basename "$BINARY") attempt $attempt/$ATTEMPTS ==="
+  if run_with_timeout "$ATTEMPT_TIMEOUT" bash "$ROOT/scripts/run-macos-browser-fixture.sh" "$BINARY" "$OUT" && test -f "$OUT/result.txt"; then
+    echo "$(basename "$BINARY") passed on attempt $attempt"
+    [ "$attempt" -gt 1 ] && echo "::warning::$(basename "$BINARY") needed $attempt attempts (flaky on this runner)"
+    exit 0
+  fi
+  echo "::warning::$(basename "$BINARY") attempt $attempt failed"
+  if [ -n "${PREVIEW_HOSTS:-}" ]; then
+    dscacheutil -q host -a name "$label.fieldnotes.localhost" || true
+    lsof -nP -iTCP:7331 -sTCP:LISTEN || true
+  fi
+  mkdir -p "$OUT.failed-$attempt"
+  cp -R "$OUT"/. "$OUT.failed-$attempt"/ 2>/dev/null || true
+  pkill -f 'vite/bin/vite.js' 2>/dev/null || true
+  pkill -f 'node api.js' 2>/dev/null || true
+  pkill -f 'Fixture.app/Contents/MacOS/fixture' 2>/dev/null || true
+  sleep 2
+done
+echo "$(basename "$BINARY") failed after $ATTEMPTS attempts"
+exit 1

From c286d118b48f592b4e1252802f7ff10c788caecd Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 16:36:54 -0700
Subject: [PATCH 10/74] CI: remove the macOS jobs from ui-tests and
 preview-tests

macos-frame-recovery, ios-tests and their path-filter job move to macos.yml; the preview networking tests on macOS run there as well.
---
 .github/workflows/preview-tests.yml |   2 +-
 .github/workflows/ui-tests.yml      | 152 ----------------------------
 2 files changed, 1 insertion(+), 153 deletions(-)

diff --git a/.github/workflows/preview-tests.yml b/.github/workflows/preview-tests.yml
index ff8b162392..fee2ff30bb 100644
--- a/.github/workflows/preview-tests.yml
+++ b/.github/workflows/preview-tests.yml
@@ -14,7 +14,7 @@ jobs:
   networking:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30
     steps:
diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 93a8226a23..81dae1aa89 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -34,39 +34,6 @@ concurrency:
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 jobs:
-  changes:
-    runs-on: ubuntu-24.04
-    permissions:
-      pull-requests: read
-    outputs:
-      ios: ${{ steps.filter.outputs.result }}
-    steps:
-      - uses: actions/github-script@v8
-        id: filter
-        with:
-          script: |
-            // Preserve iOS coverage for main pushes and manual runs.
-            if (context.eventName !== 'pull_request') return true;
-            const files = await github.paginate(github.rest.pulls.listFiles, {
-              ...context.repo,
-              pull_number: context.payload.pull_request.number,
-              per_page: 100,
-            });
-            // Run conservatively if the API did not return the full diff.
-            if (files.length < context.payload.pull_request.changed_files) return true;
-            // The app links the Rust mobile core and everything it depends on.
-            const mobileCore = ['crates/mobile/', 'crates/client/', 'crates/text/', 'crates/markdown/',
-              'crates/doc/', 'crates/sync/', 'crates/proto/', 'crates/rpc/', 'crates/syntax/',
-              'scripts/ios/'];
-            const affectsIOS = path => path?.startsWith('apps/ios/')
-              || mobileCore.some(prefix => path?.startsWith(prefix))
-              || path === 'Cargo.lock'
-              || path === 'Cargo.toml'
-              || path === 'rust-toolchain.toml'
-              || path === '.github/workflows/ui-tests.yml';
-            return files.some(file => affectsIOS(file.filename)
-              || affectsIOS(file.previous_filename));
-
   session-sync-regressions:
     runs-on: ubuntu-24.04
     timeout-minutes: 20
@@ -111,125 +78,6 @@ jobs:
       - name: UI and headless layout regressions
         run: cargo test --release --locked -p zeron-ui --lib -- --test-threads=1
 
-  macos-frame-recovery:
-    runs-on: macos-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v4
-      - name: Rust toolchain
-        run: rustup show active-toolchain || rustup toolchain install
-      - name: Check out pinned GPUI for native frame-source tests
-        shell: bash
-        run: |
-          rev=$(python3 -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["workspace"]["dependencies"]["gpui"]["rev"])')
-          git init frame-source-tests
-          git -C frame-source-tests remote add origin https://github.com/zeronsh/zui
-          git -C frame-source-tests fetch --depth=1 origin "$rev"
-          git -C frame-source-tests checkout --detach FETCH_HEAD
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
-          workspaces: |
-            .
-            frame-source-tests
-      - name: Check macOS application
-        run: cargo check --release --locked -p zeron
-      - name: Updater tests (bundle staging, install detection)
-        run: cargo test --release --locked -p zeron-update
-      - name: Native diff font geometry regression
-        run: cargo test --release --locked -p zeron-ui --lib native_diff_font_geometry -- --test-threads=1
-      - name: Native notification click regressions
-        run: |
-          cargo test --release --locked -p zeron-ui --lib notify::tests:: -- --test-threads=1
-      - name: Build native browser fixture
-        run: cargo build --release --locked -p zeron-ui --example browser-fixture --example preview-fixture --features browser-fixture
-      - name: Native browser regression and screenshots
-        timeout-minutes: 3
-        env:
-          RUST_BACKTRACE: 1
-        run: |
-          bash scripts/run-macos-browser-fixture.sh target/release/examples/browser-fixture "$RUNNER_TEMP/browser-captures"
-          test -f "$RUNNER_TEMP/browser-captures/result.txt"
-      - name: Upload browser screenshots
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: browser-macos-captures
-          path: ${{ runner.temp }}/browser-captures
-          if-no-files-found: ignore
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24
-      - name: Install preview fixture server
-        run: npm ci --prefix edge
-      - name: Project discovery, stable URLs and HMR in native WebKit
-        timeout-minutes: 3
-        env:
-          ZERON_PREVIEW_AUTO_OPEN: 1
-        run: |
-          VITE_BINARY="$GITHUB_WORKSPACE/edge/node_modules/vite/bin/vite.js" bash scripts/run-macos-browser-fixture.sh target/release/examples/preview-fixture "$RUNNER_TEMP/preview-captures"
-          test -f "$RUNNER_TEMP/preview-captures/result.txt"
-      - name: Upload preview screenshots
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: preview-macos-captures
-          path: ${{ runner.temp }}/preview-captures
-          if-no-files-found: ignore
-      - name: Native frame-source recovery regression
-        working-directory: frame-source-tests
-        run: cargo test --release --locked -p gpui_macos --test frame_source_recovery
-
-  ios-tests:
-    needs: changes
-    if: needs.changes.outputs.ios == 'true'
-    runs-on: macos-latest
-    timeout-minutes: 50
-    steps:
-      - uses: actions/checkout@v4
-      - name: Select an available iPhone simulator
-        run: |
-          python3 - <<'PYTHON'
-          import json, os, subprocess
-          devices = json.loads(subprocess.check_output(["xcrun", "simctl", "list", "devices", "available", "--json"]))["devices"]
-          iphones = [device for runtime, group in devices.items() if "iOS" in runtime
-                     for device in group if device["name"].startswith("iPhone")]
-          if not iphones:
-              raise SystemExit("No iPhone simulator is installed")
-          with open(os.environ["GITHUB_ENV"], "a") as env:
-              env.write("IOS_SIMULATOR_ID=" + iphones[0]["udid"] + "\n")
-          PYTHON
-      - name: Rust toolchain + iOS targets
-        run: |
-          rustup show active-toolchain || rustup toolchain install
-          rustup target add aarch64-apple-ios aarch64-apple-ios-sim
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
-          key: ios-core
-      - name: Rust mobile core tests
-        run: cargo test --locked -p zeron-text -p zeron-markdown -p zeron-client -p zeron-mobile
-      - name: Generated Swift bindings are current
-        run: |
-          scripts/ios/build-core.sh iphonesimulator
-          git diff --exit-code -- apps/ios/Zeron/Core/Generated
-      - name: Run iOS unit tests
-        working-directory: apps/ios
-        run: |
-          xcodebuild -project Zeron.xcodeproj -scheme Zeron \
-            -destination "platform=iOS Simulator,id=$IOS_SIMULATOR_ID" \
-            -resultBundlePath "$RUNNER_TEMP/ios-tests.xcresult" \
-            -only-testing:ZeronTests CODE_SIGNING_ALLOWED=NO test
-      - name: Upload iOS test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: ios-test-results
-          path: ${{ runner.temp }}/ios-tests.xcresult
-          if-no-files-found: ignore
-
   linux-browser:
     runs-on: ubuntu-24.04
     timeout-minutes: 30

From 366b3c9e2a8210b0efb6067ec23bcf088bfcf8bd Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Wed, 30 Sep 2026 16:43:58 -0700
Subject: [PATCH 11/74] Fix drag-select failing when several transcripts share
 a frame (#632)

* Fix drag-select failing when several transcripts share a frame

The markdown selection registry was one thread-local list that every
transcript's frame reset cleared. With a side chat or subagent tab painted
beside the main chat, only the last-painted transcript kept its text in
the registry, so a drag anchored in any other one resolved to nothing.
Triple-click still worked because its span is stored at mouse-down.

Give each transcript a surface id (its entity id). Its reset clears only
its own entries, entries are stamped with the surface they were painted
in, and a drag resolves only against the surface it started in.

Adds a two-pane regression test.

* Keep forked panes' selections apart and prune closed panes' entries

A side chat's forked history repeats its parent's entry ids, so both
transcripts paint the same selection keys and a selection in one washed
the other too. The selection now records the surface it began on; the
wash and drag resolution use that instead of a separate thread-local.

A surface that stops painting (closed side chat or subagent tab) never
resets again, so its registry entries lived for the rest of the session
and every frame's reset walked them. Drop a surface's entries once a
full cycle of another surface's resets passes without it.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/markdown/render.rs    | 235 ++++++++++++++++++++++++++--
 crates/ui/src/markdown/selection.rs |  35 ++++-
 crates/ui/src/transcript.rs         |  12 +-
 3 files changed, 257 insertions(+), 25 deletions(-)

diff --git a/crates/ui/src/markdown/render.rs b/crates/ui/src/markdown/render.rs
index f92e30bc9a..7faa45f52e 100644
--- a/crates/ui/src/markdown/render.rs
+++ b/crates/ui/src/markdown/render.rs
@@ -8,7 +8,7 @@
 //! chunk opacity veil over the text runs (see [`super::veil`]) — opacity only,
 //! zero translate, applied after layout-relevant properties are fixed.
 
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::ops::Range;
 use std::path::PathBuf;
@@ -1213,6 +1213,7 @@ pub(super) fn flat_text_presented_element(
     let underlay = canvas(
         |bounds, window, _| window.insert_hitbox(bounds, gpui::HitboxBehavior::Normal),
         move |_, hitbox, window, _| {
+            let surface = PAINTING_SURFACE.with(Cell::get);
             for range in &code_ranges {
                 for rect in range_rects(&layout, range, INLINE_CODE_PAD_X, INLINE_CODE_INSET_Y) {
                     window.paint_quad(quad(
@@ -1225,7 +1226,7 @@ pub(super) fn flat_text_presented_element(
                     ));
                 }
             }
-            if let Some(range) = super::selection::wash_range(&sel_key) {
+            if let Some(range) = super::selection::wash_range(surface, &sel_key) {
                 let range = offsets
                     .as_ref()
                     .map_or_else(|| range.clone(), |map| map.displayed_range(range.clone()));
@@ -1245,6 +1246,7 @@ pub(super) fn flat_text_presented_element(
             // mouse listeners.
             REGISTRY.with(|r| {
                 r.borrow_mut().push(RegEntry {
+                    surface,
                     key: sel_key.clone(),
                     text: flat_text.clone(),
                     layout: layout.clone(),
@@ -1255,6 +1257,7 @@ pub(super) fn flat_text_presented_element(
                 window,
                 hitbox,
                 &sel_key,
+                surface,
                 &flat_text,
                 &layout,
                 offsets.clone(),
@@ -1354,7 +1357,8 @@ fn paint_text_selection_with_wash(
     layout: &gpui::TextLayout,
     wash: Hsla,
 ) {
-    if let Some(range) = super::selection::wash_range(key) {
+    let surface = PAINTING_SURFACE.with(Cell::get);
+    if let Some(range) = super::selection::wash_range(surface, key) {
         for rect in range_rects(layout, &range, 0.0, 0.0) {
             window.paint_quad(quad(
                 rect,
@@ -1368,13 +1372,14 @@ fn paint_text_selection_with_wash(
     }
     REGISTRY.with(|r| {
         r.borrow_mut().push(RegEntry {
+            surface,
             key: key.clone(),
             text: text.clone(),
             layout: layout.clone(),
             offsets: None,
         })
     });
-    register_selection_listeners(window, hitbox, key, text, layout, None);
+    register_selection_listeners(window, hitbox, key, surface, text, layout, None);
 }
 
 /// The wrapping div shared by every selectable text region: markdown
@@ -1418,6 +1423,9 @@ fn code_line_selection_key(row_key: &str, code_ix: usize, line_ix: usize) -> std
 /// continuity model that lets a drag span paragraphs/list items (Zed gets
 /// this for free from its single-element markdown; our tree rebuilds it).
 struct RegEntry {
+    /// Which painted transcript this element belongs to (see
+    /// `selection_frame_reset_for`); 0 for surfaces that never share a frame.
+    surface: u64,
     key: std::sync::Arc<str>,
     text: SharedString,
     layout: gpui::TextLayout,
@@ -1426,6 +1434,11 @@ struct RegEntry {
 
 thread_local! {
     static REGISTRY: RefCell<Vec<RegEntry>> = const { RefCell::new(Vec::new()) };
+    /// The surface currently painting: set by its reset canvas, which paints
+    /// before any of its text, and stamped onto each entry it registers.
+    static PAINTING_SURFACE: Cell<u64> = const { Cell::new(0) };
+    /// Surfaces whose reset painted since the latest one's previous reset.
+    static PAINTED_SURFACES: RefCell<Vec<u64>> = const { RefCell::new(Vec::new()) };
 }
 
 #[cfg(test)]
@@ -1466,13 +1479,38 @@ pub(super) fn selection_test_snapshot(
 /// the transcript root (before any markdown), so each frame's registry holds
 /// exactly that frame's visible text elements in paint order.
 pub fn selection_frame_reset() -> impl IntoElement {
+    selection_frame_reset_for(0)
+}
+
+/// `selection_frame_reset` for one of several surfaces painted in the same
+/// frame (the main chat beside a side chat or subagent tab). It clears only
+/// its own surface's entries and stamps the text painted after it, so
+/// another transcript's reset can't wipe this one's drag anchor.
+///
+/// A surface that stops painting (closed side chat or subagent tab) never
+/// resets again, so its entries are dropped once a full cycle of this
+/// surface's resets passes without it.
+pub fn selection_frame_reset_for(surface: u64) -> impl IntoElement {
     canvas(
         |_, _, _| (),
-        |_, _, _, _| {
-            REGISTRY.with(|r| {
-                r.borrow_mut()
-                    .retain(|e| !selection_scope(&e.key).is_empty())
-            })
+        move |_, _, _, _| {
+            PAINTING_SURFACE.with(|s| s.set(surface));
+            PAINTED_SURFACES.with(|painted| {
+                let mut painted = painted.borrow_mut();
+                // Seeing this surface again closes a cycle: `painted` now
+                // holds every surface still on screen.
+                let cycle = painted.contains(&surface);
+                REGISTRY.with(|r| {
+                    r.borrow_mut().retain(|e| {
+                        !selection_scope(&e.key).is_empty()
+                            || (e.surface != surface && (!cycle || painted.contains(&e.surface)))
+                    })
+                });
+                if cycle {
+                    painted.clear();
+                }
+                painted.push(surface);
+            });
         },
     )
     .absolute()
@@ -1517,9 +1555,14 @@ fn registry_point(position: gpui::Point<gpui::Pixels>) -> Option<(usize, usize)>
     REGISTRY.with(|r| {
         let reg = r.borrow();
         let anchor = super::selection::anchor_key().unwrap_or_default();
+        // A drag only resolves against its own surface, so a second
+        // transcript on screen can't capture it.
+        let anchor_surface = super::selection::anchor_surface();
         let mut best: Option<(usize, f32, f32)> = None;
         for (ei, entry) in reg.iter().enumerate() {
-            if selection_scope(&entry.key) != selection_scope(&anchor) {
+            if selection_scope(&entry.key) != selection_scope(&anchor)
+                || entry.surface != anchor_surface
+            {
                 continue;
             }
             let b = entry.layout.bounds();
@@ -1568,7 +1611,7 @@ fn resolve_drag(head: (usize, usize)) -> bool {
         let filtered: Vec<_> = reg
             .iter()
             .enumerate()
-            .filter(|(_, e)| selection_scope(&e.key) == scope)
+            .filter(|(_, e)| selection_scope(&e.key) == scope && e.surface == entry.surface)
             .collect();
         let Some(index) = filtered.iter().position(|(ix, _)| *ix == head.0) else {
             return false;
@@ -1598,6 +1641,7 @@ fn register_selection_listeners(
     window: &mut Window,
     hitbox: gpui::Hitbox,
     key: &std::sync::Arc<str>,
+    surface: u64,
     text: &SharedString,
     layout: &gpui::TextLayout,
     offsets: Option<super::link_presentation::OffsetMap>,
@@ -1620,12 +1664,12 @@ fn register_selection_listeners(
                 match e.click_count {
                     2 => {
                         let range = super::selection::word_range(&text, ix);
-                        super::selection::begin_with_span(&key, &text, range);
+                        super::selection::begin_with_span_in(surface, &key, &text, range);
                     }
                     n if n >= 3 => {
-                        super::selection::begin_with_span(&key, &text, 0..text.len());
+                        super::selection::begin_with_span_in(surface, &key, &text, 0..text.len());
                     }
-                    _ => super::selection::begin(&key, ix),
+                    _ => super::selection::begin_in(surface, &key, ix),
                 }
                 window.refresh();
             } else if super::selection::clear_if_owner(&key) {
@@ -2800,6 +2844,169 @@ mod tests {
         }
     }
 
+    /// Two transcripts painted side by side (main chat + side chat or subagent
+    /// tab), each opening with its own `selection_frame_reset()`. A side
+    /// chat's forked history repeats its parent's row keys: `prefixes` equal.
+    struct TwoPaneSelectionHarness {
+        prefixes: [&'static str; 2],
+        second_pane: bool,
+    }
+
+    impl TwoPaneSelectionHarness {
+        fn new(prefixes: [&'static str; 2]) -> Self {
+            Self {
+                prefixes,
+                second_pane: true,
+            }
+        }
+    }
+
+    impl Render for TwoPaneSelectionHarness {
+        fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+            let theme = Theme::of(cx).clone();
+            let pane = |prefix: &str, surface: u64| {
+                let opts = RenderOptions::settled(prefix.to_string().into());
+                div()
+                    .w(px(320.0))
+                    .h_full()
+                    .child(selection_frame_reset_for(surface))
+                    .child(text_element(
+                        &[InlineRun {
+                            text: "alpha beta gamma delta".into(),
+                            style: InlineStyle::default(),
+                        }],
+                        MD_TEXT_SIZE,
+                        MD_LINE_HEIGHT,
+                        false,
+                        0,
+                        0,
+                        &opts,
+                        &theme,
+                    ))
+            };
+            div()
+                .size_full()
+                .flex()
+                .child(pane(self.prefixes[0], 1))
+                .when(self.second_pane, |el| el.child(pane(self.prefixes[1], 2)))
+        }
+    }
+
+    #[gpui::test]
+    fn dragging_selects_text_in_every_pane_of_a_two_transcript_layout(cx: &mut TestAppContext) {
+        let _selection = super::super::selection::test_state_lock();
+        cx.update(|cx| cx.set_global(Theme::dark()));
+        let (_, cx) = cx.add_window_view(|_, _| TwoPaneSelectionHarness::new(["pane-a", "pane-b"]));
+        cx.simulate_resize(size(px(640.0), px(240.0)));
+        cx.update(|window, cx| {
+            window.refresh();
+            let _ = window.draw(cx);
+        });
+
+        // Each pane is 320px wide; drag across the start of its text. The
+        // last-painted pane is the control: it always worked.
+        for (name, left) in [("pane-b", 320.0), ("pane-a", 0.0)] {
+            let start = point(px(left + 1.0), px(9.0));
+            cx.simulate_event(gpui::MouseDownEvent {
+                button: gpui::MouseButton::Left,
+                position: start,
+                click_count: 1,
+                ..Default::default()
+            });
+            cx.simulate_event(gpui::MouseMoveEvent {
+                position: start + point(px(60.0), px(0.0)),
+                pressed_button: Some(gpui::MouseButton::Left),
+                ..Default::default()
+            });
+            let selected = super::super::selection::selected_text();
+            super::super::selection::end_active_drag();
+            super::super::selection::clear_if_owner(&format!("{name}:0"));
+            assert!(
+                selected.is_some_and(|text| !text.is_empty()),
+                "a drag in {name} must select text"
+            );
+        }
+    }
+
+    #[gpui::test]
+    fn a_forked_pane_sharing_keys_keeps_its_selection_to_itself(cx: &mut TestAppContext) {
+        use super::super::selection;
+        let _selection = selection::test_state_lock();
+        cx.update(|cx| cx.set_global(Theme::dark()));
+        let (_, cx) = cx.add_window_view(|_, _| TwoPaneSelectionHarness::new(["fork", "fork"]));
+        cx.simulate_resize(size(px(640.0), px(240.0)));
+        cx.update(|window, cx| {
+            window.refresh();
+            let _ = window.draw(cx);
+        });
+
+        // Both panes paint `fork:0`. Whichever pane the drag starts in, it
+        // must select there (the other pane's same-key listener must not
+        // clear it) and wash only there.
+        for (surface, other, left) in [(1, 2, 0.0), (2, 1, 320.0)] {
+            let start = point(px(left + 1.0), px(9.0));
+            let end = start + point(px(60.0), px(0.0));
+            cx.simulate_event(gpui::MouseDownEvent {
+                button: gpui::MouseButton::Left,
+                position: start,
+                click_count: 1,
+                ..Default::default()
+            });
+            cx.simulate_event(gpui::MouseMoveEvent {
+                position: end,
+                pressed_button: Some(gpui::MouseButton::Left),
+                ..Default::default()
+            });
+            cx.simulate_event(gpui::MouseUpEvent {
+                button: gpui::MouseButton::Left,
+                position: end,
+                ..Default::default()
+            });
+            let selected = selection::selected_text();
+            let washed = selection::wash_range(surface, "fork:0");
+            let leaked = selection::wash_range(other, "fork:0");
+            selection::clear_if_owner("fork:0");
+            let selected = selected.unwrap_or_default();
+            assert!(
+                "alpha beta gamma delta".starts_with(&selected) && !selected.is_empty(),
+                "a drag in surface {surface} copies its own text, got {selected:?}"
+            );
+            assert_eq!(washed, Some(0..selected.len()), "surface {surface} washes");
+            assert_eq!(leaked, None, "surface {other} stays unwashed");
+        }
+    }
+
+    #[gpui::test]
+    fn a_closed_pane_leaves_no_registry_entries_behind(cx: &mut TestAppContext) {
+        let _selection = super::super::selection::test_state_lock();
+        cx.update(|cx| cx.set_global(Theme::dark()));
+        let (view, cx) =
+            cx.add_window_view(|_, _| TwoPaneSelectionHarness::new(["pane-a", "pane-b"]));
+        cx.simulate_resize(size(px(640.0), px(240.0)));
+        let entries = |surface: u64| {
+            REGISTRY.with(|r| r.borrow().iter().filter(|e| e.surface == surface).count())
+        };
+        cx.update(|window, cx| {
+            window.refresh();
+            let _ = window.draw(cx);
+        });
+        assert!(entries(2) > 0);
+
+        // The side chat closes: its reset never paints again.
+        view.update(cx, |harness, cx| {
+            harness.second_pane = false;
+            cx.notify();
+        });
+        for _ in 0..2 {
+            cx.update(|window, cx| {
+                window.refresh();
+                let _ = window.draw(cx);
+            });
+        }
+        assert_eq!(entries(2), 0, "the closed pane's text is dropped");
+        assert!(entries(1) > 0, "the open pane keeps its text");
+    }
+
     #[gpui::test]
     fn code_block_lines_participate_in_text_selection(cx: &mut TestAppContext) {
         let _selection = super::super::selection::test_state_lock();
diff --git a/crates/ui/src/markdown/selection.rs b/crates/ui/src/markdown/selection.rs
index 74639c573e..3bf2743d49 100644
--- a/crates/ui/src/markdown/selection.rs
+++ b/crates/ui/src/markdown/selection.rs
@@ -30,6 +30,9 @@ pub struct Span {
 
 #[derive(Clone, Default)]
 struct MdSelection {
+    /// Painted surface (transcript) the selection lives in. Keys are only
+    /// unique within one: a side chat's forked history repeats its parent's.
+    surface: u64,
     /// Element that owns the drag (where the mouse went down).
     anchor_key: String,
     /// Byte offset of the anchor within its element.
@@ -87,7 +90,13 @@ pub fn resolve_spans(elements: &[(&str, &str)], a: (usize, usize), b: (usize, us
 
 /// Begin a drag anchored at `(key, ix)`; claims the global selection.
 pub fn begin(key: &str, ix: usize) {
+    begin_in(0, key, ix);
+}
+
+/// `begin` on one of several surfaces painted in the same frame.
+pub(crate) fn begin_in(surface: u64, key: &str, ix: usize) {
     *state().lock().unwrap() = Some(MdSelection {
+        surface,
         anchor_key: key.to_string(),
         anchor_ix: ix,
         dragging: true,
@@ -98,7 +107,13 @@ pub fn begin(key: &str, ix: usize) {
 
 /// Begin with an immediate span (double/triple click inside one element).
 pub fn begin_with_span(key: &str, text: &str, range: Range<usize>) {
+    begin_with_span_in(0, key, text, range);
+}
+
+/// `begin_with_span` on one of several surfaces painted in the same frame.
+pub(crate) fn begin_with_span_in(surface: u64, key: &str, text: &str, range: Range<usize>) {
     *state().lock().unwrap() = Some(MdSelection {
+        surface,
         anchor_key: key.to_string(),
         anchor_ix: range.start,
         dragging: true,
@@ -126,6 +141,11 @@ pub(crate) fn anchor_key() -> Option<String> {
         .map(|s| s.anchor_key.clone())
 }
 
+/// The surface the selection lives in (0 when there is none).
+pub(crate) fn anchor_surface() -> u64 {
+    state().lock().unwrap().as_ref().map_or(0, |s| s.surface)
+}
+
 /// Whether a markdown selection drag is currently in flight.
 pub fn is_dragging() -> bool {
     state()
@@ -268,10 +288,11 @@ pub fn clear_if_owner(key: &str) -> bool {
     false
 }
 
-/// The wash range for `key` this frame (empty ⇒ nothing to paint).
-pub fn wash_range(key: &str) -> Option<Range<usize>> {
+/// The wash range for `key` painted on `surface` this frame (empty ⇒ nothing
+/// to paint). Another surface showing the same key stays unwashed.
+pub fn wash_range(surface: u64, key: &str) -> Option<Range<usize>> {
     let guard = state().lock().unwrap();
-    let sel = guard.as_ref()?;
+    let sel = guard.as_ref().filter(|sel| sel.surface == surface)?;
     sel.spans
         .iter()
         .find(|s| s.key == key && !s.range.is_empty())
@@ -381,9 +402,9 @@ mod tests {
         let spans = resolve_spans(&elems(), (0, 6), (1, 6));
         assert!(update_spans(spans.clone()));
         assert!(!update_spans(spans)); // unchanged ⇒ no repaint
-        assert_eq!(wash_range("p1"), Some(6..15));
-        assert_eq!(wash_range("p2"), Some(0..6));
-        assert_eq!(wash_range("p3"), None);
+        assert_eq!(wash_range(0, "p1"), Some(6..15));
+        assert_eq!(wash_range(0, "p2"), Some(0..6));
+        assert_eq!(wash_range(0, "p3"), None);
         assert_eq!(end_drag("p1").as_deref(), Some("paragraph\nsecond"));
         assert_eq!(selected_text().as_deref(), Some("paragraph\nsecond"));
         // Settled: a down elsewhere clears via the owner's listener.
@@ -434,7 +455,7 @@ mod tests {
     fn double_click_span() {
         let _state = test_state_lock();
         begin_with_span("p1", "hello world", 6..11);
-        assert_eq!(wash_range("p1"), Some(6..11));
+        assert_eq!(wash_range(0, "p1"), Some(6..11));
         assert_eq!(end_drag("p1").as_deref(), Some("world"));
     }
 
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index ef584e9b8e..be8d082944 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -9025,10 +9025,14 @@ impl Render for Transcript {
             .on_mouse_move(cx.listener(Self::on_selection_mouse_move))
             .on_mouse_up(MouseButton::Left, cx.listener(Self::on_selection_mouse_up))
             .on_mouse_up_out(MouseButton::Left, cx.listener(Self::on_selection_mouse_up))
-            // FIRST child ⇒ paints first: clears the frame's markdown text-
-            // selection registry before any row's text elements re-register
-            // (document paint order = selection order; see markdown/render.rs).
-            .child(crate::markdown::render::selection_frame_reset())
+            // FIRST child ⇒ paints first: clears this transcript's slice of the
+            // frame's markdown text-selection registry before any row's text
+            // elements re-register (document paint order = selection order;
+            // see markdown/render.rs). Keyed by entity so a side chat or
+            // subagent tab painted in the same frame can't wipe it.
+            .child(crate::markdown::render::selection_frame_reset_for(
+                cx.entity_id().as_u64(),
+            ))
             .child(content)
             .child(rail);
         // Full-size viewer for a clicked user-bubble thumbnail

From a2a593a5d51110db2f1bd3302235451662ee8c1a Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Wed, 30 Sep 2026 16:46:25 -0700
Subject: [PATCH 12/74] Bump version to v0.2.100

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 34 +++++++++++++++++-----------------
 Cargo.toml |  2 +-
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9d2ae3fd6d..ebe7663a14 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12101,7 +12101,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "clap",
@@ -12123,7 +12123,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "async-trait",
  "chrono",
@@ -12147,7 +12147,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "chrono",
  "loro",
@@ -12161,7 +12161,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12201,7 +12201,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12228,14 +12228,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12253,7 +12253,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "serde",
  "serde_json",
@@ -12270,7 +12270,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12298,7 +12298,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -12309,7 +12309,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12328,7 +12328,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -12351,7 +12351,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -12385,7 +12385,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -12402,7 +12402,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "clap",
@@ -12417,7 +12417,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -12484,7 +12484,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.99"
+version = "0.2.100"
 dependencies = [
  "anyhow",
  "futures",
diff --git a/Cargo.toml b/Cargo.toml
index f71c5fbc6a..9f66383825 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.99"
+version = "0.2.100"
 edition = "2024"
 license = "MIT"
 publish = false

From c168ba5b4589352877ad5450168860a1ad308a26 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 17:12:22 -0700
Subject: [PATCH 13/74] windows: run the crate suites as two parallel jobs

---
 .github/workflows/windows.yml | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 33e5c69b45..24fc44a313 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -63,7 +63,9 @@ jobs:
           $headlessResult = $LASTEXITCODE
           if ($nativeResult -ne 0 -or $headlessResult -ne 0) { exit 1 }
 
-  crate-tests:
+  # The crate suites compile different package sets, so the two jobs below each
+  # build what they need in parallel instead of one job building them in turn.
+  harness-app-tests:
     runs-on: windows-2022
     timeout-minutes: 45
     steps:
@@ -75,6 +77,13 @@ jobs:
         run: cargo test --release --locked -p gpui_windows --lib layout
       - name: Application and updater tests
         run: cargo test --release --locked -p zeron -p zeron-update
+
+  engine-tests:
+    runs-on: windows-2022
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/windows-ci-setup
       - name: Engine unit tests
         run: cargo test --release --locked -p zeron-engine --lib
       - name: Harness catalog and login tests

From fd3b2c0662901dde913fdaf5031008f5afb9f77e Mon Sep 17 00:00:00 2001
From: Sina Khalili <20732540+SinaKhalili@users.noreply.github.com>
Date: Wed, 30 Sep 2026 17:35:51 -0700
Subject: [PATCH 14/74] footer

---
 apps/landing/public/index.html | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/apps/landing/public/index.html b/apps/landing/public/index.html
index e0243c68e7..8e5edeb7df 100644
--- a/apps/landing/public/index.html
+++ b/apps/landing/public/index.html
@@ -808,6 +808,7 @@
   }
   .footer-inner .right { margin-left: auto; display: flex; align-items: center; gap: 20px; }
   .footer-inner .gh-icon { padding: 0; }
+  .footer-company { flex-basis: 100%; font-size: 11px; }
   footer a:hover { color: var(--dim); }
 
   /* ── mobile ──────────────────────────────────────────── */
@@ -1207,6 +1208,7 @@ <h2>Bring your agents together.</h2>
         </a>
         <span>MIT © 2026</span>
       </div>
+      <small class="footer-company">1499487 B.C. LTD.</small>
     </div>
   </footer>
 

From 9cb1de50f580abe6a081c11c9e8921319aebd783 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 17:37:33 -0700
Subject: [PATCH 15/74] CI: add Linux test helpers (setup action, nextest, apt
 with retries)

A composite action installs the toolchain, a checksum-pinned cargo-nextest
and apt packages (bounded retries, cached .debs), and wires the main-seeded
Rust cache. scripts/ci/test-core.sh runs the harness, engine, sync, update,
doc and preview tests as one build and one nextest run. nextest.toml retries
the two tests that are timing-sensitive under nextest. Not used by any
workflow yet.
---
 .github/actions/linux-ci/action.yml | 78 +++++++++++++++++++++++++++++
 scripts/ci/apt-install.sh           | 41 +++++++++++++++
 scripts/ci/install-nextest.sh       | 17 +++++++
 scripts/ci/nextest.toml             | 24 +++++++++
 scripts/ci/test-core.sh             | 33 ++++++++++++
 5 files changed, 193 insertions(+)
 create mode 100644 .github/actions/linux-ci/action.yml
 create mode 100755 scripts/ci/apt-install.sh
 create mode 100755 scripts/ci/install-nextest.sh
 create mode 100644 scripts/ci/nextest.toml
 create mode 100755 scripts/ci/test-core.sh

diff --git a/.github/actions/linux-ci/action.yml b/.github/actions/linux-ci/action.yml
new file mode 100644
index 0000000000..59d0b9f7ed
--- /dev/null
+++ b/.github/actions/linux-ci/action.yml
@@ -0,0 +1,78 @@
+name: Linux Rust CI setup
+description: >-
+  Rust toolchain, cargo-nextest, optional apt packages (with a cached .deb
+  directory) and the main-seeded Rust cache for Linux test jobs. Run
+  actions/checkout first.
+
+inputs:
+  rust-cache:
+    description: >-
+      rust-cache shared key. Jobs with the same key share one cache, so they
+      must have the same dependency graph.
+    required: true
+  save-rust-cache:
+    description: >-
+      Whether this job may save the cache when it runs on main. Give it to
+      exactly one job per key. Pull requests never save.
+    default: 'false'
+  apt-packages:
+    description: apt packages to install (space separated). Nothing is installed when empty.
+    default: ''
+  apt-cache:
+    description: Name of the cached .deb directory for apt-packages (one per package list).
+    default: ''
+  apt-recommends:
+    description: Install recommended packages too ('true' or 'false').
+    default: 'false'
+
+runs:
+  using: composite
+  steps:
+    - name: Rust toolchain
+      shell: bash
+      run: rustup show active-toolchain || rustup toolchain install
+
+    # apt mirrors on hosted runners occasionally stall for minutes; apt-install.sh
+    # bounds and retries the download and uses a directory of .debs that main
+    # saves to the cache (pull requests only restore it).
+    - name: Restore apt packages
+      id: apt-cache
+      if: inputs.apt-packages != ''
+      uses: actions/cache/restore@v4
+      with:
+        path: ~/apt-debs/*.deb
+        key: apt-debs-v1-${{ inputs.apt-cache }}-${{ hashFiles('scripts/ci/apt-install.sh') }}
+    - name: Install system packages
+      if: inputs.apt-packages != ''
+      shell: bash
+      env:
+        APT_RECOMMENDS: ${{ inputs.apt-recommends == 'true' && '1' || '0' }}
+        APT_PACKAGES: ${{ inputs.apt-packages }}
+      run: |
+        # shellcheck disable=SC2086 # the package list is word-split on purpose
+        bash scripts/ci/apt-install.sh $APT_PACKAGES
+    - name: Save apt packages
+      if: inputs.apt-packages != '' && github.ref == 'refs/heads/main' && steps.apt-cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@v4
+      with:
+        path: ~/apt-debs/*.deb
+        key: apt-debs-v1-${{ inputs.apt-cache }}-${{ hashFiles('scripts/ci/apt-install.sh') }}
+
+    - name: Install cargo-nextest
+      shell: bash
+      run: bash scripts/ci/install-nextest.sh
+
+    # Exported for the rest of the job. Tests and the browser fixture are built in
+    # the dev profile without debug info (smaller, faster to link). CARGO_* variables
+    # are part of the rust-cache key, so every job sharing a cache must set the same.
+    - name: Build settings
+      shell: bash
+      run: echo "CARGO_PROFILE_DEV_DEBUG=0" >> "$GITHUB_ENV"
+
+    - uses: Swatinem/rust-cache@v2
+      with:
+        prefix-key: ci-linux-v1
+        shared-key: ${{ inputs.rust-cache }}
+        add-job-id-key: false
+        save-if: ${{ inputs.save-rust-cache == 'true' && github.ref == 'refs/heads/main' }}
+        cache-on-failure: true
diff --git a/scripts/ci/apt-install.sh b/scripts/ci/apt-install.sh
new file mode 100755
index 0000000000..bf7254127f
--- /dev/null
+++ b/scripts/ci/apt-install.sh
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Install apt packages from a user-owned, cacheable .deb directory with
+# stall-resistant retries and per-phase timestamps.
+#   usage: APT_DEB_DIR=~/apt-debs [APT_RECOMMENDS=1] apt-install.sh pkg...
+# Hosted-runner apt mirrors occasionally stall for minutes (observed 7-14 min
+# for a ~400 MB install); a bounded download retry + actions/cache of the .debs
+# makes the common case ~20 s and the bad case bounded.
+set -uo pipefail
+dir=${APT_DEB_DIR:-$HOME/apt-debs}
+mkdir -p "$dir/partial"
+export DEBIAN_FRONTEND=noninteractive
+ts() { while IFS= read -r l; do printf '[%(%T)T] %s\n' -1 "$l"; done; }
+log() { printf '[%(%T)T] apt-install: %s\n' -1 "$*"; }
+
+# No docs/man/locales, no fsync: faster unpack.
+printf '%s\n' force-unsafe-io 'path-exclude=/usr/share/doc/*' 'path-exclude=/usr/share/man/*' \
+  'path-exclude=/usr/share/locale/*' 'path-exclude=/usr/share/info/*' | sudo tee /etc/dpkg/dpkg.cfg.d/90ci >/dev/null
+sudo rm -f /var/lib/man-db/auto-update
+
+APT=(-y -o Acquire::Retries=3 -o Acquire::http::Timeout=15 -o Acquire::Languages=none
+     -o "Dir::Cache::archives=$dir" -o APT::Sandbox::User=root -o DPkg::Lock::Timeout=120)
+[ "${APT_RECOMMENDS:-0}" = 1 ] || APT+=(--no-install-recommends)
+
+log "cached debs: $(ls "$dir"/*.deb 2>/dev/null | wc -l)"
+log "update"
+# Only Ubuntu packages are needed; unrelated runner repositories can be out of sync.
+sudo timeout 120 apt-get update -qq -o Acquire::Retries=3 -o Acquire::http::Timeout=15 \
+  -o Dir::Etc::sourcelist="sources.list.d/ubuntu.sources" -o Dir::Etc::sourceparts="-" 2>&1 | ts
+
+ok=0
+for attempt in 1 2 3 4; do
+  log "download attempt $attempt"
+  sudo timeout 150 apt-get install "${APT[@]}" --download-only "$@" 2>&1 | ts
+  if [ "${PIPESTATUS[0]}" = 0 ]; then ok=1; break; fi
+done
+[ "$ok" = 1 ] || { log "download failed"; exit 1; }
+log "install"
+sudo apt-get install "${APT[@]}" -qq "$@" 2>&1 | ts
+rc=${PIPESTATUS[0]}
+log "done rc=$rc"
+exit "$rc"
diff --git a/scripts/ci/install-nextest.sh b/scripts/ci/install-nextest.sh
new file mode 100755
index 0000000000..3c4d912058
--- /dev/null
+++ b/scripts/ci/install-nextest.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Install a pinned cargo-nextest release (x86_64 Linux) after verifying its
+# SHA-256, instead of trusting a third-party install action. To bump: change
+# VERSION and SHA256 (from the release's .tar.gz asset).
+set -euo pipefail
+VERSION=0.9.146
+SHA256=682c21b777c333e96fd532e114d3a5a894e0729ab88d94c0a9f20f8419695428
+
+[ "$(uname -m)" = x86_64 ] || { echo "install-nextest.sh: x86_64 only" >&2; exit 1; }
+tmp="$(mktemp -d)"
+trap 'rm -rf "$tmp"' EXIT
+curl --proto '=https' --tlsv1.2 -fsSL --retry 5 -o "$tmp/nextest.tar.gz" \
+  "https://github.com/nextest-rs/nextest/releases/download/cargo-nextest-$VERSION/cargo-nextest-$VERSION-x86_64-unknown-linux-gnu.tar.gz"
+echo "$SHA256  $tmp/nextest.tar.gz" | sha256sum -c -
+mkdir -p "$HOME/.cargo/bin"
+tar -xzf "$tmp/nextest.tar.gz" -C "$HOME/.cargo/bin" cargo-nextest
+cargo nextest --version
diff --git a/scripts/ci/nextest.toml b/scripts/ci/nextest.toml
new file mode 100644
index 0000000000..7666a4adad
--- /dev/null
+++ b/scripts/ci/nextest.toml
@@ -0,0 +1,24 @@
+# cargo-nextest settings for CI (pass with --config-file).
+#
+# Two tests are timing-sensitive and fail now and then when nextest runs many tests
+# at once (the old `cargo test` runs were serial per binary, and the UI run was
+# `--test-threads=1` in the release profile). nextest reports a pass-on-retry as
+# FLAKY, so these stay visible in the log. Remove an override once its test is fixed.
+
+# zeron-ui `state::tests::bootstrap_reports_local_assembly_failure_before_returning_a_handle`
+# picks a "free" port (bind(:0) + drop), makes an engine bootstrap fail, then asserts
+# nothing listens on that port ("failed bootstrap must release the IPC listener").
+# In the dev profile it fails on the first attempt in roughly one run in three and
+# passes on the retry, even when it runs alone: a race in listener teardown or port
+# reuse.
+[[profile.default.overrides]]
+filter = 'package(zeron-ui) & test(bootstrap_reports_local_assembly_failure_before_returning_a_handle)'
+retries = 2
+
+# zeron-harness `opencode::mcp_injection_tests::mcp_injection_reaches_isolated_server_processes`
+# starts `node` fixture scripts and `binary_version` gives each `--version` probe 2 s;
+# on a loaded 4-core runner the probe occasionally times out ("cannot determine
+# opencode version for MCP configuration").
+[[profile.default.overrides]]
+filter = 'package(zeron-harness) & test(mcp_injection_reaches_isolated_server_processes)'
+retries = 2
diff --git a/scripts/ci/test-core.sh b/scripts/ci/test-core.sh
new file mode 100755
index 0000000000..539b1a09ab
--- /dev/null
+++ b/scripts/ci/test-core.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# The Linux Rust tests that used to run as separate `cargo test` invocations in
+# session-sync-regressions, cursor-compatibility and preview-tests, as ONE
+# build and ONE nextest run (separate invocations recompiled the same
+# dependency graph with different feature sets).
+#
+# Same coverage as the old invocations:
+#   zeron-harness  every test binary (cursor-compatibility ran `-p zeron-harness`
+#                  plus `--test pi_rpc` with native-fixture; native-fixture only
+#                  adds the pi_rpc fixture binaries, so it is on for the whole build)
+#   zeron-preview  every test binary (preview-tests)
+#   zeron-doc      lib + attachments_roundtrip (cursor-compatibility)
+#   zeron-sync, zeron-update   lib only (session-sync-regressions)
+#   zeron-engine   lib + the integration tests named below. Engine has many other
+#                  integration binaries (live agents etc.) that no workflow ran, so
+#                  they are listed instead of globbed to avoid compiling them.
+# nextest does not run doctests; these crates have none (their doc comments
+# contain no Rust code blocks).
+set -euo pipefail
+cd "$(dirname "$0")/../.."
+
+tests=()
+for f in crates/harness/tests/*.rs crates/preview/tests/*.rs; do
+  tests+=(--test "$(basename "$f" .rs)")
+done
+for t in session_publication restart_resume codex_subagents local_profiles message_queue pi_resume attachments_roundtrip; do
+  tests+=(--test "$t")
+done
+
+exec cargo nextest run --config-file scripts/ci/nextest.toml --locked --no-fail-fast \
+  -p zeron-harness -p zeron-engine -p zeron-sync -p zeron-update -p zeron-doc -p zeron-preview \
+  --features zeron-harness/native-fixture \
+  --lib --bins "${tests[@]}"

From 878307a3d685a216e4100324be939a75c03eef65 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Wed, 30 Sep 2026 17:37:33 -0700
Subject: [PATCH 16/74] CI: run Linux tests with nextest on a dev profile and
 one shared build

- ui-tests: session-sync-regressions becomes core-tests (one build for the
  harness, engine, sync, update, doc and preview tests); ui-tests and
  linux-browser use nextest, the dev profile and a shared rust-cache
- cursor-compatibility: the Rust half runs from core-tests on PRs and main;
  it only runs here for release, cursor-sdk-update dispatch and manual runs
- preview-tests: the Linux leg moves into core-tests
- linux-installer: install desktop-file-utils with bounded apt retries
---
 .github/workflows/cursor-compatibility.yml | 33 +++++----
 .github/workflows/linux-installer.yml      |  8 ++-
 .github/workflows/preview-tests.yml        |  4 +-
 .github/workflows/ui-tests.yml             | 84 ++++++++++------------
 4 files changed, 63 insertions(+), 66 deletions(-)

diff --git a/.github/workflows/cursor-compatibility.yml b/.github/workflows/cursor-compatibility.yml
index 329443b7c1..a42c7337ff 100644
--- a/.github/workflows/cursor-compatibility.yml
+++ b/.github/workflows/cursor-compatibility.yml
@@ -32,10 +32,6 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: '22'
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
       - name: Dependency updater validation
         run: python3 scripts/test-update-cursor-sdk.py
       - name: Install the exact SDK selected by this engine
@@ -44,14 +40,21 @@ jobs:
           npm install --prefix "$RUNNER_TEMP/cursor-sdk-contract" --ignore-scripts --no-audit --no-fund "$pin"
       - name: Actual SDK token expiry, stream invalidation, and transient auth recovery
         run: node scripts/test-cursor-sdk-auth.mjs "$RUNNER_TEMP/cursor-sdk-contract/node_modules/@cursor/sdk"
-      - name: Harness compatibility, steering, and session recovery
-        run: cargo test --locked -p zeron-harness
-      - name: Durable commands and engine message delivery
-        run: |
-          cargo test --locked -p zeron-doc
-          cargo test --locked -p zeron-engine --test message_queue
-          cargo test --locked -p zeron-engine --lib sessions::tests
-      - name: Native Pi RPC driver
-        run: |
-          cargo test --locked -p zeron-harness --features native-fixture --test pi_rpc
-          cargo test --locked -p zeron-engine --test pi_resume
+
+  # The Rust half (harness compatibility, steering, session recovery, durable
+  # commands, message delivery, native Pi RPC) is part of the `core-tests` job
+  # of ui-tests.yml, which already runs on pull requests and on main with a
+  # superset of this workflow's paths. Run it here only for the callers that
+  # do not get that: release.yml (tag push), cursor-sdk-update.yml (manual
+  # dispatch on the update branch) and manual runs.
+  rust-tests:
+    if: ${{ github.event_name != 'pull_request' && !(github.event_name == 'push' && github.ref == 'refs/heads/main') }}
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/linux-ci
+        with:
+          rust-cache: core # saved by core-tests in ui-tests.yml
+      - name: Harness, engine, sync, update, doc and preview tests
+        run: scripts/ci/test-core.sh
diff --git a/.github/workflows/linux-installer.yml b/.github/workflows/linux-installer.yml
index 574f803f36..62c990069b 100644
--- a/.github/workflows/linux-installer.yml
+++ b/.github/workflows/linux-installer.yml
@@ -6,6 +6,7 @@ on:
       - 'edge/src/install.sh'
       - 'scripts/package-linux.sh'
       - 'scripts/test-linux-desktop-entry.sh'
+      - 'scripts/ci/apt-install.sh'
       - 'dist/zeron.desktop'
       - 'dist/zeron.png'
       - '.github/workflows/linux-installer.yml'
@@ -15,6 +16,7 @@ on:
       - 'edge/src/install.sh'
       - 'scripts/package-linux.sh'
       - 'scripts/test-linux-desktop-entry.sh'
+      - 'scripts/ci/apt-install.sh'
       - 'dist/zeron.desktop'
       - 'dist/zeron.png'
       - '.github/workflows/linux-installer.yml'
@@ -34,9 +36,9 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Desktop entry validator
-        run: |
-          sudo apt-get update -qq -o Dir::Etc::sourcelist="sources.list.d/ubuntu.sources" -o Dir::Etc::sourceparts="-"
-          sudo apt-get install -y -qq desktop-file-utils
+        # Skips apt when the runner image already has it; otherwise the install
+        # retries and is bounded instead of hanging on a stalled mirror.
+        run: command -v desktop-file-validate || bash scripts/ci/apt-install.sh desktop-file-utils
       # Both installers, offline, under a throwaway HOME (no network, no systemd).
       - name: Installers write a valid launcher entry
         run: scripts/test-linux-desktop-entry.sh
diff --git a/.github/workflows/preview-tests.yml b/.github/workflows/preview-tests.yml
index ff8b162392..d4115aef2a 100644
--- a/.github/workflows/preview-tests.yml
+++ b/.github/workflows/preview-tests.yml
@@ -11,10 +11,12 @@ concurrency:
   group: preview-tests-${{ github.ref }}
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
+  # The Linux leg runs in the `core-tests` job of ui-tests.yml (same tests, one
+  # shared build with the rest of the Rust tests).
   networking:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [macos-latest]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30
     steps:
diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 93a8226a23..29b9e30006 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -7,6 +7,8 @@ on:
       - 'Cargo.lock'
       - 'rust-toolchain.toml'
       - 'crates/**'
+      - '.github/actions/linux-ci/**'
+      - 'scripts/ci/**'
       - 'scripts/test-linux-browser.sh'
       - 'scripts/run-macos-browser-fixture.sh'
       - 'dist/macos/Info.plist'
@@ -19,6 +21,8 @@ on:
       - 'Cargo.lock'
       - 'rust-toolchain.toml'
       - 'crates/**'
+      - '.github/actions/linux-ci/**'
+      - 'scripts/ci/**'
       - 'scripts/test-linux-browser.sh'
       - 'scripts/run-macos-browser-fixture.sh'
       - 'dist/macos/Info.plist'
@@ -67,49 +71,38 @@ jobs:
             return files.some(file => affectsIOS(file.filename)
               || affectsIOS(file.previous_filename));
 
-  session-sync-regressions:
+  # Every Linux Rust test that is not UI: one build, one nextest run (see
+  # scripts/ci/test-core.sh). Replaces session-sync-regressions and the Rust
+  # steps of cursor-compatibility and preview-tests.
+  core-tests:
     runs-on: ubuntu-24.04
-    timeout-minutes: 20
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - name: Rust toolchain
-        run: rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: ./.github/actions/linux-ci
         with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
-      - name: OpenCode protocol and permission regressions
-        run: |
-          cargo test --locked -p zeron-harness --lib opencode::
-          cargo test --locked -p zeron-harness --test opencode
-      - name: Durable session publication and recovery
-        run: |
-          cargo test --locked -p zeron-sync --lib
-          cargo test --locked -p zeron-update --lib
-          cargo test --locked -p zeron-engine --lib --test session_publication --test restart_resume --test codex_subagents --test local_profiles
+          rust-cache: core
+          save-rust-cache: 'true'
+      - name: Harness, engine, sync, update, doc and preview tests
+        run: scripts/ci/test-core.sh
 
   ui-tests:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - name: GPUI system dependencies
-        run: |
-          # Only Ubuntu packages are needed; unrelated runner repositories can be out of sync.
-          sudo apt-get update -qq -o Dir::Etc::sourcelist="sources.list.d/ubuntu.sources" -o Dir::Etc::sourceparts="-"
-          sudo apt-get install -y -qq \
-            libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev \
-            libx11-dev libxcb1-dev libx11-xcb-dev \
-            libfontconfig1-dev libfreetype-dev libasound2-dev \
-            libvulkan-dev pkg-config cmake libwebkit2gtk-4.1-dev libjson-glib-dev
-      - name: Rust toolchain
-        run: rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: ./.github/actions/linux-ci
         with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
+          rust-cache: ui
+          save-rust-cache: 'true'
+          apt-cache: gpui
+          apt-packages: >-
+            libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev
+            libx11-dev libxcb1-dev libx11-xcb-dev
+            libfontconfig1-dev libfreetype-dev libasound2-dev
+            libvulkan-dev pkg-config cmake libwebkit2gtk-4.1-dev libjson-glib-dev
       - name: UI and headless layout regressions
-        run: cargo test --release --locked -p zeron-ui --lib -- --test-threads=1
+        run: cargo nextest run --config-file scripts/ci/nextest.toml --locked --no-fail-fast -p zeron-ui --lib
 
   macos-frame-recovery:
     runs-on: macos-latest
@@ -235,28 +228,25 @@ jobs:
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - name: Native browser and GPUI dependencies
-        run: |
-          # Only Ubuntu packages are needed; unrelated runner repositories can be out of sync.
-          sudo apt-get update -qq -o Dir::Etc::sourcelist="sources.list.d/ubuntu.sources" -o Dir::Etc::sourceparts="-"
-          sudo apt-get install -y -qq \
-            libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev \
-            libx11-dev libxcb1-dev libx11-xcb-dev libfontconfig1-dev \
-            libfreetype-dev libasound2-dev libvulkan-dev pkg-config cmake \
-            libwebkit2gtk-4.1-dev libjson-glib-dev xvfb xdotool openbox \
-            weston ffmpeg imagemagick fonts-noto-cjk
-      - name: Rust toolchain
-        run: rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: ./.github/actions/linux-ci
         with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
+          # Same dependency graph as ui-tests, which saves this cache on main.
+          rust-cache: ui
+          apt-cache: browser
+          apt-recommends: 'true'
+          apt-packages: >-
+            libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev
+            libx11-dev libxcb1-dev libx11-xcb-dev libfontconfig1-dev
+            libfreetype-dev libasound2-dev libvulkan-dev pkg-config cmake
+            libwebkit2gtk-4.1-dev libjson-glib-dev xvfb xdotool openbox
+            weston ffmpeg imagemagick fonts-noto-cjk
       - name: Build browser fixture
-        run: cargo build --release --locked -p zeron-ui --example browser-fixture --features browser-fixture
+        run: cargo build --locked -p zeron-ui --example browser-fixture --features browser-fixture
       - name: X11 and Wayland browser regressions
         timeout-minutes: 5
         env:
           RUST_LOG: gpui_wgpu=info
+          BROWSER_FIXTURE_BINARY: target/debug/examples/browser-fixture
         run: |
           scripts/test-linux-browser.sh "$RUNNER_TEMP/linux-browser/default"
           VK_DRIVER_FILES=/dev/null scripts/test-linux-browser.sh "$RUNNER_TEMP/linux-browser/opengl"

From c72c66d8adce8a594a7acd342432b33cfb348c62 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Thu, 1 Oct 2026 00:13:10 -0300
Subject: [PATCH 17/74] Add file tree context actions and drag-and-drop moves
 (#514)

* feat(proto): define workspace entry mutation contracts

* feat(engine): move workspace entries without replacement

* feat(engine): delete workspace entries and publish mutations

* feat(files): coordinate workspace mutations across open surfaces

* feat(files): reuse context menus for copy path and add to chat

* feat(files): rename entries inline and confirm deletion

* feat(files): preserve workspace drag origin and enable Windows handles

* feat(files): move tree entries with scoped drop targets

* feat(files): polish tree drag feedback and navigation

* test(files): cover workspace mutations and composer drag regressions

* fix(files): style delete menu action as destructive

* fix(files): reuse icons for all tree context menu actions

* fix(files): show only entry name in delete confirmation

* fix(files): give delete dialog more spacing and shorten action label

* fix(files): refresh mutation revisions after completed saves

* fix(files): refresh editor presentation and syntax after rename

* fix(files): show rename caret and preserve text input focus

* fix(files): copy full paths from the owning workspace

* fix(engine): compare canonical workspace paths on Windows

* Route chat drops through the shared dropzone with origin checks

The branch replaced the main chat's chat_dropzone() call from #612 with an
inline copy, so the main chat validated drag origins but side chats did not.
Both now go through chat_dropzone(), which hands workspace payloads to
attach_workspace_drag() for the target composer. The dropzone fixture now
stamps tree/search payloads with a live explorer origin, and also checks that
an origin-less (stale) payload attaches nowhere.

Also correct the Windows drag note: tree rows drag on every platform; there is
no dedicated drag handle.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/rpc.rs                      |  22 +
 crates/engine/src/workspace_files.rs          |  58 +-
 .../engine/src/workspace_files/mutations.rs   | 735 ++++++++++++++++++
 crates/engine/tests/device_routing.rs         |  53 ++
 crates/engine/tests/workspace_files.rs        |  84 ++
 crates/proto/src/entities.rs                  | 132 ++++
 crates/rpc/src/lib.rs                         |   2 +
 crates/ui/src/files/client.rs                 |  55 +-
 crates/ui/src/files/context_menu.rs           | 322 ++++++++
 crates/ui/src/files/drag.rs                   | 490 ++++++++++++
 crates/ui/src/files/mod.rs                    | 101 ++-
 crates/ui/src/files/model.rs                  | 120 +++
 crates/ui/src/files/mutations.rs              | 445 +++++++++++
 crates/ui/src/files/preview.rs                | 176 ++++-
 crates/ui/src/files/rename.rs                 | 544 +++++++++++++
 crates/ui/src/files/search.rs                 |   6 +-
 crates/ui/src/files/test_support.rs           |  70 ++
 crates/ui/src/files/tree.rs                   | 112 ++-
 crates/ui/src/files/watch.rs                  | 159 +++-
 crates/ui/src/shell.rs                        |  88 ++-
 crates/ui/src/shell/chat_dropzone.rs          |  22 +-
 crates/ui/src/shell/chat_dropzone_tests.rs    |  71 +-
 crates/ui/src/shell/file_mutations.rs         | 316 ++++++++
 crates/ui/src/shell/files_panel.rs            |  34 +
 docs/file-tree-interactions.md                | 103 +++
 docs/research/windows-click-drag-audit.md     |   7 +
 26 files changed, 4271 insertions(+), 56 deletions(-)
 create mode 100644 crates/engine/src/workspace_files/mutations.rs
 create mode 100644 crates/ui/src/files/context_menu.rs
 create mode 100644 crates/ui/src/files/drag.rs
 create mode 100644 crates/ui/src/files/mutations.rs
 create mode 100644 crates/ui/src/files/rename.rs
 create mode 100644 crates/ui/src/files/test_support.rs
 create mode 100644 crates/ui/src/shell/file_mutations.rs
 create mode 100644 docs/file-tree-interactions.md

diff --git a/crates/engine/src/rpc.rs b/crates/engine/src/rpc.rs
index 2ca1fce168..be5d0666fe 100644
--- a/crates/engine/src/rpc.rs
+++ b/crates/engine/src/rpc.rs
@@ -1380,6 +1380,8 @@ fn forwardable(method: &str) -> bool {
             | methods::SEARCH_WORKSPACE_FILES
             | methods::READ_WORKSPACE_IMAGE
             | methods::READ_WORKSPACE_FILE
+            | methods::DELETE_WORKSPACE_ENTRY
+            | methods::MOVE_WORKSPACE_ENTRY
             | methods::WRITE_WORKSPACE_FILE
             | methods::WATCH_WORKSPACE_FILES
             | methods::CREATE_WORKTREE
@@ -3007,6 +3009,24 @@ impl RpcService for EngineRpc {
                 .map_err(RpcError::from)?;
                 RpcReply::value(&file)
             }
+            methods::DELETE_WORKSPACE_ENTRY => {
+                let request: zeron_proto::DeleteWorkspaceEntryRequest = parse_params(params)?;
+                let outcome = self
+                    .workspace_files
+                    .delete_entry(request)
+                    .await
+                    .map_err(RpcError::from)?;
+                RpcReply::value(&outcome)
+            }
+            methods::MOVE_WORKSPACE_ENTRY => {
+                let request: zeron_proto::MoveWorkspaceEntryRequest = parse_params(params)?;
+                let outcome = self
+                    .workspace_files
+                    .move_entry(request)
+                    .await
+                    .map_err(RpcError::from)?;
+                RpcReply::value(&outcome)
+            }
             methods::WRITE_WORKSPACE_FILE => {
                 let request: zeron_proto::WriteWorkspaceFileRequest = parse_params(params)?;
                 let outcome = tokio::time::timeout(
@@ -3807,6 +3827,8 @@ mod tests {
         assert!(forwardable(methods::SEARCH_WORKSPACE_FILES));
         assert!(forwardable(methods::READ_WORKSPACE_FILE));
         assert!(forwardable(methods::READ_WORKSPACE_IMAGE));
+        assert!(forwardable(methods::DELETE_WORKSPACE_ENTRY));
+        assert!(forwardable(methods::MOVE_WORKSPACE_ENTRY));
         assert!(forwardable(methods::WRITE_WORKSPACE_FILE));
         assert!(forwardable(methods::WATCH_WORKSPACE_FILES));
         assert!(forwardable(methods::WATCH_WORKSPACE_GIT_STATUS));
diff --git a/crates/engine/src/workspace_files.rs b/crates/engine/src/workspace_files.rs
index 0eebf92c15..fd89a7d8ac 100644
--- a/crates/engine/src/workspace_files.rs
+++ b/crates/engine/src/workspace_files.rs
@@ -26,6 +26,8 @@ use zeron_rpc::RpcError;
 
 use crate::{Repos, WorkspaceHost};
 
+mod mutations;
+
 const MAX_RELATIVE_PATH_BYTES: usize = 4096;
 const MAX_RELATIVE_PATH_COMPONENTS: usize = 256;
 const MAX_ABSOLUTE_PATH_BYTES: usize = 16 * 1024;
@@ -52,6 +54,7 @@ struct WorkspaceFilesInner {
     repos: Repos,
     workspace: WorkspaceHost,
     device_id: String,
+    mutation_gates: Mutex<HashMap<String, Weak<tokio::sync::RwLock<()>>>>,
     write_locks: Mutex<HashMap<WorkspaceFileKey, Weak<tokio::sync::Mutex<()>>>>,
     watches: Mutex<HashMap<String, Arc<CheckoutWatch>>>,
     cancel: CancellationToken,
@@ -242,6 +245,7 @@ impl WorkspaceFiles {
                 repos,
                 workspace,
                 device_id: device_id.into(),
+                mutation_gates: Mutex::new(HashMap::new()),
                 write_locks: Mutex::new(HashMap::new()),
                 watches: Mutex::new(HashMap::new()),
                 cancel: CancellationToken::new(),
@@ -392,7 +396,14 @@ impl WorkspaceFiles {
         .await
         .map_err(|error| WorkspaceFilesError::Io(format!("directory worker failed: {error}")))?;
         cancel_on_drop.disarm();
-        result
+        result.map(|mut page| {
+            page.checkout_id = Some(workspace.checkout_id);
+            page.mutation_capabilities = Some(zeron_proto::WorkspaceMutationCapabilities {
+                move_entry: cfg!(any(target_os = "linux", target_os = "macos", windows)),
+                delete_entry: true,
+            });
+            page
+        })
     }
 
     pub async fn search(
@@ -498,6 +509,15 @@ impl WorkspaceFiles {
                     .into(),
             ));
         }
+        let mutation_guard = self
+            .mutation_gate(&workspace.checkout_id)
+            .read_owned()
+            .await;
+        if self.resolve_target(&request.target).await? != workspace {
+            return Err(WorkspaceFilesError::Authorization(
+                "Workspace changed while waiting to save".into(),
+            ));
+        }
         let relative = WorkspaceRelativePath::file(&request.path)?;
         let key = WorkspaceFileKey {
             checkout_id: workspace.checkout_id.clone(),
@@ -519,6 +539,7 @@ impl WorkspaceFiles {
         let cancel_on_drop = CancelOnDrop::new(cancel.clone());
         let expected_hash = request.expected_content_hash;
         let result = tokio::task::spawn_blocking(move || {
+            let _mutation_guard = mutation_guard;
             let _write_guard = write_guard;
             write_file_blocking(&workspace.root, &relative, &expected_hash, &bytes, &cancel)
         })
@@ -883,6 +904,7 @@ fn normalize_watch_events(
                     changes.insert(
                         path.clone(),
                         WorkspaceFileChange {
+                            operation_id: None,
                             kind: WorkspaceFileChangeKind::Modified,
                             path,
                             old_path: None,
@@ -893,6 +915,7 @@ fn normalize_watch_events(
                 changes.insert(
                     path.clone(),
                     WorkspaceFileChange {
+                        operation_id: None,
                         kind: WorkspaceFileChangeKind::Renamed,
                         path,
                         old_path: Some(old_path),
@@ -919,6 +942,7 @@ fn normalize_watch_events(
                 continue;
             };
             let incoming = WorkspaceFileChange {
+                operation_id: None,
                 kind,
                 path: path.clone(),
                 old_path: None,
@@ -1091,6 +1115,8 @@ fn list_directory_blocking(
             .as_ref()
             .is_some_and(|visible| !visible.contains(&path));
         entries.push(WorkspaceEntry {
+            mutation_revision: (!mutations::is_link(&metadata))
+                .then(|| mutations::revision(&metadata)),
             name: entry.file_name().to_string_lossy().into_owned(),
             path,
             kind,
@@ -1144,6 +1170,8 @@ fn list_directory_blocking(
         })
     });
     Ok(WorkspaceDirectoryPage {
+        checkout_id: None,
+        mutation_capabilities: None,
         directory: directory.wire_path(),
         entries: page_entries,
         next_cursor,
@@ -1527,7 +1555,7 @@ fn checked_file_metadata(
                 WorkspaceFilesError::Io(error.to_string())
             }
         })?;
-        if metadata.file_type().is_symlink() {
+        if mutations::is_link(&metadata) {
             let message = if index + 1 == components.len() {
                 "path is a symlink"
             } else {
@@ -1986,6 +2014,8 @@ fn checked_directory(
     root: &Path,
     directory: &WorkspaceRelativePath,
 ) -> Result<PathBuf, WorkspaceFilesError> {
+    let canonical_root =
+        std::fs::canonicalize(root).map_err(|error| WorkspaceFilesError::Io(error.to_string()))?;
     let mut current = root.to_path_buf();
     for component in directory.as_path().components() {
         let Component::Normal(component) = component else {
@@ -1994,7 +2024,7 @@ fn checked_directory(
         current.push(component);
         let metadata = std::fs::symlink_metadata(&current)
             .map_err(|error| WorkspaceFilesError::Io(error.to_string()))?;
-        if metadata.file_type().is_symlink() {
+        if mutations::is_link(&metadata) {
             return Err(WorkspaceFilesError::Unsupported(
                 "symlink directories cannot be traversed".into(),
             ));
@@ -2007,7 +2037,7 @@ fn checked_directory(
     }
     let canonical = std::fs::canonicalize(&current)
         .map_err(|error| WorkspaceFilesError::Io(error.to_string()))?;
-    if !canonical.starts_with(root) {
+    if !canonical.starts_with(&canonical_root) {
         return Err(WorkspaceFilesError::Authorization(
             "directory escaped workspace".into(),
         ));
@@ -2145,6 +2175,26 @@ mod tests {
         AtomicBool::new(false)
     }
 
+    #[test]
+    fn checked_directory_accepts_the_workspace_root_and_its_child_after_canonicalization() {
+        let root = tempfile::tempdir().unwrap();
+        std::fs::create_dir(root.path().join("child")).unwrap();
+        let canonical_root = std::fs::canonicalize(root.path()).unwrap();
+
+        assert_eq!(
+            checked_directory(root.path(), &WorkspaceRelativePath::directory("").unwrap()).unwrap(),
+            canonical_root
+        );
+        assert_eq!(
+            checked_directory(
+                root.path(),
+                &WorkspaceRelativePath::directory("child").unwrap()
+            )
+            .unwrap(),
+            canonical_root.join("child")
+        );
+    }
+
     #[test]
     fn relative_paths_preserve_normal_and_unicode_components() {
         let path = WorkspaceRelativePath::file("src/日本語/emoji-🛰️.rs").unwrap();
diff --git a/crates/engine/src/workspace_files/mutations.rs b/crates/engine/src/workspace_files/mutations.rs
new file mode 100644
index 0000000000..6b3174fc7d
--- /dev/null
+++ b/crates/engine/src/workspace_files/mutations.rs
@@ -0,0 +1,735 @@
+//! Structural mutations execute on the workspace host, serialized against saves.
+use super::*;
+use zeron_proto::{
+    MoveWorkspaceEntryRequest, WorkspaceMutationOutcome, WorkspaceMutationRejection as Reason,
+};
+
+type MutationResult<T> = Result<T, (Reason, String)>;
+
+impl WorkspaceFiles {
+    pub async fn delete_entry(
+        &self,
+        request: zeron_proto::DeleteWorkspaceEntryRequest,
+    ) -> Result<WorkspaceMutationOutcome, WorkspaceFilesError> {
+        let workspace = self.resolve_target(&request.target).await?;
+        let gate = self
+            .mutation_gate(&workspace.checkout_id)
+            .write_owned()
+            .await;
+        if request.expected_checkout_id.is_empty()
+            || self.resolve_target(&request.target).await? != workspace
+            || request.expected_checkout_id != workspace.checkout_id
+        {
+            return Ok(rejected(
+                request.operation_id,
+                Reason::WorkspaceChanged,
+                "Workspace changed; refresh before deleting",
+            ));
+        }
+        let cancel = Arc::new(AtomicBool::new(false));
+        let cancel_on_drop = CancelOnDrop::new(cancel.clone());
+        let owner = self.clone();
+        let result = tokio::task::spawn_blocking(move || {
+            let _gate = gate;
+            let result = match delete_blocking(&workspace, &request, &cancel) {
+                Ok(()) => WorkspaceMutationOutcome::Applied {
+                    operation_id: request.operation_id.clone(),
+                    checkout_id: workspace.checkout_id.clone(),
+                    change: WorkspaceFileChange {
+                        operation_id: Some(request.operation_id),
+                        kind: WorkspaceFileChangeKind::Removed,
+                        path: request.path,
+                        old_path: None,
+                    },
+                    entry: None,
+                },
+                Err((reason, message)) => rejected(request.operation_id, reason, &message),
+            };
+            owner.publish_mutation(&workspace.checkout_id, &result);
+            result
+        })
+        .await
+        .map_err(|e| WorkspaceFilesError::Io(format!("delete worker failed: {e}")))?;
+        cancel_on_drop.disarm();
+        Ok(result)
+    }
+
+    fn publish_mutation(&self, checkout: &str, result: &WorkspaceMutationOutcome) {
+        if let Some(watch) = lock(&self.inner.watches).get(checkout).cloned() {
+            match result {
+                WorkspaceMutationOutcome::Applied { change, .. } => {
+                    watch.publish(false, vec![change.clone()])
+                }
+                WorkspaceMutationOutcome::Rejected {
+                    reason: Reason::PartialFailure,
+                    ..
+                } => watch.publish(true, vec![]),
+                _ => {}
+            }
+        }
+    }
+
+    pub(super) fn mutation_gate(&self, checkout: &str) -> Arc<tokio::sync::RwLock<()>> {
+        let mut gates = lock(&self.inner.mutation_gates);
+        gates.retain(|_, gate| gate.strong_count() > 0);
+        if let Some(gate) = gates.get(checkout).and_then(Weak::upgrade) {
+            return gate;
+        }
+        let gate = Arc::new(tokio::sync::RwLock::new(()));
+        gates.insert(checkout.into(), Arc::downgrade(&gate));
+        gate
+    }
+
+    pub async fn move_entry(
+        &self,
+        request: MoveWorkspaceEntryRequest,
+    ) -> Result<WorkspaceMutationOutcome, WorkspaceFilesError> {
+        let workspace = self.resolve_target(&request.target).await?;
+        let gate = self
+            .mutation_gate(&workspace.checkout_id)
+            .write_owned()
+            .await;
+        let current = self.resolve_target(&request.target).await?;
+        if request.expected_checkout_id.is_empty()
+            || current != workspace
+            || request.expected_checkout_id != workspace.checkout_id
+        {
+            return Ok(rejected(
+                request.operation_id,
+                Reason::WorkspaceChanged,
+                "Workspace changed; refresh before moving",
+            ));
+        }
+        let cancel = Arc::new(AtomicBool::new(false));
+        let cancel_on_drop = CancelOnDrop::new(cancel.clone());
+        let owner = self.clone();
+        let result = tokio::task::spawn_blocking(move || {
+            let _gate = gate;
+            let result = match move_blocking(&workspace, &request, &cancel) {
+                Ok(entry) => WorkspaceMutationOutcome::Applied {
+                    operation_id: request.operation_id.clone(),
+                    checkout_id: workspace.checkout_id.clone(),
+                    change: WorkspaceFileChange {
+                        operation_id: Some(request.operation_id),
+                        kind: WorkspaceFileChangeKind::Renamed,
+                        path: entry.path.clone(),
+                        old_path: Some(request.source_path),
+                    },
+                    entry: Some(entry),
+                },
+                Err((reason, message)) => rejected(request.operation_id, reason, &message),
+            };
+            owner.publish_mutation(&workspace.checkout_id, &result);
+            result
+        })
+        .await
+        .map_err(|e| WorkspaceFilesError::Io(format!("move worker failed: {e}")))?;
+        cancel_on_drop.disarm();
+        Ok(result)
+    }
+}
+
+fn delete_blocking(
+    workspace: &ResolvedWorkspace,
+    request: &zeron_proto::DeleteWorkspaceEntryRequest,
+    cancel: &AtomicBool,
+) -> MutationResult<()> {
+    if request.operation_id.is_empty() || request.operation_id.len() > 128 {
+        return Err((Reason::InvalidPath, "Invalid operation identity".into()));
+    }
+    let (relative, metadata) = source(
+        &workspace.root,
+        &request.path,
+        &request.expected_source_revision,
+        request.expected_kind,
+    )?;
+    if metadata.is_dir() && !request.recursive {
+        return Err((
+            Reason::InvalidDestination,
+            "Deleting a folder requires recursive confirmation".into(),
+        ));
+    }
+    if cancel.load(Ordering::Acquire) {
+        return Err((Reason::Busy, "Delete cancelled before execution".into()));
+    }
+    let target = workspace.root.join(relative.as_path());
+    if metadata.is_dir() {
+        // std::fs::remove_dir_all does not follow symbolic links and uses platform
+        // handle-relative traversal. A failed recursive delete may have removed children.
+        std::fs::remove_dir_all(target).map_err(|e| {
+            (
+                Reason::PartialFailure,
+                format!("Folder deletion did not complete; refresh to see remaining files: {e}"),
+            )
+        })
+    } else {
+        std::fs::remove_file(target).map_err(io_error)
+    }
+}
+
+fn rejected(operation_id: String, reason: Reason, message: &str) -> WorkspaceMutationOutcome {
+    WorkspaceMutationOutcome::Rejected {
+        operation_id,
+        reason,
+        message: message.into(),
+    }
+}
+
+fn domain_error(error: WorkspaceFilesError) -> (Reason, String) {
+    let reason = match &error {
+        WorkspaceFilesError::BadParams(_) => Reason::InvalidPath,
+        WorkspaceFilesError::Authorization(_) => Reason::WorkspaceChanged,
+        WorkspaceFilesError::NotFound(_) => Reason::SourceMissing,
+        WorkspaceFilesError::Unsupported(_) => Reason::Unsupported,
+        WorkspaceFilesError::Io(_) => Reason::InvalidDestination,
+    };
+    (reason, error.to_string())
+}
+
+fn io_error(error: std::io::Error) -> (Reason, String) {
+    use std::io::ErrorKind;
+    (
+        match error.kind() {
+            ErrorKind::AlreadyExists => Reason::DestinationExists,
+            ErrorKind::NotFound => Reason::SourceMissing,
+            ErrorKind::PermissionDenied => Reason::PermissionDenied,
+            ErrorKind::Unsupported | ErrorKind::CrossesDevices => Reason::Unsupported,
+            _ => Reason::InvalidDestination,
+        },
+        error.to_string(),
+    )
+}
+
+/// Metadata revision is deliberately cheap; directory revisions are not recursive snapshots.
+pub(super) fn revision(metadata: &std::fs::Metadata) -> String {
+    let mut hash = Sha256::new();
+    hash.update(format!(
+        "{:?}:{:?}:{:?}:{}:{}",
+        metadata.file_type(),
+        metadata.modified().ok(),
+        metadata.created().ok(),
+        metadata.len(),
+        metadata.permissions().readonly()
+    ));
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        hash.update(format!(
+            ":{}:{}:{}:{}",
+            metadata.dev(),
+            metadata.ino(),
+            metadata.ctime(),
+            metadata.ctime_nsec()
+        ));
+    }
+    hex(&hash.finalize())
+}
+
+pub(super) fn is_link(metadata: &std::fs::Metadata) -> bool {
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::MetadataExt;
+        return metadata.file_attributes() & 0x400 != 0; // FILE_ATTRIBUTE_REPARSE_POINT, includes junctions.
+    }
+    #[cfg(not(windows))]
+    {
+        metadata.file_type().is_symlink()
+    }
+}
+
+fn source(
+    root: &Path,
+    path: &str,
+    expected: &str,
+    kind: WorkspaceEntryKind,
+) -> MutationResult<(WorkspaceRelativePath, std::fs::Metadata)> {
+    let relative = WorkspaceRelativePath::file(path).map_err(domain_error)?;
+    // Require canonical wire spelling so identity/deduplication is unambiguous.
+    if relative.wire_path() != path {
+        return Err((
+            Reason::InvalidPath,
+            "Path must use canonical workspace-relative spelling".into(),
+        ));
+    }
+    let parent = WorkspaceRelativePath(relative.as_path().parent().unwrap_or(Path::new("")).into());
+    checked_directory(root, &parent).map_err(domain_error)?;
+    let metadata = std::fs::symlink_metadata(root.join(relative.as_path())).map_err(io_error)?;
+    if is_link(&metadata) || !(metadata.is_file() || metadata.is_dir()) {
+        return Err((
+            Reason::Unsupported,
+            "Links and special files cannot be mutated".into(),
+        ));
+    }
+    let actual_kind = if metadata.is_dir() {
+        WorkspaceEntryKind::Directory
+    } else {
+        WorkspaceEntryKind::File
+    };
+    if actual_kind != kind || expected.is_empty() || revision(&metadata) != expected {
+        return Err((
+            Reason::SourceChanged,
+            "Entry changed; refresh before trying again".into(),
+        ));
+    }
+    Ok((relative, metadata))
+}
+
+fn move_blocking(
+    workspace: &ResolvedWorkspace,
+    request: &MoveWorkspaceEntryRequest,
+    cancel: &AtomicBool,
+) -> MutationResult<WorkspaceEntry> {
+    if request.operation_id.is_empty() || request.operation_id.len() > 128 {
+        return Err((Reason::InvalidPath, "Invalid operation identity".into()));
+    }
+    let (source, metadata) = source(
+        &workspace.root,
+        &request.source_path,
+        &request.expected_source_revision,
+        request.expected_kind,
+    )?;
+    let destination =
+        WorkspaceRelativePath::file(&request.destination_path).map_err(domain_error)?;
+    if destination.wire_path() != request.destination_path {
+        return Err((Reason::InvalidPath, "Invalid destination spelling".into()));
+    }
+    if destination == source
+        || (metadata.is_dir() && destination.as_path().starts_with(source.as_path()))
+    {
+        return Err((
+            Reason::InvalidDestination,
+            "Cannot move an entry into itself".into(),
+        ));
+    }
+    let parent = WorkspaceRelativePath(
+        destination
+            .as_path()
+            .parent()
+            .unwrap_or(Path::new(""))
+            .into(),
+    );
+    checked_directory(&workspace.root, &parent).map_err(domain_error)?;
+    if cancel.load(Ordering::Acquire) {
+        return Err((Reason::Busy, "Move cancelled before execution".into()));
+    }
+    move_entry_no_replace(&workspace.root, source.as_path(), destination.as_path())?;
+    let target = workspace.root.join(destination.as_path());
+    let updated = std::fs::symlink_metadata(&target).unwrap_or(metadata);
+    Ok(WorkspaceEntry {
+        path: destination.wire_path(),
+        name: target.file_name().unwrap().to_string_lossy().into_owned(),
+        kind: request.expected_kind,
+        size: updated.is_file().then_some(updated.len()),
+        modified_at: updated.modified().ok().map(chrono::DateTime::from),
+        ignored: false,
+        read_only: !updated.is_file(),
+        mutation_revision: Some(revision(&updated)),
+    })
+}
+
+/// Case-insensitive filesystems may reject even a spelling-only rename under
+/// NOREPLACE. Stage that single directory entry, never a second hard link.
+fn move_entry_no_replace(root: &Path, source: &Path, destination: &Path) -> MutationResult<()> {
+    match move_no_replace(root, source, destination) {
+        Ok(()) => Ok(()),
+        Err(error) => {
+            #[cfg(unix)]
+            if error.kind() == std::io::ErrorKind::AlreadyExists
+                && is_case_alias(root, source, destination)
+            {
+                let temporary = source
+                    .parent()
+                    .unwrap_or(Path::new(""))
+                    .join(format!(".zeron-save-{}.tmp", uuid::Uuid::new_v4()));
+                move_no_replace(root, source, &temporary).map_err(io_error)?;
+                if let Err(error) = move_no_replace(root, &temporary, destination) {
+                    if let Err(rollback) = move_no_replace(root, &temporary, source) {
+                        return Err((
+                            Reason::PartialFailure,
+                            format!(
+                                "Rename could not complete ({error}) or restore its original name ({rollback}); recover the entry at {}",
+                                temporary.display()
+                            ),
+                        ));
+                    }
+                    return Err(io_error(error));
+                }
+                return Ok(());
+            }
+            Err(io_error(error))
+        }
+    }
+}
+
+#[cfg(unix)]
+fn is_case_alias(root: &Path, source: &Path, destination: &Path) -> bool {
+    use std::os::unix::fs::MetadataExt;
+    if source.parent() != destination.parent() {
+        return false;
+    }
+    let (Some(from), Some(to)) = (source.file_name(), destination.file_name()) else {
+        return false;
+    };
+    if from == to || from.to_string_lossy().to_lowercase() != to.to_string_lossy().to_lowercase() {
+        return false;
+    }
+    let (Ok(a), Ok(b)) = (
+        std::fs::symlink_metadata(root.join(source)),
+        std::fs::symlink_metadata(root.join(destination)),
+    ) else {
+        return false;
+    };
+    if a.dev() != b.dev() || a.ino() != b.ino() || is_link(&a) || is_link(&b) {
+        return false;
+    }
+    // Distinct hard-link names are a real collision, not an alias in a
+    // case-insensitive directory. A failed enumeration never authorizes a move.
+    let Ok(entries) = std::fs::read_dir(root.join(source.parent().unwrap_or(Path::new("")))) else {
+        return false;
+    };
+    for entry in entries {
+        match entry {
+            Ok(entry) if entry.file_name() == to => return false,
+            Err(_) => return false,
+            _ => {}
+        }
+    }
+    true
+}
+
+/// Open every ancestor without following links, and anchor the native rename to those handles.
+#[cfg(unix)]
+fn open_parent(root: &Path, relative: &Path) -> std::io::Result<std::fs::File> {
+    use std::os::unix::fs::OpenOptionsExt;
+    use std::os::{
+        fd::{AsRawFd, FromRawFd},
+        unix::ffi::OsStrExt,
+    };
+    let mut directory = std::fs::OpenOptions::new()
+        .read(true)
+        .custom_flags(libc::O_DIRECTORY | libc::O_NOFOLLOW)
+        .open(root)?;
+    for component in relative.parent().unwrap_or(Path::new("")).components() {
+        let Component::Normal(name) = component else {
+            return Err(std::io::ErrorKind::InvalidInput.into());
+        };
+        let name = std::ffi::CString::new(name.as_bytes())?;
+        // SAFETY: a valid directory descriptor and NUL-terminated single path component.
+        let fd = unsafe {
+            libc::openat(
+                directory.as_raw_fd(),
+                name.as_ptr(),
+                libc::O_RDONLY | libc::O_DIRECTORY | libc::O_NOFOLLOW | libc::O_CLOEXEC,
+            )
+        };
+        if fd < 0 {
+            return Err(std::io::Error::last_os_error());
+        }
+        // SAFETY: openat returned a newly owned descriptor.
+        directory = unsafe { std::fs::File::from_raw_fd(fd) };
+    }
+    Ok(directory)
+}
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+fn move_no_replace(root: &Path, source: &Path, destination: &Path) -> std::io::Result<()> {
+    use std::os::{fd::AsRawFd, unix::ffi::OsStrExt};
+    let from = open_parent(root, source)?;
+    let to = open_parent(root, destination)?;
+    let source = std::ffi::CString::new(
+        source
+            .file_name()
+            .ok_or(std::io::ErrorKind::InvalidInput)?
+            .as_bytes(),
+    )?;
+    let destination = std::ffi::CString::new(
+        destination
+            .file_name()
+            .ok_or(std::io::ErrorKind::InvalidInput)?
+            .as_bytes(),
+    )?;
+    // SAFETY: live parent handles and NUL-terminated basename buffers; replacement is disabled.
+    #[cfg(target_os = "linux")]
+    let result = unsafe {
+        libc::renameat2(
+            from.as_raw_fd(),
+            source.as_ptr(),
+            to.as_raw_fd(),
+            destination.as_ptr(),
+            libc::RENAME_NOREPLACE,
+        )
+    };
+    #[cfg(target_os = "macos")]
+    let result = unsafe {
+        libc::renameatx_np(
+            from.as_raw_fd(),
+            source.as_ptr(),
+            to.as_raw_fd(),
+            destination.as_ptr(),
+            libc::RENAME_EXCL,
+        )
+    };
+    if result == 0 {
+        Ok(())
+    } else {
+        Err(std::io::Error::last_os_error())
+    }
+}
+
+#[cfg(windows)]
+fn move_no_replace(root: &Path, source: &Path, destination: &Path) -> std::io::Result<()> {
+    use std::os::windows::ffi::OsStrExt;
+    use windows_sys::Win32::Storage::FileSystem::{MOVEFILE_WRITE_THROUGH, MoveFileExW};
+    let from: Vec<u16> = root
+        .join(source)
+        .as_os_str()
+        .encode_wide()
+        .chain(Some(0))
+        .collect();
+    let to: Vec<u16> = root
+        .join(destination)
+        .as_os_str()
+        .encode_wide()
+        .chain(Some(0))
+        .collect();
+    // SAFETY: NUL-terminated paths; neither REPLACE_EXISTING nor COPY_ALLOWED is enabled.
+    if unsafe { MoveFileExW(from.as_ptr(), to.as_ptr(), MOVEFILE_WRITE_THROUGH) } == 0 {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
+fn move_no_replace(_: &Path, _: &Path, _: &Path) -> std::io::Result<()> {
+    Err(std::io::ErrorKind::Unsupported.into())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn request(root: &Path, path: &str, to: &str) -> MoveWorkspaceEntryRequest {
+        let metadata = std::fs::symlink_metadata(root.join(path)).unwrap();
+        MoveWorkspaceEntryRequest {
+            target: WorkspaceTarget {
+                chat_id: Some("chat".into()),
+                space_id: None,
+                checkout_path: None,
+            },
+            operation_id: "op".into(),
+            expected_checkout_id: "checkout".into(),
+            source_path: path.into(),
+            destination_path: to.into(),
+            expected_source_revision: revision(&metadata),
+            expected_kind: if metadata.is_dir() {
+                WorkspaceEntryKind::Directory
+            } else {
+                WorkspaceEntryKind::File
+            },
+        }
+    }
+    #[test]
+    fn simultaneous_moves_never_replace_the_winner() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        std::fs::write(root.join("one"), "one").unwrap();
+        std::fs::write(root.join("two"), "two").unwrap();
+        let barrier = Arc::new(std::sync::Barrier::new(2));
+        let results = std::thread::scope(|scope| {
+            let a = barrier.clone();
+            let first = scope.spawn(move || {
+                a.wait();
+                move_entry_no_replace(root, Path::new("one"), Path::new("winner"))
+            });
+            let b = barrier.clone();
+            let second = scope.spawn(move || {
+                b.wait();
+                move_entry_no_replace(root, Path::new("two"), Path::new("winner"))
+            });
+            (first.join().unwrap(), second.join().unwrap())
+        });
+        assert_ne!(results.0.is_ok(), results.1.is_ok());
+        let winner = std::fs::read_to_string(root.join("winner")).unwrap();
+        let loser = if winner == "one" { "two" } else { "one" };
+        assert_eq!(std::fs::read_to_string(root.join(loser)).unwrap(), loser);
+    }
+    #[test]
+    fn case_only_rename_preserves_contents() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("File.txt"), "keep").unwrap();
+        move_entry_no_replace(dir.path(), Path::new("File.txt"), Path::new("file.txt")).unwrap();
+        assert_eq!(
+            std::fs::read_to_string(dir.path().join("file.txt")).unwrap(),
+            "keep"
+        );
+        let names = std::fs::read_dir(dir.path())
+            .unwrap()
+            .map(|entry| entry.unwrap().file_name())
+            .collect::<Vec<_>>();
+        assert_eq!(names, vec![std::ffi::OsString::from("file.txt")]);
+    }
+    #[cfg(unix)]
+    #[test]
+    fn case_similar_hard_links_are_still_collisions() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("A"), "keep").unwrap();
+        // Only filesystems supporting distinct case names can create this fixture.
+        if std::fs::hard_link(dir.path().join("A"), dir.path().join("a")).is_err() {
+            return;
+        }
+        assert_eq!(
+            move_entry_no_replace(dir.path(), Path::new("A"), Path::new("a"))
+                .unwrap_err()
+                .0,
+            Reason::DestinationExists
+        );
+    }
+    #[test]
+    fn delete_requires_current_revision_and_explicit_recursion() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        std::fs::create_dir(root.join("folder")).unwrap();
+        std::fs::write(root.join("folder/file"), "keep").unwrap();
+        let ws = ResolvedWorkspace {
+            checkout_id: "checkout".into(),
+            root: root.into(),
+        };
+        let mut req = zeron_proto::DeleteWorkspaceEntryRequest {
+            target: request(root, "folder", "unused").target,
+            operation_id: "delete".into(),
+            expected_checkout_id: "checkout".into(),
+            path: "folder".into(),
+            expected_source_revision: revision(&std::fs::metadata(root.join("folder")).unwrap()),
+            expected_kind: WorkspaceEntryKind::Directory,
+            recursive: false,
+        };
+        assert!(delete_blocking(&ws, &req, &AtomicBool::new(false)).is_err());
+        assert!(root.join("folder/file").exists());
+        req.recursive = true;
+        delete_blocking(&ws, &req, &AtomicBool::new(false)).unwrap();
+        assert!(!root.join("folder").exists());
+        assert_eq!(
+            delete_blocking(&ws, &req, &AtomicBool::new(false))
+                .unwrap_err()
+                .0,
+            Reason::SourceMissing
+        );
+    }
+    #[cfg(unix)]
+    #[test]
+    fn deleting_directory_does_not_follow_links_to_external_contents() {
+        let dir = tempfile::tempdir().unwrap();
+        let outside = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("folder")).unwrap();
+        std::fs::write(outside.path().join("keep"), "keep").unwrap();
+        std::os::unix::fs::symlink(outside.path(), dir.path().join("folder/link")).unwrap();
+        let ws = ResolvedWorkspace {
+            checkout_id: "checkout".into(),
+            root: dir.path().into(),
+        };
+        let req = zeron_proto::DeleteWorkspaceEntryRequest {
+            target: request(dir.path(), "folder", "unused").target,
+            operation_id: "delete".into(),
+            expected_checkout_id: "checkout".into(),
+            path: "folder".into(),
+            expected_source_revision: revision(
+                &std::fs::metadata(dir.path().join("folder")).unwrap(),
+            ),
+            expected_kind: WorkspaceEntryKind::Directory,
+            recursive: true,
+        };
+        delete_blocking(&ws, &req, &AtomicBool::new(false)).unwrap();
+        assert_eq!(
+            std::fs::read_to_string(outside.path().join("keep")).unwrap(),
+            "keep"
+        );
+    }
+
+    #[test]
+    fn moves_subtrees_without_replacement_or_prefix_confusion() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        std::fs::create_dir_all(root.join("a/child")).unwrap();
+        std::fs::create_dir(root.join("ab")).unwrap();
+        std::fs::write(root.join("a/child/á.txt"), "keep").unwrap();
+        let workspace = ResolvedWorkspace {
+            checkout_id: "checkout".into(),
+            root: root.into(),
+        };
+        let cancel = AtomicBool::new(false);
+        assert_eq!(
+            move_blocking(&workspace, &request(root, "a", "a/child/new"), &cancel)
+                .unwrap_err()
+                .0,
+            Reason::InvalidDestination
+        );
+        assert_eq!(
+            move_blocking(&workspace, &request(root, "a", "ab"), &cancel)
+                .unwrap_err()
+                .0,
+            Reason::DestinationExists
+        );
+        move_blocking(&workspace, &request(root, "a", "ab/a"), &cancel).unwrap();
+        assert_eq!(
+            std::fs::read_to_string(root.join("ab/a/child/á.txt")).unwrap(),
+            "keep"
+        );
+    }
+    #[test]
+    fn stale_sources_invalid_paths_and_cancel_do_not_mutate() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        std::fs::write(root.join("a"), "old").unwrap();
+        let workspace = ResolvedWorkspace {
+            checkout_id: "checkout".into(),
+            root: root.into(),
+        };
+        let req = request(root, "a", "b");
+        std::fs::write(root.join("a"), "changed").unwrap();
+        assert_eq!(
+            move_blocking(&workspace, &req, &AtomicBool::new(false))
+                .unwrap_err()
+                .0,
+            Reason::SourceChanged
+        );
+        for to in ["../b", ".git/file", "", "/tmp/outside"] {
+            assert!(
+                move_blocking(&workspace, &request(root, "a", to), &AtomicBool::new(false))
+                    .is_err()
+            );
+        }
+        assert_eq!(
+            move_blocking(&workspace, &request(root, "a", "b"), &AtomicBool::new(true))
+                .unwrap_err()
+                .0,
+            Reason::Busy
+        );
+        assert!(root.join("a").exists());
+        assert!(!root.join("b").exists());
+    }
+    #[cfg(unix)]
+    #[test]
+    fn links_cannot_be_overwritten_or_traversed() {
+        let dir = tempfile::tempdir().unwrap();
+        let outside = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        std::fs::write(root.join("a"), "keep").unwrap();
+        std::os::unix::fs::symlink(outside.path().join("missing"), root.join("b")).unwrap();
+        std::os::unix::fs::symlink(outside.path(), root.join("link")).unwrap();
+        let ws = ResolvedWorkspace {
+            checkout_id: "checkout".into(),
+            root: root.into(),
+        };
+        assert_eq!(
+            move_blocking(&ws, &request(root, "a", "b"), &AtomicBool::new(false))
+                .unwrap_err()
+                .0,
+            Reason::DestinationExists
+        );
+        assert!(
+            move_blocking(&ws, &request(root, "a", "link/a"), &AtomicBool::new(false)).is_err()
+        );
+        assert!(root.join("a").exists());
+        assert!(!outside.path().join("a").exists());
+    }
+}
diff --git a/crates/engine/tests/device_routing.rs b/crates/engine/tests/device_routing.rs
index 40d8457908..eb232df2c2 100644
--- a/crates/engine/tests/device_routing.rs
+++ b/crates/engine/tests/device_routing.rs
@@ -1843,3 +1843,56 @@ async fn queue_watch_and_single_consumption_route_to_the_remote_chat_host() {
     core_a.shutdown().await;
     core_b.shutdown().await;
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn workspace_entry_mutations_are_forwarded_to_the_owning_plain_folder() {
+    let (relay_url, _relay) = fake_device_room().await;
+    let dirs = tempfile::tempdir().unwrap();
+    let host = assemble(&dirs.path().join("host"), "mutation-host");
+    let _host_relay = host.start_host_relay(&relay_url);
+    let viewer = assemble(&dirs.path().join("viewer"), "mutation-viewer");
+    let mut config = LinkCacheConfig::new(relay_url, Arc::new(StaticToken("test-user".into())));
+    config.probe_timeout = Duration::from_secs(5);
+    viewer.set_links(LinkCache::new(config));
+    let folder = dirs.path().join("plain-folder");
+    std::fs::create_dir(&folder).unwrap();
+    std::fs::write(folder.join("original.txt"), "host only").unwrap();
+    host.workspace
+        .create_space(
+            "mutation-space",
+            "mutation-host",
+            &folder.to_string_lossy(),
+            None,
+            false,
+        )
+        .unwrap();
+    let client = zeron_rpc::memory_client(viewer.rpc_service());
+    let page = client
+        .call(
+            methods::LIST_WORKSPACE_DIRECTORY,
+            serde_json::json!({"spaceId":"mutation-space","targetDeviceId":"mutation-host"}),
+        )
+        .await
+        .unwrap();
+    let entry = &page["entries"][0];
+    assert!(page["checkoutId"].as_str().unwrap().starts_with("folder-"));
+    let moved=client.call(methods::MOVE_WORKSPACE_ENTRY,serde_json::json!({
+        "spaceId":"mutation-space","targetDeviceId":"mutation-host","operationId":"remote-move",
+        "expectedCheckoutId":page["checkoutId"],"sourcePath":"original.txt","destinationPath":"renamed.txt",
+        "expectedSourceRevision":entry["mutationRevision"],"expectedKind":"file"
+    })).await.unwrap();
+    assert_eq!(moved["status"], "applied");
+    assert_eq!(
+        std::fs::read_to_string(folder.join("renamed.txt")).unwrap(),
+        "host only"
+    );
+    let deleted=client.call(methods::DELETE_WORKSPACE_ENTRY,serde_json::json!({
+        "spaceId":"mutation-space","targetDeviceId":"mutation-host","operationId":"remote-delete",
+        "expectedCheckoutId":page["checkoutId"],"path":"renamed.txt",
+        "expectedSourceRevision":moved["entry"]["mutationRevision"],"expectedKind":"file","recursive":false
+    })).await.unwrap();
+    assert_eq!(deleted["status"], "applied");
+    assert!(!folder.join("renamed.txt").exists());
+    viewer.shutdown().await;
+    host.shutdown().await;
+}
diff --git a/crates/engine/tests/workspace_files.rs b/crates/engine/tests/workspace_files.rs
index cc6ad8c9a1..9b5bb42c33 100644
--- a/crates/engine/tests/workspace_files.rs
+++ b/crates/engine/tests/workspace_files.rs
@@ -657,6 +657,90 @@ async fn write_rejects_changed_checkout_even_when_contents_match() {
     );
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn workspace_mutations_validate_revision_and_publish_semantic_events() {
+    let temp = tempfile::tempdir().unwrap();
+    let repo = temp.path().join("repo");
+    init_repo(&repo).await;
+    let core = assemble(&temp.path().join("data"), "device-mutations");
+    core.workspace
+        .create_space(
+            "space",
+            &core.device_id,
+            &repo.to_string_lossy(),
+            None,
+            true,
+        )
+        .unwrap();
+    core.workspace
+        .create_chat("chat", Some("space"), None, None, None)
+        .unwrap();
+    let client = zeron_rpc::memory_client(core.rpc_service());
+    let page: WorkspaceDirectoryPage = serde_json::from_value(
+        client
+            .call(
+                methods::LIST_WORKSPACE_DIRECTORY,
+                serde_json::json!({"chatId":"chat"}),
+            )
+            .await
+            .unwrap(),
+    )
+    .unwrap();
+    assert!(page.mutation_capabilities.unwrap().delete_entry);
+    let revision = page
+        .entries
+        .iter()
+        .find(|e| e.path == "README.md")
+        .unwrap()
+        .mutation_revision
+        .clone()
+        .unwrap();
+    let checkout = page.checkout_id.unwrap();
+    let mut watch = client
+        .subscribe(
+            methods::WATCH_WORKSPACE_FILES,
+            serde_json::json!({"chatId":"chat"}),
+        )
+        .await
+        .unwrap();
+    watch.recv().await.unwrap();
+    let mut request = serde_json::json!({"chatId":"chat", "operationId":"rename", "expectedCheckoutId":checkout, "sourcePath":"README.md", "destinationPath":"src/read me.md", "expectedSourceRevision":revision, "expectedKind":"file"});
+    request["expectedCheckoutId"] = "wrong".into();
+    let rejected = client
+        .call(methods::MOVE_WORKSPACE_ENTRY, request.clone())
+        .await
+        .unwrap();
+    assert_eq!(rejected["reason"], "workspaceChanged");
+    request["expectedCheckoutId"] = checkout.clone().into();
+    let moved = client
+        .call(methods::MOVE_WORKSPACE_ENTRY, request)
+        .await
+        .unwrap();
+    assert_eq!(moved["status"], "applied");
+    assert!(!repo.join("README.md").exists());
+    assert_eq!(
+        std::fs::read_to_string(repo.join("src/read me.md")).unwrap(),
+        "hello\n"
+    );
+    tokio::time::timeout(Duration::from_secs(3), async {
+        loop {
+            let frame: WorkspaceFileChanges =
+                serde_json::from_value(watch.recv().await.unwrap()).unwrap();
+            if frame.changes.iter().any(|c| {
+                c.operation_id.as_deref() == Some("rename")
+                    && c.old_path.as_deref() == Some("README.md")
+            }) {
+                break;
+            }
+        }
+    })
+    .await
+    .unwrap();
+    let deleted = client.call(methods::DELETE_WORKSPACE_ENTRY, serde_json::json!({"chatId":"chat", "operationId":"delete", "expectedCheckoutId":checkout, "path":"src/read me.md", "expectedSourceRevision":moved["entry"]["mutationRevision"], "expectedKind":"file", "recursive":false})).await.unwrap();
+    assert_eq!(deleted["status"], "applied");
+    assert!(!repo.join("src/read me.md").exists());
+}
+
 // Absolute reads take POSIX paths — the only shape a UI sends.
 #[cfg(unix)]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
diff --git a/crates/proto/src/entities.rs b/crates/proto/src/entities.rs
index b2b3b7cfe3..9946cb8501 100644
--- a/crates/proto/src/entities.rs
+++ b/crates/proto/src/entities.rs
@@ -480,6 +480,10 @@ pub struct ListWorkspaceDirectoryRequest {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WorkspaceDirectoryPage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub checkout_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mutation_capabilities: Option<WorkspaceMutationCapabilities>,
     pub directory: String,
     pub entries: Vec<WorkspaceEntry>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -490,6 +494,8 @@ pub struct WorkspaceDirectoryPage {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WorkspaceEntry {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mutation_revision: Option<String>,
     pub path: String,
     pub name: String,
     pub kind: WorkspaceEntryKind,
@@ -700,6 +706,8 @@ pub struct WorkspaceFileChanges {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WorkspaceFileChange {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operation_id: Option<String>,
     pub kind: WorkspaceFileChangeKind,
     pub path: String,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -1399,6 +1407,7 @@ mod tests {
             sequence: 4,
             resync_required: false,
             changes: vec![WorkspaceFileChange {
+                operation_id: None,
                 kind: WorkspaceFileChangeKind::Renamed,
                 path: "src/new.rs".into(),
                 old_path: Some("src/old.rs".into()),
@@ -1414,3 +1423,126 @@ mod tests {
         );
     }
 }
+
+/// Host capabilities; absent fields keep older peers read-only for mutations.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkspaceMutationCapabilities {
+    #[serde(default)]
+    pub move_entry: bool,
+    #[serde(default)]
+    pub delete_entry: bool,
+}
+
+/// Rename and move share the same no-replacement operation.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MoveWorkspaceEntryRequest {
+    #[serde(flatten)]
+    pub target: WorkspaceTarget,
+    pub operation_id: String,
+    pub expected_checkout_id: String,
+    pub source_path: String,
+    pub destination_path: String,
+    pub expected_source_revision: String,
+    pub expected_kind: WorkspaceEntryKind,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DeleteWorkspaceEntryRequest {
+    #[serde(flatten)]
+    pub target: WorkspaceTarget,
+    pub operation_id: String,
+    pub expected_checkout_id: String,
+    pub path: String,
+    pub expected_source_revision: String,
+    pub expected_kind: WorkspaceEntryKind,
+    /// Explicit consent to delete the directory's current contents.
+    pub recursive: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "status", rename_all = "camelCase")]
+pub enum WorkspaceMutationOutcome {
+    #[serde(rename_all = "camelCase")]
+    Applied {
+        operation_id: String,
+        checkout_id: String,
+        change: WorkspaceFileChange,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        entry: Option<WorkspaceEntry>,
+    },
+    #[serde(rename_all = "camelCase")]
+    Rejected {
+        operation_id: String,
+        reason: WorkspaceMutationRejection,
+        message: String,
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum WorkspaceMutationRejection {
+    InvalidPath,
+    WorkspaceChanged,
+    SourceMissing,
+    SourceChanged,
+    DestinationExists,
+    InvalidDestination,
+    PermissionDenied,
+    Unsupported,
+    Busy,
+    PartialFailure,
+}
+
+#[cfg(test)]
+mod mutation_contract_tests {
+    use super::*;
+    #[test]
+    fn old_peers_remain_readable_without_mutation_support() {
+        let page: WorkspaceDirectoryPage = serde_json::from_value(serde_json::json!({
+            "directory":"", "entries":[{"path":"a", "name":"a", "kind":"file", "ignored":false, "readOnly":false}],
+            "truncated":false
+        })).unwrap();
+        assert_eq!(page.checkout_id, None);
+        assert_eq!(page.mutation_capabilities, None);
+        assert_eq!(page.entries[0].mutation_revision, None);
+        let change: WorkspaceFileChange =
+            serde_json::from_value(serde_json::json!({"kind":"removed", "path":"a"})).unwrap();
+        assert_eq!(change.operation_id, None);
+    }
+    #[test]
+    fn mutation_requests_and_outcomes_round_trip() {
+        let request = serde_json::json!({"chatId":"chat", "operationId":"op", "expectedCheckoutId":"checkout", "sourcePath":"a", "destinationPath":"b", "expectedSourceRevision":"rev", "expectedKind":"file"});
+        let decoded: MoveWorkspaceEntryRequest = serde_json::from_value(request.clone()).unwrap();
+        let encoded = serde_json::to_value(decoded).unwrap();
+        for (key, value) in request.as_object().unwrap() {
+            assert_eq!(&encoded[key], value);
+        }
+        let delete: DeleteWorkspaceEntryRequest = serde_json::from_value(serde_json::json!({"chatId":"chat", "operationId":"op", "expectedCheckoutId":"checkout", "path":"a", "expectedSourceRevision":"rev", "expectedKind":"directory", "recursive":true})).unwrap();
+        assert_eq!(
+            serde_json::from_value::<DeleteWorkspaceEntryRequest>(
+                serde_json::to_value(&delete).unwrap()
+            )
+            .unwrap(),
+            delete
+        );
+        let outcome = WorkspaceMutationOutcome::Rejected {
+            operation_id: "op".into(),
+            reason: WorkspaceMutationRejection::DestinationExists,
+            message: "Destination exists".into(),
+        };
+        assert_eq!(
+            serde_json::from_value::<WorkspaceMutationOutcome>(
+                serde_json::to_value(&outcome).unwrap()
+            )
+            .unwrap(),
+            outcome
+        );
+        assert!(
+            serde_json::from_value::<WorkspaceMutationRejection>(serde_json::json!("overwrite"))
+                .is_err()
+        );
+    }
+}
diff --git a/crates/rpc/src/lib.rs b/crates/rpc/src/lib.rs
index c32758ab0f..c5d6d0e327 100644
--- a/crates/rpc/src/lib.rs
+++ b/crates/rpc/src/lib.rs
@@ -163,6 +163,8 @@ pub mod methods {
     pub const SEARCH_WORKSPACE_FILES: &str = "SearchWorkspaceFiles";
     pub const READ_WORKSPACE_IMAGE: &str = "ReadWorkspaceImage";
     pub const READ_WORKSPACE_FILE: &str = "ReadWorkspaceFile";
+    pub const MOVE_WORKSPACE_ENTRY: &str = "MoveWorkspaceEntry";
+    pub const DELETE_WORKSPACE_ENTRY: &str = "DeleteWorkspaceEntry";
     pub const WRITE_WORKSPACE_FILE: &str = "WriteWorkspaceFile";
     pub const WATCH_WORKSPACE_FILES: &str = "WatchWorkspaceFiles";
     pub const CREATE_WORKTREE: &str = "CreateWorktree";
diff --git a/crates/ui/src/files/client.rs b/crates/ui/src/files/client.rs
index a7669da2e6..8b100ccba2 100644
--- a/crates/ui/src/files/client.rs
+++ b/crates/ui/src/files/client.rs
@@ -132,7 +132,7 @@ impl WorkspaceFilesClient {
     /// Refresh through the cached children before publishing the new listing.
     /// Usually this reads only the pages already visited. If a cached child is
     /// missing, reach the end before treating it as deleted.
-    pub(super) async fn list_directory_snapshot(
+    pub(crate) async fn list_directory_snapshot(
         &self,
         mut request: ListWorkspaceDirectoryRequest,
         cached_paths: &[String],
@@ -156,6 +156,11 @@ impl WorkspaceFilesClient {
                 }
                 request.cursor = Some(cursor);
                 let next = self.list_directory(request.clone()).await?;
+                if next.checkout_id != page.checkout_id {
+                    return Err(FilesClientError::Decode(
+                        "Workspace changed between directory pages".into(),
+                    ));
+                }
                 for entry in &next.entries {
                     remaining.remove(entry.path.as_str());
                 }
@@ -256,6 +261,20 @@ impl WorkspaceFilesClient {
         self.call(methods::WRITE_WORKSPACE_FILE, &request).await
     }
 
+    pub async fn move_entry(
+        &self,
+        request: zeron_proto::MoveWorkspaceEntryRequest,
+    ) -> Result<zeron_proto::WorkspaceMutationOutcome, FilesClientError> {
+        self.call(methods::MOVE_WORKSPACE_ENTRY, &request).await
+    }
+
+    pub async fn delete_entry(
+        &self,
+        request: zeron_proto::DeleteWorkspaceEntryRequest,
+    ) -> Result<zeron_proto::WorkspaceMutationOutcome, FilesClientError> {
+        self.call(methods::DELETE_WORKSPACE_ENTRY, &request).await
+    }
+
     pub async fn watch(&self) -> Result<mpsc::Receiver<serde_json::Value>, FilesClientError> {
         let request = WatchWorkspaceFilesRequest {
             target: self.context.target.clone(),
@@ -356,6 +375,40 @@ mod tests {
         })
     }
 
+    #[tokio::test]
+    async fn structural_mutations_preserve_remote_addressing_and_never_retry_transport_errors() {
+        let transport = Arc::new(DeterministicTransport {
+            scripted_responses: Mutex::new([Err(RpcError::Transport("reply lost".into()))].into()),
+            ..Default::default()
+        });
+        let client = WorkspaceFilesClient::with_transport(
+            transport.clone(),
+            FilesRequestContext {
+                target: target(),
+                target_device_id: Some("host".into()),
+                cwd: "/remote".into(),
+                checkout_id: Some("checkout".into()),
+            },
+        );
+        let result = client
+            .move_entry(zeron_proto::MoveWorkspaceEntryRequest {
+                target: target(),
+                operation_id: "op".into(),
+                expected_checkout_id: "checkout".into(),
+                source_path: "a".into(),
+                destination_path: "folder/a".into(),
+                expected_source_revision: "rev".into(),
+                expected_kind: zeron_proto::WorkspaceEntryKind::File,
+            })
+            .await;
+        assert!(result.is_err());
+        let calls = transport.calls.lock().unwrap();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].0, methods::MOVE_WORKSPACE_ENTRY);
+        assert_eq!(calls[0].1["targetDeviceId"], "host");
+        assert_eq!(calls[0].1["expectedCheckoutId"], "checkout");
+        assert_eq!(calls[0].1["sourcePath"], "a");
+    }
     #[tokio::test]
     async fn cached_directory_refresh_collects_pages_but_initial_load_stays_lazy() {
         for refresh in [false, true] {
diff --git a/crates/ui/src/files/context_menu.rs b/crates/ui/src/files/context_menu.rs
new file mode 100644
index 0000000000..c6cefee1bd
--- /dev/null
+++ b/crates/ui/src/files/context_menu.rs
@@ -0,0 +1,322 @@
+//! Tree menus share the editor's popup surface, positioning and dismissal.
+use super::*;
+use crate::{icons, popover, theme::Theme};
+use gpui::{ClipboardItem, KeyDownEvent, MouseButton};
+use mutations::WorkspaceInteractionOrigin;
+
+pub(super) struct TreeContextMenu {
+    pub path: String,
+    pub origin: WorkspaceInteractionOrigin,
+    pub position: Point<Pixels>,
+    pub active: usize,
+}
+
+fn absolute_workspace_path(root: &str, relative: &str) -> String {
+    // Interpret the owning host's path, not the desktop's OS. PathBuf::join
+    // would mix separators when viewing a Windows workspace from Linux/macOS.
+    let bytes = root.as_bytes();
+    let windows = root.starts_with("\\\\")
+        || (bytes.len() >= 3
+            && bytes[0].is_ascii_alphabetic()
+            && bytes[1] == b':'
+            && matches!(bytes[2], b'/' | b'\\'));
+    if windows {
+        format!(
+            "{}\\{}",
+            root.trim_end_matches(['/', '\\']).replace('/', "\\"),
+            relative.replace('/', "\\")
+        )
+    } else {
+        format!("{}/{}", root.trim_end_matches('/'), relative)
+    }
+}
+
+impl FilesSurface {
+    pub(super) fn open_tree_context_menu(
+        &mut self,
+        path: String,
+        position: Point<Pixels>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(origin) = self.interaction_origin(cx) else {
+            return;
+        };
+        if self.tree.node(&path).is_none() {
+            return;
+        }
+        self.tree.select(path.clone());
+        self.tree_focus.focus(window, cx);
+        self.close_editor_context_menu(cx);
+        self.tree_context_menu.open(TreeContextMenu {
+            path,
+            origin,
+            position,
+            active: 0,
+        });
+        cx.notify();
+    }
+
+    pub(super) fn close_tree_context_menu(&mut self, cx: &mut Context<Self>) {
+        if self.tree_context_menu.begin_close() {
+            popover::reap_popup(cx, |files: &mut Self| &mut files.tree_context_menu);
+            cx.notify();
+        }
+    }
+
+    pub(super) fn tree_menu_key(
+        &mut self,
+        event: &KeyDownEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        if !self.tree_context_menu.is_open() {
+            return false;
+        }
+        match popover::classify_key(
+            &event.keystroke.key,
+            event.keystroke.modifiers.platform,
+            event.keystroke.modifiers.control,
+        ) {
+            popover::MenuKey::Escape => self.close_tree_context_menu(cx),
+            key @ (popover::MenuKey::Up | popover::MenuKey::Down) => {
+                if let Some(menu) = self.tree_context_menu.as_open() {
+                    let mut next = menu.active;
+                    for _ in 0..4 {
+                        next = popover::menu_step(
+                            Some(next),
+                            4,
+                            if matches!(key, popover::MenuKey::Up) {
+                                -1
+                            } else {
+                                1
+                            },
+                        )
+                        .unwrap_or(0);
+                        if next < 2 || self.can_mutate_tree_entry(&menu.path, next == 3, cx) {
+                            break;
+                        }
+                    }
+                    self.tree_context_menu.open_mut().unwrap().active = next;
+                    cx.notify();
+                }
+            }
+            popover::MenuKey::Enter => {
+                if let Some(menu) = self.tree_context_menu.as_open() {
+                    self.dispatch_tree_menu(menu.active, window, cx);
+                }
+            }
+            _ => {}
+        }
+        window.prevent_default();
+        cx.stop_propagation();
+        true
+    }
+
+    fn dispatch_tree_menu(&mut self, action: usize, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(menu) = self.tree_context_menu.as_open() else {
+            return;
+        };
+        let path = menu.path.clone();
+        let origin = menu.origin.clone();
+        if !self.accepts_origin(&origin, cx) {
+            self.close_tree_context_menu(cx);
+            return;
+        }
+        let Some(node) = self.tree.node(&path) else {
+            self.close_tree_context_menu(cx);
+            return;
+        };
+        let is_directory = node.entry.kind == zeron_proto::WorkspaceEntryKind::Directory;
+        self.close_tree_context_menu(cx);
+        match action {
+            0 => cx.emit(FilesEvent::AddToChat {
+                path,
+                is_directory,
+                origin,
+            }),
+            1 => {
+                cx.write_to_clipboard(ClipboardItem::new_string(absolute_workspace_path(
+                    &origin.context.cwd,
+                    &path,
+                )));
+                self.tree_focus.focus(window, cx);
+            }
+            2 => self.begin_tree_rename(path, window, cx),
+            3 => self.begin_tree_delete(path, window, cx),
+            _ => {}
+        }
+    }
+
+    pub(super) fn render_tree_context_menu(
+        &self,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> Option<gpui::AnyElement> {
+        let menu = self.tree_context_menu.get()?;
+        let theme = theme.for_popup();
+        let mut card = popover::popover_card(&theme)
+            .w(px(190.0))
+            .flex()
+            .flex_col()
+            .on_mouse_down_out(cx.listener(|this, _, _, cx| this.close_tree_context_menu(cx)))
+            .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation());
+        for (index, (label, icon_path)) in [
+            ("Add to chat", icons::CHAT_ROUND_LINE),
+            ("Copy path", icons::COPY),
+            ("Rename…", icons::PEN),
+            ("Delete…", icons::TRASH_BIN_MINIMALISTIC),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            if index == 2 {
+                card = card.child(popover::menu_separator());
+            }
+            let enabled = index < 2 || self.can_mutate_tree_entry(&menu.path, index == 3, cx);
+            card = card.child(
+                popover::menu_row(&theme, menu.active == index, format!("tree-menu-{index}"))
+                    .id(gpui::SharedString::from(format!("tree-menu-{index}")))
+                    .role(gpui::Role::MenuItem)
+                    .aria_label(label)
+                    .when(index == 3, |row| row.text_color(theme.danger))
+                    .when(index == 1, |row| {
+                        row.tooltip(|_, cx| {
+                            cx.new(|_| preview::FileEditorTooltip {
+                                text: "Copy full path".into(),
+                            })
+                            .into()
+                        })
+                    })
+                    .when(!enabled, |el| el.opacity(0.38).cursor_default())
+                    .when(enabled, |el| {
+                        el.on_click(cx.listener(move |this, _, window, cx| {
+                            this.dispatch_tree_menu(index, window, cx)
+                        }))
+                    })
+                    .child(
+                        icons::icon(icon_path)
+                            .size(px(16.0))
+                            .text_color(if index == 3 {
+                                theme.danger
+                            } else {
+                                theme.text_muted
+                            }),
+                    )
+                    .child(label),
+            );
+        }
+        Some(popover::menu_at(
+            "tree-context-menu",
+            menu.position,
+            card.into_any_element(),
+            self.tree_context_menu.closing_since(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::{AppContext, TestAppContext};
+
+    #[test]
+    fn full_paths_follow_the_owning_hosts_path_format() {
+        for (root, expected) in [
+            ("/workspace", "/workspace/src/a.txt"),
+            ("/workspace/", "/workspace/src/a.txt"),
+            ("/", "/src/a.txt"),
+            (r"C:\work", r"C:\work\src\a.txt"),
+            (r"C:\", r"C:\src\a.txt"),
+            ("C:/work/", r"C:\work\src\a.txt"),
+            (r"\\server\share\work\", r"\\server\share\work\src\a.txt"),
+            (r"\\?\C:\work", r"\\?\C:\work\src\a.txt"),
+        ] {
+            assert_eq!(absolute_workspace_path(root, "src/a.txt"), expected);
+        }
+    }
+
+    #[gpui::test]
+    fn copy_uses_the_remote_workspace_root(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+        });
+        for (root, expected) in [
+            ("/remote/project", "/remote/project/a.txt"),
+            (r"D:\remote\project", r"D:\remote\project\a.txt"),
+        ] {
+            let window = cx.add_window(|_, cx| {
+                let state = cx.new(|_| {
+                    let mut state = super::super::test_support::state();
+                    state.chats[0].device_id = "remote-host".into();
+                    state.chats[0].cwd = Some(root.into());
+                    state
+                });
+                super::super::test_support::explorer(state, cx)
+            });
+            window
+                .update(cx, |files, window, cx| {
+                    assert_eq!(
+                        files
+                            .request_context
+                            .as_ref()
+                            .unwrap()
+                            .target_device_id
+                            .as_deref(),
+                        Some("remote-host")
+                    );
+                    files.open_tree_context_menu(
+                        "a.txt".into(),
+                        gpui::point(px(50.), px(50.)),
+                        window,
+                        cx,
+                    );
+                    files.dispatch_tree_menu(1, window, cx);
+                    assert_eq!(
+                        cx.read_from_clipboard().unwrap().text().as_deref(),
+                        Some(expected)
+                    );
+                })
+                .unwrap();
+        }
+    }
+
+    #[gpui::test]
+    fn menu_selects_without_opening_and_copies_full_path(cx: &mut TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _subscription = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        files.update_in(cx, |files, window, cx| {
+            files.open_tree_context_menu("a.txt".into(), gpui::point(px(50.), px(50.)), window, cx);
+            assert_eq!(files.tree.selected(), Some("a.txt"));
+            assert!(events.borrow().is_empty());
+            files.dispatch_tree_menu(1, window, cx);
+            assert_eq!(
+                cx.read_from_clipboard().unwrap().text().as_deref(),
+                Some("/workspace/a.txt")
+            );
+            files.open_tree_context_menu(
+                "folder".into(),
+                gpui::point(px(50.), px(50.)),
+                window,
+                cx,
+            );
+            assert!(!files.tree.is_expanded("folder"));
+            files.dispatch_tree_menu(0, window, cx);
+        });
+        cx.run_until_parked();
+        assert!(events.borrow().iter().any(|event|matches!(event,FilesEvent::AddToChat{path,is_directory:true,..} if path=="folder")));
+        assert!(
+            !events
+                .borrow()
+                .iter()
+                .any(|event| matches!(event, FilesEvent::OpenFile(_)))
+        );
+    }
+}
diff --git a/crates/ui/src/files/drag.rs b/crates/ui/src/files/drag.rs
new file mode 100644
index 0000000000..ccccd82aff
--- /dev/null
+++ b/crates/ui/src/files/drag.rs
@@ -0,0 +1,490 @@
+//! Workspace drag targets are scoped to the tree viewport; the chat keeps its own receiver.
+use super::*;
+use gpui::{AnyElement, Bounds, CursorStyle, DragMoveEvent};
+use std::{cell::RefCell, rc::Rc};
+use zeron_proto::WorkspaceEntryKind;
+
+#[derive(Default)]
+pub(super) struct TreeDrag {
+    rows: Rc<RefCell<HashMap<String, (Bounds<Pixels>, Option<String>)>>>,
+    pub payload: Option<WorkspacePathDrag>,
+    pub destination: Option<String>,
+    pub pointer: Point<Pixels>,
+    pub bounds: Bounds<Pixels>,
+    hover_since: Option<std::time::Instant>,
+    last_tick: Option<std::time::Instant>,
+    tick_task: Option<Task<()>>,
+}
+
+/// The server is authoritative for existence/permissions/collisions. This
+/// resolver handles gesture semantics without touching the filesystem.
+pub(super) fn destination_path(
+    source: &str,
+    directory: &str,
+    is_directory: bool,
+) -> Option<String> {
+    if source.is_empty() || model::parent_path(source).as_deref() == Some(directory) {
+        return None;
+    }
+    if is_directory && mutations::contains_path(source, directory) {
+        return None;
+    }
+    let name = source.rsplit('/').next()?;
+    Some(if directory.is_empty() {
+        name.into()
+    } else {
+        format!("{directory}/{name}")
+    })
+}
+
+impl FilesSurface {
+    pub(super) fn track_tree_drop_row(
+        &self,
+        key: String,
+        target: Option<String>,
+        height: f32,
+        content: AnyElement,
+    ) -> AnyElement {
+        let rows = self.tree_drag.rows.clone();
+        div()
+            .relative()
+            .w_full()
+            .h(px(height))
+            .flex_none()
+            .child(content)
+            .child(
+                gpui::canvas(
+                    move |bounds, _, _| {
+                        rows.borrow_mut()
+                            .insert(key.clone(), (bounds, target.clone()));
+                    },
+                    |_, _, _, _| {},
+                )
+                .absolute()
+                .inset_0(),
+            )
+            .into_any_element()
+    }
+
+    pub(super) fn render_tree_root_target(&self, cx: &mut Context<Self>) -> AnyElement {
+        let theme = crate::theme::Theme::of(cx);
+        let active = self.tree_drag.destination.as_deref() == Some("");
+        let label = if self.tree_drag.payload.is_some() {
+            "Move to workspace root"
+        } else {
+            "Workspace root"
+        };
+        self.track_tree_drop_row(
+            "".into(),
+            Some("".into()),
+            24.,
+            div()
+                .id("tree-workspace-root")
+                .debug_selector(|| "tree-workspace-root".into())
+                .h(px(24.))
+                .w_full()
+                .px(px(8.))
+                .flex()
+                .items_center()
+                .text_size(px(10.5))
+                .text_color(theme.text_muted)
+                .when(active, |el| el.bg(crate::theme::wash(0.16)))
+                .aria_label(label)
+                .child(label)
+                .into_any_element(),
+        )
+    }
+
+    pub(super) fn reset_tree_drop_rows(&self) {
+        self.tree_drag.rows.borrow_mut().clear();
+    }
+
+    pub(super) fn tree_drag_compatible(&self, payload: &WorkspacePathDrag, cx: &gpui::App) -> bool {
+        payload.source == WorkspacePathSource::Tree
+            && payload.origin.as_ref().is_some_and(|origin| {
+                self.accepts_origin(origin, cx) && origin.checkout_id == self.effective_checkout_id
+            })
+            && !self.mutation_busy()
+            && self.tree_rename.is_none()
+            && self.tree_delete.is_none()
+            && self
+                .mutation_capabilities
+                .is_some_and(|caps| caps.move_entry)
+            && self.tree.node(&payload.path).is_some_and(|node| {
+                node.entry.kind != WorkspaceEntryKind::Symlink
+                    && node.entry.mutation_revision.is_some()
+                    && node.entry.mutation_revision == payload.revision
+            })
+    }
+
+    fn drop_directory_at(&self, point: Point<Pixels>) -> Option<String> {
+        if !self.tree_drag.bounds.contains(&point) {
+            return None;
+        }
+        // The rail remains a scroll control, not a root drop target.
+        if point.x > self.tree_drag.bounds.right() - px(12.) {
+            return None;
+        }
+        let rows = self.tree_drag.rows.borrow();
+        for (bounds, target) in rows.values() {
+            if bounds.contains(&point) {
+                let path = target.as_ref()?;
+                if path.is_empty() {
+                    return Some(String::new());
+                }
+                let node = self.tree.node(path)?;
+                return match node.entry.kind {
+                    WorkspaceEntryKind::Directory => Some(path.clone()),
+                    WorkspaceEntryKind::File => model::parent_path(path),
+                    WorkspaceEntryKind::Symlink => None,
+                };
+            }
+        }
+        let viewport = self.tree_list.viewport_bounds();
+        let last = rows.values().map(|(bounds, _)| bounds.bottom()).max();
+        if viewport.contains(&point) && last.is_none_or(|bottom| point.y >= bottom) {
+            Some(String::new())
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn on_tree_drag_move(
+        &mut self,
+        event: &DragMoveEvent<WorkspacePathDrag>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let payload = event.drag(cx).clone();
+        self.tree_drag.bounds = event.bounds;
+        if !event.bounds.contains(&event.event.position) || !self.tree_drag_compatible(&payload, cx)
+        {
+            self.clear_tree_drag(window, cx);
+            return;
+        }
+        self.close_tree_context_menu(cx);
+        self.tree_drag.pointer = event.event.position;
+        self.tree_drag.payload = Some(payload.clone());
+        let destination = self
+            .drop_directory_at(event.event.position)
+            .filter(|directory| {
+                destination_path(&payload.path, directory, payload.is_directory).is_some()
+            });
+        if self.tree_drag.destination != destination {
+            self.tree_drag.hover_since = Some(cx.background_executor().now());
+            self.tree_drag.destination = destination;
+            cx.notify();
+        }
+        if self.tree_drag.tick_task.is_none() {
+            self.tree_drag.last_tick = Some(cx.background_executor().now());
+            self.tree_drag.tick_task = Some(cx.spawn_in(window, async move |this, cx| {
+                loop {
+                    cx.background_executor()
+                        .timer(Duration::from_millis(16))
+                        .await;
+                    if !this
+                        .update_in(cx, |files, window, cx| files.tree_drag_tick(window, cx))
+                        .unwrap_or(false)
+                    {
+                        break;
+                    }
+                }
+            }));
+        }
+        cx.set_active_drag_cursor_style(
+            if self.tree_drag.destination.is_some() {
+                CursorStyle::ClosedHand
+            } else {
+                CursorStyle::OperationNotAllowed
+            },
+            window,
+        );
+    }
+
+    pub(super) fn on_tree_drop(
+        &mut self,
+        payload: &WorkspacePathDrag,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let destination = if self.tree_drag_compatible(payload, cx) {
+            self.drop_directory_at(window.mouse_position())
+                .and_then(|directory| {
+                    destination_path(&payload.path, &directory, payload.is_directory)
+                })
+        } else {
+            None
+        };
+        self.clear_tree_drag(window, cx);
+        if let Some(destination) = destination {
+            self.request_mutation(&payload.path, Some(destination), cx);
+        }
+    }
+
+    pub(super) fn tree_drag_tick(&mut self, window: &mut Window, cx: &mut Context<Self>) -> bool {
+        let Some(payload) = self.tree_drag.payload.clone() else {
+            return false;
+        };
+        let pointer = window.mouse_position();
+        if !cx.has_active_drag()
+            || !window.is_window_active()
+            || !self.tree_drag_compatible(&payload, cx)
+            || !self.tree_drag.bounds.contains(&pointer)
+        {
+            self.clear_tree_drag(window, cx);
+            return false;
+        }
+        let now = cx.background_executor().now();
+        let elapsed = self
+            .tree_drag
+            .last_tick
+            .replace(now)
+            .map(|last| now.saturating_duration_since(last).as_secs_f32())
+            .unwrap_or(0.)
+            .min(0.05);
+        let viewport = self.tree_list.viewport_bounds();
+        let speed = if viewport.contains(&pointer) {
+            edge_scroll_speed(
+                f32::from(pointer.y),
+                f32::from(viewport.top()),
+                f32::from(viewport.bottom()),
+            )
+        } else {
+            0.
+        };
+        if speed != 0. {
+            let offset = self.tree_list.scroll_px_offset_for_scrollbar();
+            self.tree_list
+                .set_offset_from_scrollbar(gpui::point(offset.x, offset.y - px(speed * elapsed)));
+            cx.notify();
+        }
+        let destination = self.drop_directory_at(pointer).filter(|directory| {
+            destination_path(&payload.path, directory, payload.is_directory).is_some()
+        });
+        if destination != self.tree_drag.destination {
+            self.tree_drag.destination = destination;
+            self.tree_drag.hover_since = Some(now);
+            cx.notify();
+        }
+        if self
+            .tree_drag
+            .hover_since
+            .is_some_and(|since| now.saturating_duration_since(since) >= Duration::from_millis(650))
+        {
+            self.tree_drag.hover_since = None;
+            if let Some(directory) = self.tree_drag.destination.clone().filter(|p| !p.is_empty()) {
+                if self.tree.expand(&directory) {
+                    self.sync_tree_list();
+                    let needs_load = self
+                        .tree
+                        .node(&directory)
+                        .is_some_and(|node| node.stale || !node.has_loaded);
+                    if needs_load {
+                        self.load_directory(directory, None, cx);
+                    }
+                    cx.notify();
+                }
+            }
+        }
+        true
+    }
+
+    pub(crate) fn suspend_tree_interactions(&mut self, cx: &mut Context<Self>) {
+        if self.tree_drag.payload.is_some()
+            || self.tree_context_menu.is_open()
+            || self
+                .tree_rename
+                .as_ref()
+                .is_some_and(|rename| !rename.submitted)
+            || self.tree_delete.is_some()
+        {
+            self.interaction_generation = self.interaction_generation.wrapping_add(1);
+            self.tree_drag = TreeDrag::default();
+            self.close_tree_context_menu(cx);
+            if self
+                .tree_rename
+                .as_ref()
+                .is_some_and(|rename| !rename.submitted)
+            {
+                self.tree_rename = None;
+            }
+            if let Some(dialog) = self.tree_delete.take() {
+                cx.emit(FilesEvent::HoldMutation {
+                    origin: dialog.origin,
+                    path: None,
+                });
+            }
+            cx.notify();
+        }
+    }
+
+    pub(super) fn clear_tree_drag(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.tree_drag.tick_task = None;
+        self.tree_drag.hover_since = None;
+        self.tree_drag.last_tick = None;
+        if self.tree_drag.payload.take().is_some() || self.tree_drag.destination.take().is_some() {
+            self.tree_drag.destination = None;
+            cx.set_active_drag_cursor_style(CursorStyle::Arrow, window);
+            cx.notify();
+        }
+    }
+}
+
+fn edge_scroll_speed(y: f32, top: f32, bottom: f32) -> f32 {
+    if y < top || y > bottom || bottom <= top {
+        return 0.;
+    }
+    let band = 28.0_f32.min((bottom - top) / 2.0);
+    if y < top + band {
+        -540.0 * (1.0 - (y - top) / band)
+    } else if y > bottom - band {
+        540.0 * (1.0 - (bottom - y) / band)
+    } else {
+        0.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[gpui::test]
+    fn real_tree_drop_emits_one_move_and_no_chat_reference(cx: &mut gpui::TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        let start = cx.debug_bounds("tree-entry:a.txt").unwrap().center();
+        let end = cx.debug_bounds("tree-entry:folder").unwrap().center();
+        cx.simulate_mouse_down(start, gpui::MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(
+            start + gpui::point(px(9.), px(0.)),
+            Some(gpui::MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.simulate_mouse_move(
+            end,
+            Some(gpui::MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.simulate_mouse_up(end, gpui::MouseButton::Left, gpui::Modifiers::default());
+        cx.run_until_parked();
+        let events = events.borrow();
+        let moves = events
+            .iter()
+            .filter_map(|event| {
+                if let FilesEvent::Mutate(intent) = event {
+                    Some(intent)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(moves.len(), 1);
+        assert_eq!(moves[0].destination.as_deref(), Some("folder/a.txt"));
+        assert!(
+            !events
+                .iter()
+                .any(|event| matches!(event, FilesEvent::AddToChat { .. }))
+        );
+    }
+    #[gpui::test]
+    fn hover_expands_only_after_delay_and_escape_stops_tasks(cx: &mut gpui::TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let start = cx.debug_bounds("tree-entry:a.txt").unwrap().center();
+        let end = cx.debug_bounds("tree-entry:folder").unwrap().center();
+        cx.simulate_mouse_down(start, gpui::MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(
+            start + gpui::point(px(9.), px(0.)),
+            Some(gpui::MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.simulate_mouse_move(
+            end,
+            Some(gpui::MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.executor().advance_clock(Duration::from_millis(649));
+        files.update_in(cx, |files, window, cx| {
+            files.tree_drag_tick(window, cx);
+            assert!(!files.tree.is_expanded("folder"));
+        });
+        cx.executor().advance_clock(Duration::from_millis(1));
+        files.update_in(cx, |files, window, cx| {
+            files.tree_drag_tick(window, cx);
+            assert!(files.tree.is_expanded("folder"));
+        });
+        cx.simulate_keystrokes("escape");
+        files.read_with(cx, |files, cx| {
+            assert!(files.tree_drag.tick_task.is_none());
+            assert!(files.tree_drag.destination.is_none());
+            assert!(!cx.has_active_drag());
+        });
+    }
+    #[cfg(target_os = "windows")]
+    #[gpui::test]
+    fn windows_row_jitter_preserves_click_and_row_starts_drag(cx: &mut gpui::TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        let row = cx.debug_bounds("tree-entry:a.txt").unwrap().center();
+        cx.simulate_mouse_down(row, gpui::MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(
+            row + gpui::point(px(3.), px(0.)),
+            Some(gpui::MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.update(|_, cx| assert!(!cx.has_active_drag()));
+        cx.simulate_mouse_up(
+            row + gpui::point(px(3.), px(0.)),
+            gpui::MouseButton::Left,
+            gpui::Modifiers::default(),
+        );
+        cx.run_until_parked();
+        assert!(
+            events
+                .borrow()
+                .iter()
+                .any(|event| matches!(event,FilesEvent::OpenFile(path) if path=="a.txt"))
+        );
+        cx.simulate_mouse_down(row, gpui::MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(
+            row + gpui::point(px(9.), px(0.)),
+            Some(gpui::MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.update(|_, cx| assert!(cx.has_active_drag()));
+        cx.simulate_keystrokes("escape");
+    }
+    #[test]
+    fn autoscroll_is_bounded_and_stops_outside_the_viewport() {
+        assert_eq!(edge_scroll_speed(100., 100., 500.), -540.);
+        assert_eq!(edge_scroll_speed(500., 100., 500.), 540.);
+        assert_eq!(edge_scroll_speed(300., 100., 500.), 0.);
+        assert_eq!(edge_scroll_speed(99., 100., 500.), 0.);
+        assert!(edge_scroll_speed(486., 100., 500.) > 0.);
+    }
+    #[test]
+    fn tree_drop_resolves_parent_root_and_descendants() {
+        assert_eq!(
+            destination_path("a/file", "b", false).as_deref(),
+            Some("b/file")
+        );
+        assert_eq!(
+            destination_path("a/file", "", false).as_deref(),
+            Some("file")
+        );
+        assert_eq!(destination_path("a/file", "a", false), None);
+        assert_eq!(destination_path("a", "a/sub", true), None);
+        assert_eq!(destination_path("a", "a", true), None);
+        assert_eq!(destination_path("a", "ab", true).as_deref(), Some("ab/a"));
+    }
+}
diff --git a/crates/ui/src/files/mod.rs b/crates/ui/src/files/mod.rs
index 08d73af527..e672ec44ad 100644
--- a/crates/ui/src/files/mod.rs
+++ b/crates/ui/src/files/mod.rs
@@ -18,7 +18,9 @@ use crate::{
 };
 
 pub mod client;
+mod context_menu;
 pub mod document;
+mod drag;
 pub mod editor;
 pub mod editor_adapter;
 mod git_status;
@@ -26,9 +28,13 @@ mod image_preview;
 pub(crate) mod markdown_media;
 mod markdown_preview;
 pub mod model;
+pub mod mutations;
 pub mod preview;
+mod rename;
 pub mod search;
 mod sections;
+#[cfg(test)]
+pub(crate) mod test_support;
 pub mod tree;
 pub mod watch;
 
@@ -80,13 +86,41 @@ pub(super) fn toolbar_button(id: &'static str, label: &'static str) -> gpui::Sta
 /// that workspace instead of leaking a path from the UI machine.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct WorkspacePathDrag {
+    pub origin: Option<mutations::WorkspaceInteractionOrigin>,
+    pub source: WorkspacePathSource,
+    pub revision: Option<String>,
     pub path: String,
     pub is_directory: bool,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum WorkspacePathSource {
+    Tree,
+    Search,
+    FileTab,
+}
+
 impl WorkspacePathDrag {
     pub(crate) fn new(path: String, is_directory: bool) -> Self {
-        Self { path, is_directory }
+        Self {
+            path,
+            is_directory,
+            origin: None,
+            source: WorkspacePathSource::Search,
+            revision: None,
+        }
+    }
+
+    pub(crate) fn with_origin(
+        mut self,
+        origin: Option<mutations::WorkspaceInteractionOrigin>,
+        source: WorkspacePathSource,
+        revision: Option<String>,
+    ) -> Self {
+        self.origin = origin;
+        self.source = source;
+        self.revision = revision;
+        self
     }
 
     fn title(&self) -> SharedString {
@@ -147,6 +181,16 @@ pub(crate) fn workspace_path_drag_ghost(
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum FilesEvent {
+    AddToChat {
+        path: String,
+        is_directory: bool,
+        origin: mutations::WorkspaceInteractionOrigin,
+    },
+    HoldMutation {
+        origin: mutations::WorkspaceInteractionOrigin,
+        path: Option<String>,
+    },
+    Mutate(mutations::MutationIntent),
     OpenFile(String),
     RevealFile(String),
     OpenWebLink(crate::markdown::render::LinkActivation),
@@ -205,6 +249,18 @@ struct EditorContextMenu {
 }
 
 pub struct FilesSurface {
+    surface_id: gpui::EntityId,
+    interaction_generation: u64,
+    effective_checkout_id: Option<String>,
+    mutation_capabilities: Option<zeron_proto::WorkspaceMutationCapabilities>,
+    pending_mutation: Option<mutations::MutationIntent>,
+    deferred_file_changes: Vec<zeron_proto::WorkspaceFileChanges>,
+    applied_mutations: std::collections::VecDeque<String>,
+    mutation_error: Option<SharedString>,
+    mutation_hold: Option<String>,
+    tree_drag: drag::TreeDrag,
+    tree_rename: Option<rename::TreeRename>,
+    tree_delete: Option<rename::TreeDelete>,
     state: Entity<AppState>,
     chat_id: String,
     review_comment_flush_source: u64,
@@ -231,6 +287,7 @@ pub struct FilesSurface {
     watch_sequence: Option<u64>,
     watch_error: Option<SharedString>,
     preview: FilePreviewState,
+    tree_context_menu: crate::popover::Popup<context_menu::TreeContextMenu>,
     pending_line_navigation: Option<(u32, Option<u32>)>,
     line_navigation_generation: u64,
     editor_context_menu: crate::popover::Popup<EditorContextMenu>,
@@ -245,6 +302,9 @@ pub struct FilesSurface {
 
 impl Render for FilesSurface {
     fn render(&mut self, window: &mut gpui::Window, cx: &mut Context<Self>) -> impl IntoElement {
+        if !cx.has_active_drag() || !self.is_current_target(cx) {
+            self.clear_tree_drag(window, cx);
+        }
         if std::mem::take(&mut self.search_restore_tree_focus) {
             self.tree_focus.focus(window, cx);
         }
@@ -281,8 +341,15 @@ impl Render for FilesSurface {
             .flex_col()
             .children(header)
             .child(div().flex_1().min_h_0().w_full().child(body))
+            .children(
+                self.mutation_error
+                    .as_ref()
+                    .map(|message| crate::popover::error_row(&theme, message).into_any_element()),
+            )
             .children(sections)
             .children(editor_context_menu)
+            .children(self.render_tree_context_menu(&theme, cx))
+            .children(self.render_tree_delete(&theme, window, cx))
     }
 }
 
@@ -562,6 +629,18 @@ impl FilesSurface {
                 .ok();
         });
         let mut surface = Self {
+            surface_id: cx.entity_id(),
+            interaction_generation: 0,
+            effective_checkout_id: None,
+            mutation_capabilities: None,
+            pending_mutation: None,
+            deferred_file_changes: Vec::new(),
+            applied_mutations: std::collections::VecDeque::new(),
+            mutation_error: None,
+            mutation_hold: None,
+            tree_drag: drag::TreeDrag::default(),
+            tree_rename: None,
+            tree_delete: None,
             state,
             chat_id,
             review_comment_flush_source: NEXT_REVIEW_COMMENT_FLUSH_SOURCE
@@ -593,6 +672,7 @@ impl FilesSurface {
                 word_wrap,
                 editor_font_size,
             ),
+            tree_context_menu: crate::popover::Popup::default(),
             pending_line_navigation: None,
             line_navigation_generation: 0,
             editor_context_menu: crate::popover::Popup::default(),
@@ -957,6 +1037,8 @@ impl FilesSurface {
                 let reload = surface.tree.node(&directory).is_some_and(|node| node.stale);
                 match result {
                     Ok(page) => {
+                        surface.effective_checkout_id = page.checkout_id.clone();
+                        surface.mutation_capabilities = page.mutation_capabilities;
                         surface.error = None;
                         surface.tree.apply_page(page, generation);
                         if directory.is_empty() {
@@ -1027,6 +1109,22 @@ impl FilesSurface {
     }
 
     fn apply_target(&mut self, next: Option<FilesRequestContext>, cx: &mut Context<Self>) {
+        if let Some(dialog) = self.tree_delete.take() {
+            cx.emit(FilesEvent::HoldMutation {
+                origin: dialog.origin,
+                path: None,
+            });
+        }
+        self.tree_rename = None;
+        self.tree_drag = drag::TreeDrag::default();
+        self.mutation_hold = None;
+        self.interaction_generation = self.interaction_generation.wrapping_add(1);
+        self.effective_checkout_id = None;
+        self.mutation_capabilities = None;
+        self.pending_mutation = None;
+        self.deferred_file_changes.clear();
+        self.applied_mutations.clear();
+        self.mutation_error = None;
         self.release_git_status();
         self.suspend_images(cx);
         self.cancel_review_comment_flush(cx);
@@ -1034,6 +1132,7 @@ impl FilesSurface {
         self.watch_task = None;
         self.watch_sequence = None;
         self.watch_error = None;
+        self.tree_context_menu = crate::popover::Popup::default();
         self.editor_context_menu = crate::popover::Popup::default();
         self.preview.reset();
         self.pending_line_navigation = None;
diff --git a/crates/ui/src/files/model.rs b/crates/ui/src/files/model.rs
index ca30729f54..609fb09224 100644
--- a/crates/ui/src/files/model.rs
+++ b/crates/ui/src/files/model.rs
@@ -383,6 +383,92 @@ impl FileTreeModel {
         }
     }
 
+    /// Re-key a confirmed move without throwing away expansion or selection.
+    pub fn relocate_subtree(
+        &mut self,
+        old: &str,
+        new: &str,
+        entry: Option<WorkspaceEntry>,
+    ) -> bool {
+        if old.is_empty() || old == new || is_descendant(new, old) {
+            return false;
+        }
+        let remap = |path: &str| -> String {
+            if path == old {
+                new.to_string()
+            } else if is_descendant(path, old) {
+                format!("{new}{}", &path[old.len()..])
+            } else {
+                path.to_string()
+            }
+        };
+        if !self.nodes.contains_key(old) {
+            return false;
+        }
+        let old_parent = parent_path(old).unwrap();
+        let new_parent = parent_path(new).unwrap();
+        if let Some(parent) = self.nodes.get_mut(&old_parent) {
+            parent.children.retain(|p| p != old);
+        }
+        let nodes = std::mem::take(&mut self.nodes);
+        for (path, mut node) in nodes {
+            let next = remap(&path);
+            node.entry.path = next.clone();
+            if path == old {
+                node.entry.name = new.rsplit('/').next().unwrap_or(new).into();
+            }
+            node.children = node.children.iter().map(|p| remap(p)).collect();
+            if is_descendant(&path, old) || path == old {
+                node.stale = true;
+                if node.entry.kind == WorkspaceEntryKind::Directory {
+                    node.load = DirectoryLoadState::Unloaded;
+                }
+            }
+            self.nodes.insert(next, node);
+        }
+        if let Some(entry) = entry {
+            if let Some(node) = self.nodes.get_mut(new) {
+                node.entry = entry;
+            }
+        }
+        self.expanded = self.expanded.iter().map(|p| remap(p)).collect();
+        self.selected = self.selected.as_deref().map(remap);
+        let mut ancestor = Some(new_parent.clone());
+        while let Some(path) = ancestor {
+            self.expanded.insert(path.clone());
+            ancestor = parent_path(&path);
+        }
+        self.listing_children.clear();
+        if let Some(parent) = self.nodes.get_mut(&new_parent) {
+            if !parent.children.iter().any(|p| p == new) {
+                parent.children.push(new.into());
+            }
+        }
+        for parent in [&old_parent, &new_parent] {
+            if let Some(node) = self.nodes.get_mut(parent) {
+                node.stale = true;
+                node.load = DirectoryLoadState::Unloaded;
+                let mut children = std::mem::take(&mut node.children);
+                children.sort_by(|a, b| compare_paths(&self.nodes, a, b));
+                self.nodes.get_mut(parent).unwrap().children = children;
+            }
+        }
+        self.rebuild_visible_rows();
+        true
+    }
+
+    /// Invalidate asynchronous listings without resetting the visible tree.
+    pub fn invalidate_loads(&mut self) {
+        self.generation = self.generation.wrapping_add(1);
+        self.listing_children.clear();
+        for node in self.nodes.values_mut() {
+            if matches!(node.load, DirectoryLoadState::Loading { .. }) {
+                node.load = DirectoryLoadState::Unloaded;
+                node.stale = true;
+            }
+        }
+    }
+
     pub fn remove(&mut self, path: &str) -> bool {
         if path.is_empty() || !self.nodes.contains_key(path) {
             return false;
@@ -556,6 +642,7 @@ impl FileTreeModel {
 
 fn root_entry() -> WorkspaceEntry {
     WorkspaceEntry {
+        mutation_revision: None,
         path: String::new(),
         name: String::new(),
         kind: WorkspaceEntryKind::Directory,
@@ -614,6 +701,7 @@ mod tests {
 
     fn entry(path: &str, kind: WorkspaceEntryKind) -> WorkspaceEntry {
         WorkspaceEntry {
+            mutation_revision: None,
             path: path.into(),
             name: path.rsplit('/').next().unwrap_or(path).into(),
             kind,
@@ -630,6 +718,8 @@ mod tests {
         next_cursor: Option<&str>,
     ) -> WorkspaceDirectoryPage {
         WorkspaceDirectoryPage {
+            checkout_id: None,
+            mutation_capabilities: None,
             directory: directory.into(),
             entries,
             next_cursor: next_cursor.map(str::to_string),
@@ -637,6 +727,36 @@ mod tests {
         }
     }
 
+    #[test]
+    fn relocation_keeps_descendants_selection_and_expansion() {
+        let mut tree = FileTreeModel::new();
+        tree.begin_load("", None, tree.generation());
+        tree.apply_page(
+            page(
+                "",
+                vec![
+                    entry("a", WorkspaceEntryKind::Directory),
+                    entry("b", WorkspaceEntryKind::Directory),
+                ],
+                None,
+            ),
+            tree.generation(),
+        );
+        tree.expand("a");
+        tree.begin_load("a", None, tree.generation());
+        tree.apply_page(
+            page("a", vec![entry("a/child", WorkspaceEntryKind::File)], None),
+            tree.generation(),
+        );
+        tree.select("a/child");
+        assert!(tree.relocate_subtree("a", "b/a", None));
+        assert!(tree.is_expanded("b/a"));
+        assert_eq!(tree.selected(), Some("b/a/child"));
+        assert!(tree.node("a").is_none());
+        assert!(tree.node("b/a/child").is_some());
+        assert!(!tree.relocate_subtree("a", "b/a", None));
+    }
+
     #[test]
     fn background_refresh_keeps_loaded_rows_even_when_empty_or_failed() {
         let mut tree = FileTreeModel::new();
diff --git a/crates/ui/src/files/mutations.rs b/crates/ui/src/files/mutations.rs
new file mode 100644
index 0000000000..04d16575d3
--- /dev/null
+++ b/crates/ui/src/files/mutations.rs
@@ -0,0 +1,445 @@
+//! Shared identity and reconciliation for tree mutations and workspace references.
+use super::*;
+use zeron_proto::{WorkspaceEntry, WorkspaceEntryKind, WorkspaceMutationOutcome};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WorkspaceInteractionOrigin {
+    pub context: FilesRequestContext,
+    pub surface_id: gpui::EntityId,
+    pub generation: u64,
+    pub checkout_id: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MutationIntent {
+    pub operation_id: String,
+    pub origin: WorkspaceInteractionOrigin,
+    pub entry: WorkspaceEntry,
+    /// None deletes; Some moves without replacement (including rename).
+    pub destination: Option<String>,
+}
+
+pub(crate) fn contains_path(ancestor: &str, path: &str) -> bool {
+    path == ancestor
+        || path
+            .strip_prefix(ancestor)
+            .is_some_and(|suffix| suffix.starts_with('/'))
+}
+
+impl MutationIntent {
+    pub(crate) fn affects(&self, path: &str) -> bool {
+        contains_path(&self.entry.path, path)
+            || self
+                .destination
+                .as_deref()
+                .is_some_and(|to| contains_path(to, path))
+    }
+}
+
+impl FilesSurface {
+    pub(crate) fn interaction_origin(&self, cx: &gpui::App) -> Option<WorkspaceInteractionOrigin> {
+        self.is_current_target(cx)
+            .then(|| WorkspaceInteractionOrigin {
+                context: self.request_context.clone().unwrap(),
+                surface_id: self.surface_id,
+                generation: self.interaction_generation,
+                checkout_id: self.effective_checkout_id.clone().or_else(|| {
+                    self.request_context
+                        .as_ref()
+                        .and_then(|c| c.checkout_id.clone())
+                }),
+            })
+    }
+
+    pub(crate) fn accepts_origin(
+        &self,
+        origin: &WorkspaceInteractionOrigin,
+        cx: &gpui::App,
+    ) -> bool {
+        self.is_current_target(cx)
+            && self.surface_id == origin.surface_id
+            && self.interaction_generation == origin.generation
+            && self.request_context.as_ref() == Some(&origin.context)
+    }
+
+    pub(crate) fn shares_workspace(&self, origin: &WorkspaceInteractionOrigin) -> bool {
+        let Some(context) = &self.request_context else {
+            return false;
+        };
+        if context.target_device_id != origin.context.target_device_id {
+            return false;
+        }
+        let checkout = self
+            .effective_checkout_id
+            .as_ref()
+            .or(context.checkout_id.as_ref());
+        match (checkout, origin.checkout_id.as_ref()) {
+            (Some(a), Some(b)) => a == b,
+            _ => context.cwd == origin.context.cwd,
+        }
+    }
+
+    pub(crate) fn mutation_busy(&self) -> bool {
+        self.pending_mutation.is_some()
+    }
+
+    pub(crate) fn prepare_mutation(&mut self, intent: MutationIntent, cx: &mut Context<Self>) {
+        self.pending_mutation = Some(intent);
+        for (path, document) in &mut self.preview.documents {
+            if self.pending_mutation.as_ref().unwrap().affects(path) {
+                document.autosave_task = None;
+            }
+        }
+        self.mutation_error = None;
+        cx.notify();
+    }
+
+    pub(crate) fn mutation_has_save(&self) -> bool {
+        self.pending_mutation.as_ref().is_some_and(|intent| {
+            self.preview
+                .documents
+                .iter()
+                .any(|(path, doc)| intent.affects(path) && doc.pending_save.is_some())
+        })
+    }
+
+    pub(crate) fn hold_mutation(&mut self, path: Option<String>, cx: &mut Context<Self>) {
+        self.mutation_hold = path;
+        let paths = self.preview.documents.keys().cloned().collect::<Vec<_>>();
+        for path in paths {
+            if self.mutation_blocks_path(&path) {
+                self.preview.documents.get_mut(&path).unwrap().autosave_task = None;
+            } else {
+                self.schedule_autosave(path, cx);
+            }
+        }
+    }
+    pub(super) fn mutation_blocks_path(&self, path: &str) -> bool {
+        if self
+            .mutation_hold
+            .as_deref()
+            .is_some_and(|hold| contains_path(hold, path))
+        {
+            return true;
+        }
+        self.pending_mutation
+            .as_ref()
+            .is_some_and(|intent| intent.affects(path))
+    }
+
+    pub(crate) fn report_mutation_error(&mut self, message: String, cx: &mut Context<Self>) {
+        self.mutation_error = Some(message.into());
+        if let Some(rename) = self.tree_rename.as_mut() {
+            rename.submitted = false;
+        }
+        cx.notify();
+    }
+
+    pub(super) fn request_mutation(
+        &mut self,
+        path: &str,
+        destination: Option<String>,
+        cx: &mut Context<Self>,
+    ) {
+        if self.pending_mutation.is_some() {
+            return;
+        }
+        let Some(origin) = self.interaction_origin(cx) else {
+            return;
+        };
+        let Some(entry) = self.tree.node(path).map(|n| n.entry.clone()) else {
+            return;
+        };
+        let available = self.mutation_capabilities.is_some_and(|c| {
+            if destination.is_some() {
+                c.move_entry
+            } else {
+                c.delete_entry
+            }
+        });
+        if !available
+            || origin.checkout_id.is_none()
+            || entry.mutation_revision.is_none()
+            || entry.kind == WorkspaceEntryKind::Symlink
+        {
+            return;
+        }
+        cx.emit(FilesEvent::Mutate(MutationIntent {
+            operation_id: uuid::Uuid::new_v4().to_string(),
+            origin,
+            entry,
+            destination,
+        }));
+    }
+
+    pub(crate) fn finish_mutation(
+        &mut self,
+        intent: &MutationIntent,
+        result: &Result<WorkspaceMutationOutcome, String>,
+        cx: &mut Context<Self>,
+    ) {
+        if self.pending_mutation.as_ref().map(|p| &p.operation_id) != Some(&intent.operation_id) {
+            return;
+        }
+        // A semantic watch event is authoritative even if the RPC reply was lost.
+        let observed = self
+            .deferred_file_changes
+            .iter()
+            .flat_map(|frame| &frame.changes)
+            .find(|change| change.operation_id.as_deref() == Some(&intent.operation_id))
+            .cloned();
+        let observed_applied = observed.is_some();
+        if let Some(change) = observed {
+            self.apply_semantic_mutation(&change, None, true, cx);
+        }
+        match result {
+            Ok(WorkspaceMutationOutcome::Applied {
+                checkout_id,
+                change,
+                entry,
+                ..
+            }) if intent.origin.checkout_id.as_ref() == Some(checkout_id) => {
+                self.apply_semantic_mutation(change, entry.clone(), true, cx);
+            }
+            Ok(WorkspaceMutationOutcome::Rejected { message, .. }) | Err(message) => {
+                if !observed_applied {
+                    self.mutation_error = Some(message.clone().into());
+                }
+            }
+            _ => self.mutation_error = Some("Workspace changed before operation completed".into()),
+        }
+        if observed_applied || matches!(result, Ok(WorkspaceMutationOutcome::Applied { .. })) {
+            self.tree_rename = None;
+        } else if let Some(rename) = &mut self.tree_rename {
+            rename.submitted = false;
+        }
+        self.pending_mutation = None;
+        let frames = std::mem::take(&mut self.deferred_file_changes);
+        // Queued events may contain duplicate native remove/create pairs. After
+        // applying the semantic transition, reconcile rather than destroying state.
+        drop(frames);
+        self.loads.clear();
+        self.tree.invalidate_loads();
+        self.tree_list_generation = self.tree.generation();
+        self.refresh(cx);
+        self.reconcile_open_documents(cx);
+        let paths = self.preview.documents.keys().cloned().collect::<Vec<_>>();
+        for path in paths {
+            self.schedule_autosave(path, cx);
+        }
+        if !self.search_state.query.is_empty() {
+            self.search_state.query.clear();
+            self.on_search_edited(cx);
+        }
+        cx.notify();
+    }
+
+    pub(super) fn apply_semantic_mutation(
+        &mut self,
+        change: &zeron_proto::WorkspaceFileChange,
+        entry: Option<WorkspaceEntry>,
+        local: bool,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(id) = &change.operation_id {
+            if self.applied_mutations.contains(id) {
+                return;
+            }
+            self.applied_mutations.push_back(id.clone());
+            if self.applied_mutations.len() > 128 {
+                self.applied_mutations.pop_front();
+            }
+        }
+        self.loads.clear();
+        self.tree.invalidate_loads();
+        match change.kind {
+            zeron_proto::WorkspaceFileChangeKind::Renamed => {
+                if let Some(old) = &change.old_path {
+                    self.tree.relocate_subtree(old, &change.path, entry);
+                    let phases = if local {
+                        self.preview
+                            .documents
+                            .iter()
+                            .filter(|(p, _)| contains_path(old, p))
+                            .map(|(p, d)| {
+                                (
+                                    format!("{}{}", change.path, &p[old.len()..]),
+                                    d.phase.clone(),
+                                )
+                            })
+                            .collect::<Vec<_>>()
+                    } else {
+                        Vec::new()
+                    };
+                    for (old_path, new_path) in self.rename_documents(old, change.path.clone(), cx)
+                    {
+                        cx.emit(FilesEvent::FileRenamed { old_path, new_path });
+                    }
+                    for (path, phase) in phases {
+                        if let Some(doc) = self.preview.documents.get_mut(&path) {
+                            doc.phase = phase;
+                        }
+                    }
+                    if !self.presentation.is_editor() {
+                        self.tree.select(change.path.clone());
+                    }
+                }
+            }
+            zeron_proto::WorkspaceFileChangeKind::Removed => {
+                let rows = self.tree.visible_rows().to_vec();
+                let index = rows.iter().position(|r| r.path == change.path);
+                let next = index
+                    .and_then(|i| {
+                        rows[i + 1..]
+                            .iter()
+                            .chain(rows[..i].iter().rev())
+                            .find(|r| {
+                                matches!(r.kind, model::VisibleRowKind::Entry)
+                                    && !contains_path(&change.path, &r.path)
+                            })
+                    })
+                    .map(|r| r.path.clone());
+                self.tree.remove(&change.path);
+                self.mark_document_deleted(&change.path, cx);
+                if let Some(path) = next {
+                    self.tree.select(path);
+                }
+            }
+            _ => {}
+        }
+        self.invalidate_markdown_images(None, cx);
+        self.tree_list_generation = self.tree.generation();
+        self.sync_tree_list();
+        self.reveal_tree_selection();
+        cx.notify();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::document::{DocumentKey, DocumentPhase, FileDocument};
+    use super::*;
+    use gpui::{AppContext, TestAppContext};
+
+    #[gpui::test]
+    fn watch_before_lost_reply_still_remaps_the_dirty_buffer(cx: &mut TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        files.update_in(cx, |files, _, cx| {
+            let origin = files.interaction_origin(cx).unwrap();
+            let intent = MutationIntent {
+                operation_id: "observed".into(),
+                origin,
+                entry: files.tree.node("a.txt").unwrap().entry.clone(),
+                destination: Some("b.txt".into()),
+            };
+            let mut document = FileDocument::loading(DocumentKey {
+                chat_id: "chat".into(),
+                checkout_id: Some("checkout".into()),
+                path: "a.txt".into(),
+            });
+            document.phase = DocumentPhase::Ready;
+            document.revision = 4;
+            document.saved_revision = 1;
+            files.preview.documents.insert("a.txt".into(), document);
+            files.prepare_mutation(intent.clone(), cx);
+            let change = zeron_proto::WorkspaceFileChange {
+                operation_id: Some("observed".into()),
+                kind: zeron_proto::WorkspaceFileChangeKind::Renamed,
+                path: "b.txt".into(),
+                old_path: Some("a.txt".into()),
+            };
+            files.apply_workspace_changes(
+                zeron_proto::WorkspaceFileChanges {
+                    sequence: 2,
+                    resync_required: false,
+                    changes: vec![change],
+                },
+                cx,
+            );
+            assert!(files.preview.documents.contains_key("a.txt"));
+            files.apply_workspace_changes(
+                zeron_proto::WorkspaceFileChanges {
+                    sequence: 3,
+                    resync_required: false,
+                    changes: vec![],
+                },
+                cx,
+            );
+            files.finish_mutation(&intent, &Err("reply lost".into()), cx);
+            assert_eq!(files.watch_sequence, Some(3));
+            assert!(files.preview.documents["b.txt"].is_dirty());
+            assert_eq!(files.preview.documents["b.txt"].phase, DocumentPhase::Ready);
+            assert!(files.mutation_error.is_none());
+            assert!(!files.mutation_busy());
+        });
+    }
+    #[test]
+    fn path_membership_uses_component_boundaries() {
+        assert!(contains_path("a", "a/child"));
+        assert!(contains_path("a", "a"));
+        assert!(!contains_path("a", "ab/child"));
+    }
+
+    #[gpui::test]
+    fn confirmed_move_preserves_dirty_editor_and_duplicate_events_are_idempotent(
+        cx: &mut TestAppContext,
+    ) {
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(crate::theme::Theme::dark());
+        });
+        let window = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            FilesSurface::new_explorer(state, "chat".into(), false, cx)
+        });
+        window
+            .update(cx, |files, window, cx| {
+                let theme = crate::theme::Theme::of(cx).clone();
+                let editor = super::super::editor::new_file_editor(
+                    "unsaved text",
+                    "folder/a.txt",
+                    false,
+                    &theme,
+                    window,
+                    cx,
+                );
+                let mut doc = FileDocument::loading(DocumentKey {
+                    chat_id: "chat".into(),
+                    checkout_id: Some("checkout".into()),
+                    path: "folder/a.txt".into(),
+                });
+                doc.editor = Some(editor.clone());
+                doc.phase = DocumentPhase::Ready;
+                doc.revision = 3;
+                doc.saved_revision = 1;
+                files.preview.documents.insert("folder/a.txt".into(), doc);
+                let change = zeron_proto::WorkspaceFileChange {
+                    operation_id: Some("op".into()),
+                    kind: zeron_proto::WorkspaceFileChangeKind::Renamed,
+                    path: "other".into(),
+                    old_path: Some("folder".into()),
+                };
+                files.apply_semantic_mutation(&change, None, true, cx);
+                files.apply_semantic_mutation(&change, None, true, cx);
+                let doc = &files.preview.documents["other/a.txt"];
+                assert_eq!(doc.editor.as_ref(), Some(&editor));
+                assert_eq!(editor.read(cx).value().as_ref(), "unsaved text");
+                assert!(doc.is_dirty());
+                assert_eq!(doc.phase, DocumentPhase::Ready);
+                assert!(!files.preview.documents.contains_key("folder/a.txt"));
+                let removed = zeron_proto::WorkspaceFileChange {
+                    operation_id: Some("delete".into()),
+                    kind: zeron_proto::WorkspaceFileChangeKind::Removed,
+                    path: "other".into(),
+                    old_path: None,
+                };
+                files.apply_semantic_mutation(&removed, None, true, cx);
+                assert_eq!(
+                    files.preview.documents["other/a.txt"].phase,
+                    DocumentPhase::DeletedOnDisk
+                );
+                assert_eq!(editor.read(cx).value().as_ref(), "unsaved text");
+            })
+            .unwrap();
+    }
+}
diff --git a/crates/ui/src/files/preview.rs b/crates/ui/src/files/preview.rs
index 1538988207..a151ee1c01 100644
--- a/crates/ui/src/files/preview.rs
+++ b/crates/ui/src/files/preview.rs
@@ -97,7 +97,7 @@ enum ReloadDecision {
 
 pub(super) struct FilePreviewState {
     images_visible: bool,
-    documents: HashMap<String, FileDocument>,
+    pub(super) documents: HashMap<String, FileDocument>,
     document_recency: VecDeque<String>,
     active: Option<String>,
     highlights: HashMap<String, HighlightedFile>,
@@ -1483,7 +1483,10 @@ impl FilesSurface {
     }
 
     pub(super) fn schedule_autosave(&mut self, path: String, cx: &mut Context<Self>) {
-        if !self.preview.autosave_enabled || self.preview.autosave_paused_for_reload(&path) {
+        if self.mutation_blocks_path(&path)
+            || !self.preview.autosave_enabled
+            || self.preview.autosave_paused_for_reload(&path)
+        {
             return;
         }
         let delay = Duration::from_millis(self.preview.autosave_delay_ms);
@@ -1522,7 +1525,7 @@ impl FilesSurface {
     }
 
     pub(super) fn save_document(&mut self, path: String, cx: &mut Context<Self>) {
-        if self.target_change_pending {
+        if self.mutation_blocks_path(&path) || self.target_change_pending {
             return;
         }
         let Some(context) = self.request_context.clone() else {
@@ -1911,10 +1914,24 @@ impl FilesSurface {
             document.reconcile_task = None;
             document.pending_save = None;
             document.key.path = new_document_path.clone();
+            let was_markdown = super::markdown_preview::is_markdown(old_document_path);
+            let is_markdown = super::markdown_preview::is_markdown(new_document_path);
+            if was_markdown != is_markdown {
+                document.show_markdown = is_markdown;
+                if let Some(view) = document.markdown.take() {
+                    view.update(cx, |view, cx| view.suspend(cx));
+                }
+            }
             if let Some(file) = document.file.as_mut() {
                 file.path = new_document_path.clone();
             }
             if let Some(editor) = document.editor.clone() {
+                // Retarget the existing editor so selection and undo survive.
+                // Its previous adapter captures parsed spans for the old language.
+                editor.update(cx, |editor, cx| {
+                    editor.set_highlighter(new_document_path.clone(), cx);
+                    editor.set_highlighter_factory(Rc::new(|_| None), cx);
+                });
                 let event_path = new_document_path.clone();
                 document.editor_events =
                     Some(super::editor::subscribe_to_changes(&editor, event_path, cx));
@@ -1928,11 +1945,7 @@ impl FilesSurface {
             if self.editor_path.as_deref() == Some(old_document_path) {
                 self.editor_path = Some(new_document_path.clone());
             }
-            if let Some(highlight) = self.preview.highlights.remove(old_document_path) {
-                self.preview
-                    .highlights
-                    .insert(new_document_path.clone(), highlight);
-            }
+            self.preview.highlights.remove(old_document_path);
             if let Some(anchors) = self.preview.comment_anchors.remove(old_document_path) {
                 self.preview
                     .comment_anchors
@@ -1967,6 +1980,17 @@ impl FilesSurface {
                     .is_some_and(FileDocument::is_dirty)
             {
                 self.read_file(path.clone(), cx);
+            } else if let Some(document) = self.preview.documents.get(path) {
+                if let Some(editor) = &document.editor {
+                    let source = editor.read(cx).value().to_string();
+                    self.request_editor_highlight(path.clone(), source, document.revision, cx);
+                } else if let Some((text, hash)) = document
+                    .file
+                    .as_ref()
+                    .and_then(|file| file.text.clone().zip(file.content_hash.clone()))
+                {
+                    self.request_file_highlight(path.clone(), text, hash, cx);
+                }
             }
         }
         if !renames.is_empty() {
@@ -3336,6 +3360,142 @@ fn read_only_message(reason: Option<WorkspaceReadOnlyReason>) -> SharedString {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use gpui::TestAppContext;
+
+    #[gpui::test]
+    fn renaming_markdown_to_text_keeps_dirty_editor_and_undo(cx: &mut TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let editor = files.update_in(cx, |files, window, cx| {
+            let theme = Theme::of(cx).clone();
+            let editor = super::super::editor::new_file_editor(
+                "# Original",
+                "note.md",
+                false,
+                &theme,
+                window,
+                cx,
+            );
+            let mut document = cached_document("note.md", "# Original");
+            document.set_loaded(zeron_proto::WorkspaceFileText {
+                checkout_id: "checkout".into(),
+                path: "note.md".into(),
+                text: Some("# Original".into()),
+                content_hash: Some("saved-hash".into()),
+                size: 10,
+                modified_at: None,
+                encoding: zeron_proto::WorkspaceTextEncoding::Utf8,
+                line_ending: Some(zeron_proto::WorkspaceLineEnding::Lf),
+                read_only_reason: None,
+                truncated: false,
+            });
+            editor.update(cx, |editor, cx| {
+                editor.set_selected_range(10..10, cx);
+                editor.replace(" unsaved", window, cx);
+                editor.set_selected_range(2..10, cx);
+            });
+            document.editor = Some(editor.clone());
+            document.mark_user_edit();
+            files.preview.documents.insert("note.md".into(), document);
+            files.preview.active = Some("note.md".into());
+            files.editor_path = Some("note.md".into());
+            files.presentation = super::super::FilesPresentation::Editor;
+            assert!(
+                files
+                    .prepare_markdown_preview("note.md", Some(&editor), cx)
+                    .is_some()
+            );
+            files.apply_semantic_mutation(
+                &zeron_proto::WorkspaceFileChange {
+                    operation_id: Some("rename-md".into()),
+                    kind: zeron_proto::WorkspaceFileChangeKind::Renamed,
+                    path: "note.txt".into(),
+                    old_path: Some("note.md".into()),
+                },
+                None,
+                true,
+                cx,
+            );
+            let document = &files.preview.documents["note.txt"];
+            assert!(!document.show_markdown);
+            assert!(document.markdown.is_none());
+            assert!(document.is_dirty());
+            assert_eq!(document.phase, DocumentPhase::Ready);
+            assert_eq!(document.editor.as_ref(), Some(&editor));
+            assert_eq!(editor.read(cx).value().as_ref(), "# Original unsaved");
+            assert_eq!(editor.read(cx).selected_range(), 2..10);
+            assert_eq!(document.saved_hash.as_deref(), Some("saved-hash"));
+            assert!(
+                files
+                    .prepare_markdown_preview("note.txt", Some(&editor), cx)
+                    .is_none()
+            );
+            editor.update(cx, |editor, cx| editor.focus(window, cx));
+            editor
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| {
+            window.draw(cx).clear();
+            window.dispatch_action(Box::new(gpui_base::input::Undo), cx);
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            editor.read_with(cx, |editor, _| editor.value().to_string()),
+            "# Original"
+        );
+    }
+
+    #[gpui::test]
+    fn rename_refreshes_language_and_preserves_markdown_view_choice(cx: &mut TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        files.update_in(cx, |files, window, cx| {
+            let theme = Theme::of(cx).clone();
+            let editor = super::super::editor::new_file_editor(
+                "let value = 1;",
+                "note.txt",
+                false,
+                &theme,
+                window,
+                cx,
+            );
+            let mut document = cached_document("note.txt", "let value = 1;");
+            document.editor = Some(editor);
+            files.preview.documents.insert("note.txt".into(), document);
+            files.rename_documents("note.txt", "note.rs".into(), cx);
+        });
+        cx.run_until_parked();
+        cx.executor().advance_clock(Duration::from_millis(120));
+        cx.run_until_parked();
+        files.update_in(cx, |files, _, cx| {
+            let key = DocumentHighlightKey::new(
+                zeron_syntax::language_for_path("note.rs").unwrap(),
+                "let value = 1;",
+            );
+            assert!(
+                files.preview.syntax_cache.get(&key).is_some(),
+                "the open editor must be parsed in the new language without an edit"
+            );
+            files.rename_documents("note.rs", "note.md".into(), cx);
+            assert!(files.preview.documents["note.md"].show_markdown);
+            files
+                .preview
+                .documents
+                .get_mut("note.md")
+                .unwrap()
+                .show_markdown = false;
+            files.rename_documents("note.md", "renamed.md".into(), cx);
+            assert!(
+                !files.preview.documents["renamed.md"].show_markdown,
+                "renaming within Markdown must preserve the user's code view choice"
+            );
+            files.rename_documents("renamed.md", "renamed.txt".into(), cx);
+            assert!(
+                files.preview.documents["renamed.txt"]
+                    .highlight_task
+                    .is_none()
+            );
+            assert!(!files.preview.highlights.contains_key("renamed.txt"));
+        });
+    }
 
     /// A missing file gets its own wording — the transport's RPC framing
     /// never reaches the reader — while every other failure keeps its own.
diff --git a/crates/ui/src/files/rename.rs b/crates/ui/src/files/rename.rs
new file mode 100644
index 0000000000..df7c7b4daa
--- /dev/null
+++ b/crates/ui/src/files/rename.rs
@@ -0,0 +1,544 @@
+//! Inline single-line rename and permanent-delete confirmation.
+use super::*;
+use crate::{popover, theme::Theme};
+use gpui::{AnyElement, Focusable, KeyDownEvent, MouseButton};
+use gpui_base::input::{Input, InputEvent, InputState};
+
+pub(super) struct TreeRename {
+    pub path: String,
+    pub origin: mutations::WorkspaceInteractionOrigin,
+    pub input: Entity<InputState>,
+    pub submitted: bool,
+    revision: Option<String>,
+    _events: Subscription,
+}
+pub(super) struct TreeDelete {
+    pub path: String,
+    pub origin: mutations::WorkspaceInteractionOrigin,
+    pub focus: FocusHandle,
+    pub confirm_focused: bool,
+    revision: Option<String>,
+}
+
+pub(super) fn name_selection(name: &str, directory: bool) -> std::ops::Range<usize> {
+    let end = if directory {
+        name.len()
+    } else {
+        name.rfind('.').filter(|i| *i > 0).unwrap_or(name.len())
+    };
+    0..end
+}
+pub(super) fn renamed_path(path: &str, name: &str) -> Result<String, &'static str> {
+    if name.is_empty()
+        || name == "."
+        || name == ".."
+        || name.eq_ignore_ascii_case(".git")
+        || name.contains(['/', '\\', '\0', ':'])
+    {
+        return Err("Enter a single file name without path separators");
+    }
+    let parent = model::parent_path(path).unwrap_or_default();
+    Ok(if parent.is_empty() {
+        name.into()
+    } else {
+        format!("{parent}/{name}")
+    })
+}
+impl FilesSurface {
+    pub(super) fn can_mutate_tree_entry(&self, path: &str, deleting: bool, cx: &gpui::App) -> bool {
+        !self.mutation_busy()
+            && self.is_current_target(cx)
+            && self.effective_checkout_id.is_some()
+            && self.mutation_capabilities.is_some_and(|c| {
+                if deleting {
+                    c.delete_entry
+                } else {
+                    c.move_entry
+                }
+            })
+            && self.tree.node(path).is_some_and(|n| {
+                n.entry.mutation_revision.is_some()
+                    && n.entry.kind != zeron_proto::WorkspaceEntryKind::Symlink
+            })
+    }
+    pub(super) fn begin_tree_rename(
+        &mut self,
+        path: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if !self.can_mutate_tree_entry(&path, false, cx) {
+            return;
+        }
+        let Some(origin) = self.interaction_origin(cx) else {
+            return;
+        };
+        let entry = self.tree.node(&path).unwrap().entry.clone();
+        let input = cx.new(|cx| InputState::new(window, cx).default_value(entry.name.clone()));
+        input.update(cx, |state, cx| {
+            state.set_selected_range(
+                name_selection(
+                    &entry.name,
+                    entry.kind == zeron_proto::WorkspaceEntryKind::Directory,
+                ),
+                cx,
+            )
+        });
+        let events = cx.subscribe_in(&input, window, |this, _, event, window, cx| match event {
+            InputEvent::PressEnter { .. } => this.submit_tree_rename(window, cx),
+            InputEvent::Blur
+                if this
+                    .tree_rename
+                    .as_ref()
+                    .is_some_and(|rename| !rename.submitted) =>
+            {
+                this.tree_rename = None;
+                cx.notify();
+            }
+            _ => {}
+        });
+        let focus = input.focus_handle(cx);
+        self.tree.select(path.clone());
+        self.reveal_tree_selection();
+        self.mutation_error = None;
+        self.tree_rename = Some(TreeRename {
+            path,
+            origin,
+            input,
+            submitted: false,
+            revision: entry.mutation_revision,
+            _events: events,
+        });
+        window.focus(&focus, cx);
+        cx.notify();
+    }
+    fn submit_tree_rename(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(rename) = &self.tree_rename else {
+            return;
+        };
+        if rename.submitted {
+            return;
+        }
+        if !self.accepts_origin(&rename.origin, cx) {
+            self.tree_rename = None;
+            cx.notify();
+            return;
+        }
+        if self
+            .tree
+            .node(&rename.path)
+            .and_then(|node| node.entry.mutation_revision.as_ref())
+            != rename.revision.as_ref()
+        {
+            self.report_mutation_error("Entry changed; cancel and reopen Rename".into(), cx);
+            return;
+        }
+        let path = rename.path.clone();
+        let name = rename.input.read(cx).value().to_string();
+        let destination = match renamed_path(&path, &name) {
+            Ok(path) => path,
+            Err(message) => {
+                self.report_mutation_error(message.into(), cx);
+                return;
+            }
+        };
+        if path == destination {
+            self.tree_rename = None;
+            self.tree_focus.focus(window, cx);
+            cx.notify();
+            return;
+        }
+        self.tree_rename.as_mut().unwrap().submitted = true;
+        self.request_mutation(&path, Some(destination), cx);
+    }
+    pub(super) fn render_tree_rename(
+        &self,
+        path: &str,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        let rename = self
+            .tree_rename
+            .as_ref()
+            .filter(|rename| rename.path == path)?;
+        let theme = Theme::of(cx).clone();
+        // gpui-base's Input is unstyled: explicitly supply the same visible
+        // caret and selection colors as the file editor, including theme changes.
+        rename.input.update(cx, |input, _| {
+            input.set_editor_style(super::editor_adapter::editor_style(&theme));
+        });
+        Some(
+            div()
+                .id("tree-rename-input")
+                .debug_selector(|| "tree-rename-input".into())
+                .flex_1()
+                .min_w_0()
+                .h(px(23.))
+                .px(px(4.))
+                .flex()
+                .items_center()
+                .rounded(px(4.))
+                .border_1()
+                .border_color(theme.accent)
+                .bg(theme.input_glass_bg())
+                .font_family(theme.font_sans.clone())
+                .text_size(px(11.5))
+                .text_color(theme.text)
+                .cursor_text()
+                .occlude()
+                .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
+                .on_click(|_, _, cx| cx.stop_propagation())
+                .on_key_down(cx.listener(|this, event: &KeyDownEvent, window, cx| {
+                    if event.keystroke.key == "escape" {
+                        if this.tree_rename.as_ref().is_some_and(|r| !r.submitted) {
+                            this.tree_rename = None;
+                            this.tree_focus.focus(window, cx);
+                            cx.notify();
+                        }
+                        window.prevent_default();
+                        cx.stop_propagation();
+                    }
+                }))
+                .child(Input::new(&rename.input))
+                .into_any_element(),
+        )
+    }
+    pub(super) fn begin_tree_delete(
+        &mut self,
+        path: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if !self.can_mutate_tree_entry(&path, true, cx) {
+            return;
+        }
+        let Some(origin) = self.interaction_origin(cx) else {
+            return;
+        };
+        let focus = cx.focus_handle();
+        focus.focus(window, cx);
+        cx.emit(FilesEvent::HoldMutation {
+            origin: origin.clone(),
+            path: Some(path.clone()),
+        });
+        let revision = self
+            .tree
+            .node(&path)
+            .and_then(|node| node.entry.mutation_revision.clone());
+        self.tree_delete = Some(TreeDelete {
+            path,
+            origin,
+            focus,
+            confirm_focused: false,
+            revision,
+        });
+        cx.notify();
+    }
+    pub(super) fn dismiss_tree_delete(
+        &mut self,
+        confirm: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(dialog) = self.tree_delete.take() else {
+            return;
+        };
+        cx.emit(FilesEvent::HoldMutation {
+            origin: dialog.origin.clone(),
+            path: None,
+        });
+        if confirm && self.accepts_origin(&dialog.origin, cx) {
+            if self
+                .tree
+                .node(&dialog.path)
+                .and_then(|node| node.entry.mutation_revision.as_ref())
+                != dialog.revision.as_ref()
+            {
+                self.report_mutation_error(
+                    "Entry changed; reopen Delete to confirm its current contents".into(),
+                    cx,
+                );
+            } else {
+                self.request_mutation(&dialog.path, None, cx);
+            }
+        }
+        self.tree_focus.focus(window, cx);
+        cx.notify();
+    }
+    pub(super) fn render_tree_delete(
+        &self,
+        theme: &Theme,
+        window: &Window,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        let dialog = self.tree_delete.as_ref()?;
+        let theme = theme.for_popup();
+        let directory = self
+            .tree
+            .node(&dialog.path)
+            .is_some_and(|n| n.entry.kind == zeron_proto::WorkspaceEntryKind::Directory);
+        let name = dialog.path.rsplit('/').next().unwrap_or(&dialog.path);
+        let copy = format!(
+            "Permanently delete {}? {}Open editor buffers will be kept for recovery.",
+            name,
+            if directory {
+                "All current folder contents will be deleted. "
+            } else {
+                "This cannot be undone. "
+            }
+        );
+        let card = popover::dialog_card(&theme)
+            .w(px(380.))
+            .gap(px(12.))
+            .track_focus(&dialog.focus)
+            .on_key_down(cx.listener(|this, event: &KeyDownEvent, window, cx| {
+                match event.keystroke.key.as_str() {
+                    "escape" => this.dismiss_tree_delete(false, window, cx),
+                    "tab" | "left" | "right" => {
+                        if let Some(dialog) = this.tree_delete.as_mut() {
+                            dialog.confirm_focused = !dialog.confirm_focused;
+                            cx.notify();
+                        }
+                    }
+                    "enter" => {
+                        let confirm = this.tree_delete.as_ref().is_some_and(|d| d.confirm_focused);
+                        this.dismiss_tree_delete(confirm, window, cx);
+                    }
+                    _ => {}
+                }
+                window.prevent_default();
+                cx.stop_propagation();
+            }))
+            .child(popover::dialog_title(&theme, "Delete permanently?"))
+            .child(popover::dialog_body(&theme, copy))
+            .child(
+                div()
+                    .flex()
+                    .justify_end()
+                    .gap(px(8.))
+                    .child(
+                        popover::btn_ghost(&theme, "Cancel", "tree-delete-cancel")
+                            .id("tree-delete-cancel")
+                            .role(gpui::Role::Button)
+                            .aria_label("Cancel")
+                            .when(!dialog.confirm_focused, |el| {
+                                el.bg(crate::theme::wash(0.12))
+                            })
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                this.dismiss_tree_delete(false, window, cx)
+                            })),
+                    )
+                    .child(
+                        popover::btn_danger(&theme, "Delete")
+                            .id("tree-delete-confirm")
+                            .role(gpui::Role::Button)
+                            .aria_label("Delete")
+                            .when(dialog.confirm_focused, |el| {
+                                el.border_1().border_color(theme.text)
+                            })
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                this.dismiss_tree_delete(true, window, cx)
+                            })),
+                    ),
+            );
+        Some(popover::modal(
+            "tree-delete-dialog",
+            window.viewport_size(),
+            card.into_any_element(),
+        ))
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[gpui::test]
+    fn rename_input_keeps_focus_and_supports_caret_editing(cx: &mut gpui::TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        files.update_in(cx, |files, window, cx| {
+            files.tree.select("a.txt");
+            files.tree_focus.focus(window, cx);
+        });
+        cx.simulate_keystrokes("f2");
+        let input = files.read_with(cx, |files, _| {
+            files.tree_rename.as_ref().unwrap().input.clone()
+        });
+        assert_eq!(input.read_with(cx, |input, _| input.selected_range()), 0..1);
+        cx.simulate_keystrokes("right");
+        assert_eq!(input.read_with(cx, |input, _| input.selected_range()), 1..1);
+        cx.simulate_input("b");
+        assert_eq!(
+            input.read_with(cx, |input, _| input.value().to_string()),
+            "ab.txt"
+        );
+
+        let bounds = cx.debug_bounds("tree-rename-input").unwrap();
+        cx.simulate_click(bounds.center(), gpui::Modifiers::default());
+        files.update_in(cx, |files, window, cx| {
+            assert!(
+                files.tree_rename.is_some(),
+                "clicking the field must not activate its tree row"
+            );
+            assert!(input.focus_handle(cx).is_focused(window));
+            assert!(!files.tree_focus.is_focused(window));
+        });
+        for theme in [Theme::dark(), Theme::light()] {
+            cx.update(|window, cx| {
+                cx.set_global(theme);
+                window.refresh();
+                window.draw(cx).clear();
+            });
+            input.read_with(cx, |input, _| {
+                let (caret, _) = input.cursor_layout().expect("rename must lay out a caret");
+                assert!(caret.size.width > px(0.));
+                assert!(caret.size.height > px(0.));
+                assert!(caret.left() >= bounds.left());
+                assert!(caret.right() <= bounds.right());
+                assert!(caret.top() >= bounds.top());
+                assert!(caret.bottom() <= bounds.bottom());
+            });
+        }
+        cx.simulate_keystrokes("escape");
+        files.update_in(cx, |files, window, _| {
+            assert!(files.tree_rename.is_none());
+            assert!(files.tree_focus.is_focused(window));
+        });
+        cx.run_until_parked();
+        assert!(
+            !events
+                .borrow()
+                .iter()
+                .any(|event| matches!(event, FilesEvent::OpenFile(_) | FilesEvent::Mutate(_)))
+        );
+
+        cx.simulate_keystrokes("f2");
+        cx.simulate_input("résumé");
+        cx.simulate_keystrokes("enter");
+        cx.run_until_parked();
+        let events = events.borrow();
+        let intents = events
+            .iter()
+            .filter_map(|event| match event {
+                FilesEvent::Mutate(intent) => Some(intent),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(intents.len(), 1);
+        assert_eq!(intents[0].destination.as_deref(), Some("résumé.txt"));
+    }
+
+    #[gpui::test]
+    fn refreshed_revision_does_not_authorize_an_already_open_confirmation(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        files.update_in(cx, |files, window, cx| {
+            files.begin_tree_delete("a.txt".into(), window, cx);
+            files.begin_tree_rename("a.txt".into(), window, cx);
+            let input = files.tree_rename.as_ref().unwrap().input.clone();
+            input.update(cx, |input, cx| input.set_value("renamed.txt", window, cx));
+            let mut entry =
+                super::super::test_support::entry("a.txt", zeron_proto::WorkspaceEntryKind::File);
+            entry.mutation_revision = Some("external-edit".into());
+            files.tree.apply_page(
+                zeron_proto::WorkspaceDirectoryPage {
+                    directory: "".into(),
+                    checkout_id: Some("checkout".into()),
+                    mutation_capabilities: files.mutation_capabilities,
+                    entries: vec![entry],
+                    next_cursor: None,
+                    truncated: false,
+                },
+                files.tree.generation(),
+            );
+            files.submit_tree_rename(window, cx);
+            assert!(!files.tree_rename.as_ref().unwrap().submitted);
+            assert!(
+                files
+                    .mutation_error
+                    .as_ref()
+                    .unwrap()
+                    .contains("Entry changed")
+            );
+            files.dismiss_tree_delete(true, window, cx);
+            assert!(
+                files
+                    .mutation_error
+                    .as_ref()
+                    .unwrap()
+                    .contains("Entry changed")
+            );
+        });
+        cx.run_until_parked();
+        assert!(
+            !events
+                .borrow()
+                .iter()
+                .any(|event| matches!(event, FilesEvent::Mutate(_)))
+        );
+    }
+
+    #[gpui::test]
+    fn inline_rename_submits_once_and_cancel_delete_never_mutates(cx: &mut gpui::TestAppContext) {
+        let (files, cx) = super::super::test_support::setup(cx);
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        files.update_in(cx, |files, window, cx| {
+            files.begin_tree_rename("a.txt".into(), window, cx);
+            let input = files.tree_rename.as_ref().unwrap().input.clone();
+            input.update(cx, |input, cx| input.set_value("new.txt", window, cx));
+            files.submit_tree_rename(window, cx);
+            files.submit_tree_rename(window, cx);
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            events
+                .borrow()
+                .iter()
+                .filter(|event| matches!(event, FilesEvent::Mutate(_)))
+                .count(),
+            1
+        );
+        events.borrow_mut().clear();
+        files.update_in(cx, |files, window, cx| {
+            files.tree_rename = None;
+            files.begin_tree_delete("folder".into(), window, cx);
+            assert!(!files.tree_delete.as_ref().unwrap().confirm_focused);
+            files.dismiss_tree_delete(false, window, cx);
+        });
+        cx.run_until_parked();
+        assert!(
+            !events
+                .borrow()
+                .iter()
+                .any(|event| matches!(event, FilesEvent::Mutate(_)))
+        );
+    }
+    #[test]
+    fn rename_preserves_parent_and_selects_only_basename() {
+        assert_eq!(renamed_path("src/a.txt", "é.txt").unwrap(), "src/é.txt");
+        for invalid in ["", ".", "..", "../a", "a/b", ".git", "a\\b"] {
+            assert!(renamed_path("src/a", invalid).is_err());
+        }
+        assert_eq!(name_selection("foo.test.ts", false), 0..8);
+        assert_eq!(name_selection(".gitignore", false), 0..10);
+        assert_eq!(name_selection("foo.ts", true), 0..6);
+    }
+}
diff --git a/crates/ui/src/files/search.rs b/crates/ui/src/files/search.rs
index c17905d723..20a0ffbfe9 100644
--- a/crates/ui/src/files/search.rs
+++ b/crates/ui/src/files/search.rs
@@ -610,7 +610,11 @@ impl FilesSurface {
         let is_directory = row.kind == WorkspaceEntryKind::Directory;
         let decoration = self.git_decoration(&row.path, is_directory, cx);
         let padding = 8.0 + row.depth as f32 * super::tree::TREE_INDENT;
-        let drag_payload = WorkspacePathDrag::new(row.path.clone(), is_directory);
+        let drag_payload = WorkspacePathDrag::new(row.path.clone(), is_directory).with_origin(
+            self.interaction_origin(cx),
+            super::WorkspacePathSource::Search,
+            None,
+        );
         let content = div()
             .id(("files-search-result", index))
             .role(gpui::Role::TreeItem)
diff --git a/crates/ui/src/files/test_support.rs b/crates/ui/src/files/test_support.rs
new file mode 100644
index 0000000000..b4c60ac2f4
--- /dev/null
+++ b/crates/ui/src/files/test_support.rs
@@ -0,0 +1,70 @@
+use super::*;
+use gpui::{AppContext, TestAppContext, VisualTestContext};
+use zeron_proto::{WorkspaceDirectoryPage, WorkspaceEntry, WorkspaceEntryKind};
+
+pub(crate) fn state() -> AppState {
+    let mut state = AppState::new();
+    state.local_device_id = Some("device".into());
+    state.chats.push(
+        serde_json::from_value(serde_json::json!({
+            "id":"chat", "deviceId":"device", "archived":false, "cwd":"/workspace",
+            "checkoutId":"checkout", "createdAt":"2026-01-01T00:00:00Z"
+        }))
+        .unwrap(),
+    );
+    state
+}
+
+pub(crate) fn explorer(state: Entity<AppState>, cx: &mut Context<FilesSurface>) -> FilesSurface {
+    let mut files = FilesSurface::new_explorer(state, "chat".into(), false, cx);
+    files.effective_checkout_id = Some("checkout".into());
+    files.mutation_capabilities = Some(zeron_proto::WorkspaceMutationCapabilities {
+        move_entry: true,
+        delete_entry: true,
+    });
+    files.tree.begin_load("", None, files.tree.generation());
+    files.tree.apply_page(
+        WorkspaceDirectoryPage {
+            directory: "".into(),
+            checkout_id: Some("checkout".into()),
+            mutation_capabilities: files.mutation_capabilities,
+            entries: vec![
+                entry("a.txt", WorkspaceEntryKind::File),
+                entry("folder", WorkspaceEntryKind::Directory),
+            ],
+            next_cursor: None,
+            truncated: false,
+        },
+        files.tree.generation(),
+    );
+    files.sync_tree_list();
+    files
+}
+
+pub(super) fn setup(cx: &mut TestAppContext) -> (Entity<FilesSurface>, &mut VisualTestContext) {
+    cx.update(|cx| {
+        gpui_base::init(cx);
+        cx.set_global(crate::theme::Theme::dark());
+    });
+    let (files, cx) = cx.add_window_view(|_, cx| {
+        let state = cx.new(|_| state());
+        explorer(state, cx)
+    });
+    cx.update(|window, cx| {
+        window.activate_window();
+        window.draw(cx).clear();
+    });
+    (files, cx)
+}
+pub(super) fn entry(path: &str, kind: WorkspaceEntryKind) -> WorkspaceEntry {
+    WorkspaceEntry {
+        path: path.into(),
+        name: path.rsplit('/').next().unwrap().into(),
+        kind,
+        size: Some(1),
+        modified_at: None,
+        ignored: false,
+        read_only: false,
+        mutation_revision: Some("rev".into()),
+    }
+}
diff --git a/crates/ui/src/files/tree.rs b/crates/ui/src/files/tree.rs
index a6c92749a9..8c87d7a7ad 100644
--- a/crates/ui/src/files/tree.rs
+++ b/crates/ui/src/files/tree.rs
@@ -173,6 +173,7 @@ impl FilesSurface {
     }
 
     pub(super) fn on_tree_scrolled(&mut self, cx: &mut Context<Self>) {
+        self.close_tree_context_menu(cx);
         // The list repaints itself; the floating rail needs a view pass.
         cx.notify();
     }
@@ -186,8 +187,13 @@ impl FilesSurface {
     pub(super) fn render_tree(&mut self, cx: &mut Context<Self>) -> AnyElement {
         let theme = Theme::of(cx).clone();
         let scrollbar = popover::rail(self, "files-tree-scrollbar", &theme, cx);
+        self.reset_tree_drop_rows();
+        let root_target = self.render_tree_root_target(cx);
         div()
             .id("files-tree")
+            .debug_selector(|| "files-tree".into())
+            .on_drag_move::<WorkspacePathDrag>(cx.listener(Self::on_tree_drag_move))
+            .on_drop::<WorkspacePathDrag>(cx.listener(Self::on_tree_drop))
             .role(gpui::Role::Tree)
             .aria_label("Workspace file tree")
             .relative()
@@ -204,6 +210,7 @@ impl FilesSurface {
             .on_key_down(cx.listener(|this, event: &KeyDownEvent, window, cx| {
                 this.on_tree_key_down(event, window, cx)
             }))
+            .child(root_target)
             .child({
                 // The sidebar's overflow treatment: rows fade under the top
                 // and bottom edges while there is more to scroll to, read
@@ -235,17 +242,34 @@ impl FilesSurface {
         };
         let theme = Theme::of(cx).clone();
         let padding = 8.0 + row.depth as f32 * TREE_INDENT;
+        let drop_key = row.path.clone();
+        let drop_target = match &row.kind {
+            VisibleRowKind::Entry => Some(row.path.clone()),
+            VisibleRowKind::Empty { directory } => Some(directory.clone()),
+            _ => None,
+        };
         let content = match row.kind {
             VisibleRowKind::Entry => {
                 let Some(node) = self.tree.node(&row.path).cloned() else {
                     return gpui::Empty.into_any_element();
                 };
                 let path = row.path.clone();
+                let menu_path = path.clone();
                 let selected = self.tree.selected() == Some(path.as_str());
                 let focused = self.tree_focus.is_focused(window);
                 let is_directory = node.entry.kind == WorkspaceEntryKind::Directory;
                 let decoration = self.git_decoration(&row.path, is_directory, cx);
-                let drag_payload = WorkspacePathDrag::new(path.clone(), is_directory);
+                let drag_payload = WorkspacePathDrag::new(path.clone(), is_directory).with_origin(
+                    self.interaction_origin(cx),
+                    super::WorkspacePathSource::Tree,
+                    node.entry.mutation_revision.clone(),
+                );
+                let drag_owner = cx.weak_entity();
+                let renaming = self
+                    .tree_rename
+                    .as_ref()
+                    .is_some_and(|rename| rename.path == path);
+                let rename_element = self.render_tree_rename(&path, cx);
                 let expanded = is_directory && self.tree.is_expanded(&path);
                 let text_color = if let Some(decoration) = decoration {
                     decoration.color(&theme)
@@ -268,6 +292,14 @@ impl FilesSurface {
                     )))
                     .role(gpui::Role::TreeItem)
                     .aria_label(node.entry.name.clone())
+                    .debug_selector({
+                        let path = row.path.clone();
+                        move || format!("tree-entry:{path}")
+                    })
+                    .when(
+                        is_directory && self.tree_drag.destination.as_deref() == Some(&path),
+                        |el| el.bg(crate::theme::wash(0.18)),
+                    )
                     .aria_selected(selected)
                     .when(is_directory, |element| element.aria_expanded(expanded))
                     .h(px(TREE_ROW_HEIGHT))
@@ -292,9 +324,26 @@ impl FilesSurface {
                         this.tree_focus.focus(window, cx);
                         this.activate_tree_path(path.clone(), cx);
                     }))
-                    .on_drag(drag_payload, |payload, _, _, cx| {
-                        cx.stop_propagation();
-                        workspace_path_drag_ghost(payload, cx)
+                    .on_mouse_down(
+                        MouseButton::Right,
+                        cx.listener(move |this, event: &gpui::MouseDownEvent, window, cx| {
+                            cx.stop_propagation();
+                            window.prevent_default();
+                            this.open_tree_context_menu(
+                                menu_path.clone(),
+                                event.position,
+                                window,
+                                cx,
+                            );
+                        }),
+                    )
+                    .when(!renaming, |element| {
+                        element.on_drag(drag_payload, move |payload, _, _, cx| {
+                            let _ = drag_owner
+                                .update(cx, |files, cx| files.close_tree_context_menu(cx));
+                            cx.stop_propagation();
+                            workspace_path_drag_ghost(payload, cx)
+                        })
                     })
                     .child(
                         div()
@@ -320,15 +369,16 @@ impl FilesSurface {
                             .size(px(14.0))
                             .flex_none(),
                     )
-                    .child(
+                    .child(rename_element.unwrap_or_else(|| {
                         div()
                             .min_w_0()
                             .truncate()
                             .font_family(theme.font_sans.clone())
                             .text_size(px(11.5))
                             .text_color(text_color)
-                            .child(node.entry.name),
-                    )
+                            .child(node.entry.name)
+                            .into_any_element()
+                    }))
                     .into_any_element()
             }
             VisibleRowKind::Loading { .. } => status_row(
@@ -398,7 +448,12 @@ impl FilesSurface {
                 )
                 .into_any_element(),
         };
-        with_indent_guides(content, row.depth, TREE_ROW_HEIGHT, &theme)
+        self.track_tree_drop_row(
+            drop_key,
+            drop_target,
+            TREE_ROW_HEIGHT,
+            with_indent_guides(content, row.depth, TREE_ROW_HEIGHT, &theme),
+        )
     }
 
     pub(super) fn activate_tree_path(&mut self, path: String, cx: &mut Context<Self>) {
@@ -439,6 +494,47 @@ impl FilesSurface {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
+        // Leave text input and editing shortcuts to the inline field. Stopping
+        // printable keys here would also prevent the platform's text insertion.
+        if self.tree_rename.is_some() {
+            return;
+        }
+        if event.keystroke.key == "escape" && cx.has_active_drag() {
+            cx.stop_active_drag(window);
+            self.clear_tree_drag(window, cx);
+            cx.stop_propagation();
+            return;
+        }
+        if self.tree_menu_key(event, window, cx) {
+            return;
+        }
+        if event.keystroke.key == "menu"
+            || (event.keystroke.key == "f10" && event.keystroke.modifiers.shift)
+        {
+            if let Some(path) = self.tree.selected().map(str::to_string) {
+                self.open_tree_context_menu(
+                    path,
+                    self.tree_list.viewport_bounds().origin,
+                    window,
+                    cx,
+                );
+            }
+            window.prevent_default();
+            cx.stop_propagation();
+            return;
+        }
+        if matches!(event.keystroke.key.as_str(), "f2" | "delete") {
+            if let Some(path) = self.tree.selected().map(str::to_string) {
+                if event.keystroke.key == "f2" {
+                    self.begin_tree_rename(path, window, cx);
+                } else {
+                    self.begin_tree_delete(path, window, cx);
+                }
+            }
+            window.prevent_default();
+            cx.stop_propagation();
+            return;
+        }
         let handled = match event.keystroke.key.as_str() {
             "up" => {
                 self.tree.select_previous();
diff --git a/crates/ui/src/files/watch.rs b/crates/ui/src/files/watch.rs
index acbdedce71..06ea0dd3f4 100644
--- a/crates/ui/src/files/watch.rs
+++ b/crates/ui/src/files/watch.rs
@@ -71,8 +71,36 @@ impl FilesSurface {
         }));
     }
 
-    fn apply_workspace_changes(&mut self, frame: WorkspaceFileChanges, cx: &mut Context<Self>) {
-        let gap = sequence_needs_resync(self.watch_sequence, frame.sequence);
+    pub(super) fn apply_workspace_changes(
+        &mut self,
+        mut frame: WorkspaceFileChanges,
+        cx: &mut Context<Self>,
+    ) {
+        if self.pending_mutation.is_some() {
+            // Defer affected events; unrelated changes still flow through. Keep
+            // sequence accounting on the live stream, not the deferred fragments.
+            let intent = self.pending_mutation.as_ref().unwrap();
+            let (affected, independent): (Vec<_>, Vec<_>) =
+                frame.changes.into_iter().partition(|change| {
+                    intent.affects(&change.path)
+                        || change
+                            .old_path
+                            .as_deref()
+                            .is_some_and(|old| intent.affects(old))
+                });
+            if !affected.is_empty() || frame.resync_required {
+                self.deferred_file_changes.push(WorkspaceFileChanges {
+                    sequence: frame.sequence,
+                    resync_required: frame.resync_required,
+                    changes: affected,
+                });
+            }
+            frame.changes = independent;
+            frame.resync_required = false;
+        }
+
+        let gap = self.pending_mutation.is_none()
+            && sequence_needs_resync(self.watch_sequence, frame.sequence);
         tracing::trace!(
             sequence = frame.sequence,
             previous_sequence = ?self.watch_sequence,
@@ -91,6 +119,16 @@ impl FilesSurface {
 
         let mut parents = HashSet::new();
         for change in frame.changes {
+            if change.operation_id.is_some() {
+                self.apply_semantic_mutation(&change, None, false, cx);
+                if let Some(parent) = parent_path(&change.path) {
+                    parents.insert(parent);
+                }
+                if let Some(old) = change.old_path.as_deref().and_then(parent_path) {
+                    parents.insert(old);
+                }
+                continue;
+            }
             self.invalidate_markdown_images(Some(&change.path), cx);
             if let Some(old_path) = &change.old_path {
                 self.invalidate_markdown_images(Some(old_path), cx);
@@ -103,6 +141,11 @@ impl FilesSurface {
                     }
                 }
                 WorkspaceFileChangeKind::Modified => {
+                    // Saves (including atomic replacement) change the metadata
+                    // revision used by move/delete, even when the name is unchanged.
+                    if let Some(parent) = parent_path(&change.path) {
+                        parents.insert(parent);
+                    }
                     self.reconcile_document(change.path, cx);
                 }
                 WorkspaceFileChangeKind::Removed => {
@@ -114,7 +157,7 @@ impl FilesSurface {
                 }
                 WorkspaceFileChangeKind::Renamed => {
                     if let Some(old_path) = change.old_path {
-                        self.tree.remove(&old_path);
+                        self.tree.relocate_subtree(&old_path, &change.path, None);
                         for (old_path, new_path) in
                             self.rename_documents(&old_path, change.path.clone(), cx)
                         {
@@ -160,6 +203,116 @@ pub(super) fn sequence_needs_resync(previous: Option<u64>, next: u64) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use gpui::AppContext;
+
+    #[gpui::test]
+    fn completed_save_refreshes_revision_before_the_next_mutation(cx: &mut gpui::TestAppContext) {
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        let _guard = runtime.enter();
+        let (out, mut requests) = tokio::sync::mpsc::channel(16);
+        let (replies, inbound) = tokio::sync::mpsc::channel(16);
+        let engine =
+            crate::state::EngineHandle::from_test_client(zeron_rpc::RpcClient::new(out, inbound));
+        let state = cx.new(|_| {
+            let mut state = super::super::test_support::state();
+            state.set_test_engine(engine);
+            state
+        });
+        let files = cx.new(|cx| super::super::test_support::explorer(state, cx));
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        files.update(cx, |files, cx| {
+            files.apply_workspace_changes(
+                WorkspaceFileChanges {
+                    sequence: 1,
+                    resync_required: false,
+                    changes: vec![zeron_proto::WorkspaceFileChange {
+                        operation_id: None,
+                        kind: WorkspaceFileChangeKind::Modified,
+                        path: "a.txt".into(),
+                        old_path: None,
+                    }],
+                },
+                cx,
+            );
+        });
+        cx.run_until_parked();
+        let request: serde_json::Value = serde_json::from_str(
+            &requests
+                .try_recv()
+                .expect("Modified must reload the containing directory"),
+        )
+        .unwrap();
+        assert_eq!(
+            request["method"],
+            zeron_rpc::methods::LIST_WORKSPACE_DIRECTORY
+        );
+        assert_eq!(request["params"]["directory"], "");
+        let mut entry =
+            super::super::test_support::entry("a.txt", zeron_proto::WorkspaceEntryKind::File);
+        entry.mutation_revision = Some("after-save".into());
+        runtime.block_on(async {
+            replies
+                .send(
+                    serde_json::json!({
+                        "id": request["id"], "ok": {
+                            "directory": "", "checkoutId": "checkout",
+                            "mutationCapabilities": {"moveEntry": true, "deleteEntry": true},
+                            "entries": [entry], "nextCursor": null, "truncated": false
+                        }
+                    })
+                    .to_string(),
+                )
+                .await
+                .unwrap();
+            tokio::time::timeout(Duration::from_secs(1), async {
+                while replies.capacity() < replies.max_capacity() {
+                    tokio::task::yield_now().await;
+                }
+            })
+            .await
+            .unwrap();
+        });
+        cx.run_until_parked();
+        files.update(cx, |files, cx| {
+            assert_eq!(
+                files
+                    .tree
+                    .node("a.txt")
+                    .unwrap()
+                    .entry
+                    .mutation_revision
+                    .as_deref(),
+                Some("after-save")
+            );
+            files.request_mutation("a.txt", Some("renamed.txt".into()), cx);
+            files.request_mutation("a.txt", Some("folder/a.txt".into()), cx);
+            files.request_mutation("a.txt", None, cx);
+        });
+        cx.run_until_parked();
+        let events = events.borrow();
+        let intents = events
+            .iter()
+            .filter_map(|event| match event {
+                FilesEvent::Mutate(intent) => Some(intent),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(intents.len(), 3);
+        assert!(
+            intents
+                .iter()
+                .all(|intent| intent.entry.mutation_revision.as_deref() == Some("after-save"))
+        );
+    }
 
     #[test]
     fn sequence_gaps_require_resync() {
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index 4753a7b604..46b26e3024 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -63,6 +63,7 @@ mod chat_dropzone;
 #[cfg(test)]
 mod chat_dropzone_tests;
 mod command_palette;
+mod file_mutations;
 mod files_panel;
 mod harness_updates;
 mod navigation_focus;
@@ -3100,10 +3101,43 @@ impl Shell {
             .collect()
     }
 
+    /// Attach a workspace path only while the surface it came from still
+    /// shows this chat's workspace; a drag outliving a session switch is dropped.
+    fn attach_workspace_drag(
+        &mut self,
+        payload: &WorkspacePathDrag,
+        composer: &Entity<Composer>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(origin) = &payload.origin else {
+            return;
+        };
+        let current = crate::files::client::FilesRequestContext::for_chat(
+            self.state.read(cx),
+            &self.panel_key(cx),
+        );
+        if current.as_ref() != Some(&origin.context) || !matches!(self.route, Route::Chat) {
+            return;
+        }
+        let valid = self
+            .files
+            .values()
+            .chain(self.file_surfaces.values())
+            .any(|files| {
+                files.entity_id() == origin.surface_id && files.read(cx).accepts_origin(origin, cx)
+            });
+        if valid {
+            composer.update(cx, |composer, cx| {
+                composer.add_workspace_path(&payload.path, payload.is_directory, window, cx)
+            });
+        }
+    }
+
     fn workspace_path_for_surface(
         &self,
         surface: RightSurface,
-        _cx: &App,
+        cx: &App,
     ) -> Option<WorkspacePathDrag> {
         let path = match surface {
             RightSurface::File(id) => self.file_surface_paths.get(&id)?.clone(),
@@ -3116,7 +3150,15 @@ impl Shell {
                 return None;
             }
         };
-        Some(WorkspacePathDrag::new(path, false))
+        let RightSurface::File(id) = surface else {
+            return None;
+        };
+        let origin = self.file_surfaces.get(&id)?.read(cx).interaction_origin(cx);
+        Some(WorkspacePathDrag::new(path, false).with_origin(
+            origin,
+            crate::files::WorkspacePathSource::FileTab,
+            None,
+        ))
     }
 
     /// Drag-reorder a surface tab within this chat's strip.
@@ -3537,6 +3579,35 @@ impl Shell {
                     return;
                 }
                 match event {
+                    FilesEvent::HoldMutation { origin, path } => {
+                        let surfaces = this
+                            .files
+                            .values()
+                            .chain(this.file_surfaces.values())
+                            .filter(|s| s.read(cx).shares_workspace(origin))
+                            .cloned()
+                            .collect::<Vec<_>>();
+                        for surface in surfaces {
+                            surface.update(cx, |files, cx| files.hold_mutation(path.clone(), cx));
+                        }
+                    }
+                    FilesEvent::AddToChat {
+                        path,
+                        is_directory,
+                        origin,
+                    } => {
+                        let payload = WorkspacePathDrag::new(path.clone(), *is_directory)
+                            .with_origin(
+                                Some(origin.clone()),
+                                crate::files::WorkspacePathSource::Tree,
+                                None,
+                            );
+                        let composer = this.composer.clone();
+                        this.attach_workspace_drag(&payload, &composer, window, cx);
+                    }
+                    FilesEvent::Mutate(intent) => {
+                        this.start_file_mutation(source.clone(), intent.clone(), cx)
+                    }
                     // Navigation from an editor stays in its own chat.
                     FilesEvent::OpenFile(path) => {
                         let owner = (source.read(cx).chat_id().to_owned(), owner_state.clone());
@@ -10013,6 +10084,7 @@ impl Shell {
         };
         let status = self.render_status_strip(composer_width, cx);
         self.chat_dropzone("chat-dropzone", self.composer.clone(), cx)
+            .debug_selector(|| "chat-dropzone".into())
             .track_focus(&self.navigation_focus.main)
             .capture_any_mouse_down(cx.listener(|this, _, window, cx| {
                 this.capture_navigation_focus(false, false, window, cx);
@@ -12071,6 +12143,18 @@ fn header_icon_button(
 
 impl Render for Shell {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let active_files_key = self.panel_key(cx);
+        let hidden_explorers = self
+            .files
+            .iter()
+            .filter(|(key, _)| {
+                key.as_str() != active_files_key || !matches!(self.route, Route::Chat)
+            })
+            .map(|(_, files)| files.clone())
+            .collect::<Vec<_>>();
+        for files in hidden_explorers {
+            files.update(cx, |files, cx| files.suspend_tree_interactions(cx));
+        }
         settings::wallpaper::preload(cx);
         self.navigation_focus
             .remember(&self.shortcut_focus, window, cx);
diff --git a/crates/ui/src/shell/chat_dropzone.rs b/crates/ui/src/shell/chat_dropzone.rs
index 33216b4647..65c924156e 100644
--- a/crates/ui/src/shell/chat_dropzone.rs
+++ b/crates/ui/src/shell/chat_dropzone.rs
@@ -21,21 +21,19 @@ impl Shell {
                 cx.notify();
             }))
             .on_drop::<WorkspacePathDrag>(cx.listener(
-                move |_, payload: &WorkspacePathDrag, window, cx| {
-                    workspace.update(cx, |composer, cx| {
-                        composer.add_workspace_path(&payload.path, payload.is_directory, window, cx)
-                    });
+                move |this, payload: &WorkspacePathDrag, window, cx| {
+                    this.attach_workspace_drag(payload, &workspace, window, cx);
+                    cx.notify();
+                },
+            ))
+            .on_drop::<RightTabDrag>(cx.listener(
+                move |this, payload: &RightTabDrag, window, cx| {
+                    if let Some(path) = &payload.workspace_path {
+                        this.attach_workspace_drag(path, &composer, window, cx);
+                    }
                     cx.notify();
                 },
             ))
-            .on_drop::<RightTabDrag>(cx.listener(move |_, payload: &RightTabDrag, window, cx| {
-                if let Some(path) = &payload.workspace_path {
-                    composer.update(cx, |composer, cx| {
-                        composer.add_workspace_path(&path.path, path.is_directory, window, cx)
-                    });
-                }
-                cx.notify();
-            }))
     }
 
     pub(super) fn attachment_drop_overlay(theme: &Theme) -> gpui::Stateful<gpui::Div> {
diff --git a/crates/ui/src/shell/chat_dropzone_tests.rs b/crates/ui/src/shell/chat_dropzone_tests.rs
index 5b77466253..4240bc7977 100644
--- a/crates/ui/src/shell/chat_dropzone_tests.rs
+++ b/crates/ui/src/shell/chat_dropzone_tests.rs
@@ -18,6 +18,12 @@ impl Render for DropHost {
         self.shell.update(cx, |shell, cx| {
             let main = shell.render_main(window, 400., 400., cx);
             let right = shell.render_right_pane(window, cx);
+            // Tree and search rows stamp the explorer's current origin; the
+            // stale source models a drag that outlived its workspace.
+            let origin = shell
+                .files
+                .get(&shell.panel_key(cx))
+                .and_then(|files| files.read(cx).interaction_origin(cx));
             div()
                 .size_full()
                 .flex()
@@ -27,22 +33,30 @@ impl Render for DropHost {
                 // to enumerate a checkout. Targets and file tabs are real UI.
                 .child(
                     div().h(px(24.)).flex().children(
-                        [("file", "src/tree.rs", false), ("directory", "src", true)]
-                            .into_iter()
-                            .map(|(id, path, directory)| {
-                                div()
-                                    .id(id)
-                                    .debug_selector(move || id.into())
-                                    .w(px(100.))
-                                    .h_full()
-                                    .on_drag(
-                                        WorkspacePathDrag::new(path.into(), directory),
-                                        |payload, _, _, cx| {
-                                            crate::files::workspace_path_drag_ghost(payload, cx)
-                                        },
-                                    )
-                                    .child(id)
-                            }),
+                        [
+                            ("file", "src/tree.rs", false, origin.clone()),
+                            ("directory", "src", true, origin),
+                            ("stale", "src/stale.rs", false, None),
+                        ]
+                        .into_iter()
+                        .map(|(id, path, directory, origin)| {
+                            div()
+                                .id(id)
+                                .debug_selector(move || id.into())
+                                .w(px(100.))
+                                .h_full()
+                                .on_drag(
+                                    WorkspacePathDrag::new(path.into(), directory).with_origin(
+                                        origin,
+                                        crate::files::WorkspacePathSource::Tree,
+                                        None,
+                                    ),
+                                    |payload, _, _, cx| {
+                                        crate::files::workspace_path_drag_ghost(payload, cx)
+                                    },
+                                )
+                                .child(id)
+                        }),
                     ),
                 )
                 .child(
@@ -129,6 +143,15 @@ fn setup_with_shell(
     cx.update(|window, cx| {
         shell.update(cx, |shell, cx| {
             shell.add_file_surface("src/tab.rs".into(), window, cx);
+            let explorer = cx.new(|cx| {
+                crate::files::FilesSurface::new_explorer(
+                    shell.state.clone(),
+                    shell.active_chat.clone(),
+                    false,
+                    cx,
+                )
+            });
+            shell.files.insert(shell.panel_key(cx), explorer);
             let mut side = shell.state.read(cx).chats[0].clone();
             side.id = "saved-side".into();
             side.parent_chat_id = Some("parent".into());
@@ -243,6 +266,22 @@ fn workspace_drops_target_saved_and_unsaved_side_chat_composers(cx: &mut TestApp
             }
         });
     }
+    // A payload without a live origin attaches to neither side nor main chats.
+    let side = cx.update(|_, cx| {
+        shell.read(cx).side_chats[&1]
+            .composer
+            .read(cx)
+            .surface_bounds()
+            .get()
+            .unwrap()
+            .center()
+    });
+    drag(cx, "stale", side);
+    drag(cx, "stale", gpui::point(px(200.), px(150.)));
+    shell.read_with(cx, |shell, cx| {
+        assert!(!text(&shell.side_chats[&1].composer, cx).contains("stale.rs"));
+        assert!(text(&shell.composer, cx).is_empty());
+    });
 }
 
 #[gpui::test]
diff --git a/crates/ui/src/shell/file_mutations.rs b/crates/ui/src/shell/file_mutations.rs
new file mode 100644
index 0000000000..9330db0640
--- /dev/null
+++ b/crates/ui/src/shell/file_mutations.rs
@@ -0,0 +1,316 @@
+//! Coordinate structural changes across every editor of the affected workspace.
+use super::*;
+use crate::files::{client::WorkspaceFilesClient, mutations::MutationIntent};
+use zeron_proto::{
+    DeleteWorkspaceEntryRequest, MoveWorkspaceEntryRequest, WorkspaceMutationOutcome,
+};
+
+impl Shell {
+    pub(super) fn start_file_mutation(
+        &mut self,
+        source: Entity<FilesSurface>,
+        mut intent: MutationIntent,
+        cx: &mut Context<Self>,
+    ) {
+        if !source.read(cx).accepts_origin(&intent.origin, cx) {
+            return;
+        }
+        let Some(engine) = self.state.read(cx).engine().cloned() else {
+            source.update(cx, |files, cx| {
+                files.report_mutation_error("Workspace service is unavailable".into(), cx)
+            });
+            return;
+        };
+        let surfaces = self
+            .files
+            .values()
+            .chain(self.file_surfaces.values())
+            .filter(|surface| surface.read(cx).shares_workspace(&intent.origin))
+            .cloned()
+            .collect::<Vec<_>>();
+        if surfaces
+            .iter()
+            .any(|surface| surface.read(cx).mutation_busy())
+        {
+            source.update(cx, |files, cx| {
+                files.report_mutation_error("Another file operation is still running".into(), cx)
+            });
+            return;
+        }
+        for surface in &surfaces {
+            surface.update(cx, |files, cx| files.prepare_mutation(intent.clone(), cx));
+        }
+        let waited_for_save = surfaces
+            .iter()
+            .any(|surface| surface.read(cx).mutation_has_save());
+        let client = WorkspaceFilesClient::new(engine, intent.origin.context.clone());
+        cx.spawn(async move |shell, cx| {
+            let result: Result<WorkspaceMutationOutcome, String> = async {
+                let mut ready = false;
+                for _ in 0..400 {
+                    if !surfaces
+                        .iter()
+                        .any(|surface| surface.read_with(cx, |files, _| files.mutation_has_save()))
+                    {
+                        ready = true;
+                        break;
+                    }
+                    cx.background_executor()
+                        .timer(Duration::from_millis(25))
+                        .await;
+                }
+                if !ready {
+                    return Err("Wait for the pending save to finish and try again".into());
+                }
+                if !source.read_with(cx, |files, cx| files.accepts_origin(&intent.origin, cx)) {
+                    return Err("Workspace changed before the operation started".into());
+                }
+                // Only refresh the source revision when our own save was awaited.
+                // Otherwise an external edit must cause SourceChanged, not consent.
+                if waited_for_save {
+                    let page = client
+                        .list_directory_snapshot(
+                            zeron_proto::ListWorkspaceDirectoryRequest {
+                                target: intent.origin.context.target.clone(),
+                                directory: crate::files::model::parent_path(&intent.entry.path)
+                                    .unwrap_or_default(),
+                                include_ignored: true,
+                                cursor: None,
+                            },
+                            &[intent.entry.path.clone()],
+                        )
+                        .await
+                        .map_err(|e| e.to_string())?;
+                    if page.checkout_id != intent.origin.checkout_id {
+                        return Err("Workspace changed while saving".into());
+                    }
+                    let entry = page
+                        .entries
+                        .into_iter()
+                        .find(|entry| entry.path == intent.entry.path)
+                        .ok_or("Source no longer exists")?;
+                    intent.entry.mutation_revision = entry.mutation_revision;
+                }
+                let owner_active = shell
+                    .update(cx, |shell, cx| {
+                        matches!(shell.route, Route::Chat)
+                            && intent.origin.context.target.chat_id.as_deref()
+                                == Some(shell.panel_key(cx).as_str())
+                    })
+                    .unwrap_or(false);
+                if !owner_active
+                    || !source.read_with(cx, |files, cx| files.accepts_origin(&intent.origin, cx))
+                {
+                    return Err("File operation cancelled after switching sessions".into());
+                }
+                let checkout = intent
+                    .origin
+                    .checkout_id
+                    .clone()
+                    .ok_or("Workspace identity unavailable")?;
+                let revision = intent
+                    .entry
+                    .mutation_revision
+                    .clone()
+                    .ok_or("Refresh the tree before trying again")?;
+                if let Some(destination) = &intent.destination {
+                    client
+                        .move_entry(MoveWorkspaceEntryRequest {
+                            target: intent.origin.context.target.clone(),
+                            operation_id: intent.operation_id.clone(),
+                            expected_checkout_id: checkout,
+                            source_path: intent.entry.path.clone(),
+                            destination_path: destination.clone(),
+                            expected_source_revision: revision,
+                            expected_kind: intent.entry.kind,
+                        })
+                        .await
+                        .map_err(|e| e.to_string())
+                } else {
+                    client
+                        .delete_entry(DeleteWorkspaceEntryRequest {
+                            target: intent.origin.context.target.clone(),
+                            operation_id: intent.operation_id.clone(),
+                            expected_checkout_id: checkout,
+                            path: intent.entry.path.clone(),
+                            expected_source_revision: revision,
+                            expected_kind: intent.entry.kind,
+                            recursive: intent.entry.kind
+                                == zeron_proto::WorkspaceEntryKind::Directory,
+                        })
+                        .await
+                        .map_err(|e| e.to_string())
+                }
+            }
+            .await;
+            for surface in &surfaces {
+                let _ = surface.update(cx, |files, cx| files.finish_mutation(&intent, &result, cx));
+            }
+        })
+        .detach();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::{AppContext, TestAppContext, VisualTestContext};
+    use std::{cell::RefCell, rc::Rc};
+
+    struct DragHost {
+        shell: Entity<Shell>,
+        files: Entity<FilesSurface>,
+        _directory: tempfile::TempDir,
+    }
+    impl Render for DragHost {
+        fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+            let main = self
+                .shell
+                .update(cx, |shell, cx| shell.render_main(window, 600., 600., cx));
+            div()
+                .flex()
+                .w(px(900.))
+                .h(px(600.))
+                .child(
+                    div()
+                        .w(px(280.))
+                        .h_full()
+                        .flex_none()
+                        .child(self.files.clone()),
+                )
+                .child(main)
+        }
+    }
+    fn setup(
+        cx: &mut TestAppContext,
+    ) -> (Entity<Shell>, Entity<FilesSurface>, &mut VisualTestContext) {
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            crate::app_menus::init(cx);
+        });
+        let (host, cx) = cx.add_window_view(|_, cx| {
+            let directory = tempfile::tempdir().unwrap();
+            let state = cx.new(|_| {
+                let mut state = crate::files::test_support::state();
+                state.selected_chat = Some("chat".into());
+                state.no_project = true;
+                state
+            });
+            let files = cx.new(|cx| crate::files::test_support::explorer(state.clone(), cx));
+            let shell = cx.new(|cx| {
+                let mut shell = Shell::new(
+                    state,
+                    EngineBootConfig {
+                        data_dir: directory.path().into(),
+                        ipc_port: 0,
+                        edge_url: "http://127.0.0.1:1".into(),
+                        edge_token: None,
+                        org_id: None,
+                        workos_client_id: None,
+                        default_harness: zeron_proto::HarnessId::Mock,
+                    },
+                    cx,
+                );
+                shell.active_chat = "chat".into();
+                shell.route = Route::Chat;
+                shell.files.insert("chat".into(), files.clone());
+                shell
+            });
+            DragHost {
+                shell,
+                files,
+                _directory: directory,
+            }
+        });
+        let (shell, files) = host.read_with(cx, |host, _| (host.shell.clone(), host.files.clone()));
+        cx.update(|window, cx| {
+            window.activate_window();
+            window.draw(cx).clear();
+        });
+        (shell, files, cx)
+    }
+
+    #[gpui::test]
+    fn tree_and_production_chat_dropzones_are_exclusive(cx: &mut TestAppContext) {
+        let (shell, files, cx) = setup(cx);
+        let events = Rc::new(RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        let input = shell.read_with(cx, |shell, cx| shell.composer.read(cx).input.clone());
+        input.update(cx, |input, cx| input.set_text("keep this ", cx));
+        cx.update(|window, cx| window.draw(cx).clear());
+        let start = cx.debug_bounds("tree-entry:a.txt").unwrap().center();
+        let folder = cx.debug_bounds("tree-entry:folder").unwrap().center();
+        let chat = cx.debug_bounds("chat-dropzone").unwrap().center();
+        // Visit the tree target, then finish over the actual conversation.
+        cx.simulate_mouse_down(start, MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(
+            start + gpui::point(px(9.), px(0.)),
+            Some(MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.simulate_mouse_move(folder, Some(MouseButton::Left), gpui::Modifiers::default());
+        cx.simulate_mouse_move(chat, Some(MouseButton::Left), gpui::Modifiers::default());
+        cx.simulate_mouse_up(chat, MouseButton::Left, gpui::Modifiers::default());
+        cx.run_until_parked();
+        let text = input.read_with(cx, |input, _| input.text().to_string());
+        assert!(text.contains("keep this"));
+        assert!(text.contains("a.txt"));
+        assert!(
+            !events
+                .borrow()
+                .iter()
+                .any(|event| matches!(event, FilesEvent::Mutate(_)))
+        );
+        // Visit the chat, then finish over the tree target.
+        cx.simulate_mouse_down(start, MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(
+            start + gpui::point(px(9.), px(0.)),
+            Some(MouseButton::Left),
+            gpui::Modifiers::default(),
+        );
+        cx.simulate_mouse_move(chat, Some(MouseButton::Left), gpui::Modifiers::default());
+        cx.simulate_mouse_move(folder, Some(MouseButton::Left), gpui::Modifiers::default());
+        cx.simulate_mouse_up(folder, MouseButton::Left, gpui::Modifiers::default());
+        cx.run_until_parked();
+        assert_eq!(
+            input.read_with(cx, |input, _| input.text().to_string()),
+            text
+        );
+        assert_eq!(
+            events
+                .borrow()
+                .iter()
+                .filter(|event| matches!(event, FilesEvent::Mutate(_)))
+                .count(),
+            1
+        );
+        cx.update(|_, cx| assert!(!cx.has_active_drag()));
+    }
+
+    #[gpui::test]
+    fn stale_workspace_reference_cannot_attach_to_a_new_chat(cx: &mut TestAppContext) {
+        let (shell, files, cx) = setup(cx);
+        let origin = files
+            .read_with(cx, |files, cx| files.interaction_origin(cx))
+            .unwrap();
+        let payload = WorkspacePathDrag::new("a.txt".into(), false).with_origin(
+            Some(origin),
+            crate::files::WorkspacePathSource::Tree,
+            Some("rev".into()),
+        );
+        shell.update_in(cx, |shell, window, cx| {
+            shell.active_chat = "other".into();
+            let input = shell.composer.read(cx).input.clone();
+            let before = input.read(cx).text().to_string();
+            let composer = shell.composer.clone();
+            shell.attach_workspace_drag(&payload, &composer, window, cx);
+            assert_eq!(input.read(cx).text(), before);
+        });
+    }
+}
diff --git a/crates/ui/src/shell/files_panel.rs b/crates/ui/src/shell/files_panel.rs
index 8cd01cb49f..6a5495a39d 100644
--- a/crates/ui/src/shell/files_panel.rs
+++ b/crates/ui/src/shell/files_panel.rs
@@ -172,6 +172,37 @@ impl Shell {
                 &files,
                 window,
                 move |this: &mut Self, source, event, window, cx| match event {
+                    FilesEvent::HoldMutation { origin, path } => {
+                        let surfaces = this
+                            .files
+                            .values()
+                            .chain(this.file_surfaces.values())
+                            .filter(|s| s.read(cx).shares_workspace(origin))
+                            .cloned()
+                            .collect::<Vec<_>>();
+                        for surface in surfaces {
+                            surface.update(cx, |files, cx| files.hold_mutation(path.clone(), cx));
+                        }
+                    }
+                    FilesEvent::AddToChat {
+                        path,
+                        is_directory,
+                        origin,
+                    } => {
+                        let payload = WorkspacePathDrag::new(path.clone(), *is_directory)
+                            .with_origin(
+                                Some(origin.clone()),
+                                crate::files::WorkspacePathSource::Tree,
+                                None,
+                            );
+                        let composer = this.composer.clone();
+                        this.attach_workspace_drag(&payload, &composer, window, cx);
+                    }
+                    FilesEvent::Mutate(intent)
+                        if this.accepts_file_navigation(&owner, &source, cx) =>
+                    {
+                        this.start_file_mutation(source.clone(), intent.clone(), cx);
+                    }
                     FilesEvent::OpenFile(path)
                         if this.accepts_file_navigation(&owner, &source, cx) =>
                     {
@@ -242,6 +273,9 @@ impl Shell {
         if !self.files_panel_open(cx) {
             return;
         }
+        if let Some(files) = self.files.get(&self.panel_key(cx)).cloned() {
+            files.update(cx, |files, cx| files.suspend_tree_interactions(cx));
+        }
         let from = self.files_visible_width(cx);
         self.panels
             .update(&self.panel_key(cx), |p| p.files_open = false);
diff --git a/docs/file-tree-interactions.md b/docs/file-tree-interactions.md
new file mode 100644
index 0000000000..7810271376
--- /dev/null
+++ b/docs/file-tree-interactions.md
@@ -0,0 +1,103 @@
+# File tree actions and workspace moves
+
+Right-click a file or folder in the explorer to open the shared context menu.
+The same menu opens with the Menu key or Shift+F10 on the selected row.
+
+- **Add to chat** inserts a workspace reference into the current draft and focuses
+  the composer. It keeps existing text and does not send a message.
+- **Copy path** copies the full path using the owning workspace's root and path
+  format, including when the workspace belongs to another device.
+- **Rename…** edits the name in the row. Enter submits; Escape or losing focus
+  before submission cancels. F2 also opens the inline editor. A rename never
+  overwrites another entry.
+- **Delete…** asks for permanent deletion. Cancel is initially selected; use
+  Tab/arrow keys to choose the destructive action. Deleting a folder includes
+  its current contents. Open buffers remain available for recovery; autosave
+  cannot recreate deleted files. The Delete key opens the same confirmation.
+
+Drag an entry onto a folder to move it. Dropping on a file targets that file's
+parent directory. The root row and the empty space below the list target the
+workspace root. A drop in the current parent is a no-op; a folder cannot move
+into itself or a descendant. Existing destinations are never overwritten or
+merged. The source remains visible until the host confirms the operation.
+
+Drag from the row on macOS, Linux, and Windows. The Windows drag threshold
+protects ordinary clicks from small pointer jitter. Search results and file
+tabs continue to support references into the conversation; only tree-originated
+drags can move entries.
+
+Holding a compatible drag over a closed folder opens it after 650 ms. Dragging
+near the top or bottom of the list scrolls it. Escape, leaving the tree,
+switching sessions, and closing the explorer clear the feedback and timers.
+Folders opened by hover stay open. The chat column retains its own drop zone,
+so a gesture ending there adds a reference instead of moving the entry. OS file
+attachments continue through the existing composer attachment pipeline.
+
+## Workspace and editor consistency
+
+Operations run through the owning engine, locally or remotely. Directory pages
+announce the host's mutation capabilities and checkout identity; older hosts
+remain usable for navigation, Copy path and Add to chat. Mutation requests
+carry the expected checkout and an opaque metadata revision. A stale source
+must be refreshed before another explicit attempt. Symlinks cannot be renamed,
+moved or deleted through these actions, and traversal through symlink parents
+is rejected. The workspace root and `.git` paths are protected.
+
+Move and rename use one RPC. Writes acquire a shared checkout gate before their
+existing per-file lock; structural operations acquire the exclusive gate.
+The UI pauses affected autosaves and waits for in-flight saves. It remaps open
+editors, tabs and comment paths while retaining unsaved text. Response and
+semantic watcher events share an operation ID so receiving both is harmless.
+A semantic event can reconcile a successful operation whose RPC reply was lost.
+Transport failures are never retried automatically.
+
+A recursive delete can fail after deleting some children. The response reports
+that condition and the explorer refreshes the surviving contents. Cancellation
+of a request after a native filesystem call starts is not an undo operation.
+Metadata revisions are not recursive directory snapshots, and operations do
+not provide transactions against arbitrary external processes. Cross-volume
+moves return an error instead of falling back to copying and deleting.
+
+Native moves use Linux `RENAME_NOREPLACE`, macOS `RENAME_EXCL`, and Windows
+`MoveFileExW` without replacement or cross-volume copy flags. See the
+[Linux rename manual](https://man7.org/linux/man-pages/man2/rename.2.html),
+[Apple's exclusive rename capability](https://developer.apple.com/documentation/foundation/urlresourcevalues/volumesupportsexclusiverenaming),
+and [Microsoft's MoveFileExW contract](https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-movefileexw).
+Case-only aliases on case-insensitive Unix volumes use a unique temporary entry
+with no-replacement rollback. Distinct case-similar hard links are collisions.
+
+## Verification
+
+Automated coverage includes protocol compatibility, filesystem mutation and
+collision tests, real RPC/watch integration, two engines forwarding through a
+relay into a plain folder, tree model relocation, dirty-buffer reconciliation,
+menus, inline rename, cancellation, and timed hover expansion. A GPUI fixture
+renders the production tree beside `Shell::render_main` to test both directions
+between the tree and the real conversation drop zone.
+
+Commands from the repository root:
+
+```sh
+cargo test --release --locked -p zeron-proto --lib
+cargo test --release --locked -p zeron-engine --lib workspace_files::
+cargo test --release --locked -p zeron-engine --lib rpc::
+cargo test --release --locked -p zeron-engine --test workspace_files
+cargo test --release --locked -p zeron-engine --test device_routing workspace_entry_mutations_are_forwarded
+cargo test --release --locked -p zeron-ui --lib -- --test-threads=1
+cargo check --release --locked -p zeron
+```
+
+This implementation was exercised on Linux with GPUI's test backend. Native
+macOS/Windows interaction, Windows junctions, and the case-insensitive-volume
+fallback require verification on those hosts. A Windows-specific regression is
+included for row-click jitter and intentional row dragging. A desktop visual
+review of themes, narrow windows and pointer feel is still required; headless
+tests do not establish native rendering quality.
+
+Validated on 2026-09-23: 1,274 UI tests, 45 protocol tests, 37 workspace engine
+tests, 18 RPC tests (one ignored), four workspace RPC integration tests, and the
+two-engine forwarding test passed. The application release check also passed.
+An initial full UI run hit a sidebar scheduler failure; its isolated rerun and
+the subsequent complete suite passed. Formatting checks passed for every Rust
+file changed here; the workspace-wide formatting check still reports existing
+differences in unrelated files.
diff --git a/docs/research/windows-click-drag-audit.md b/docs/research/windows-click-drag-audit.md
index 9c6a93fb65..1e84700f2e 100644
--- a/docs/research/windows-click-drag-audit.md
+++ b/docs/research/windows-click-drag-audit.md
@@ -72,3 +72,10 @@ For each P0/P1 control, add a Windows regression covering mouse-down, approximat
 Comet now centralizes this distinction in `click_activation_drag_enabled()`. On Windows, the four P0/P1 control families above no longer register drag initiation on their click-activation hitboxes. Their primary click actions therefore survive pointer jitter. Drag-first controls remain unchanged, and macOS/Linux retain tab reordering and workspace-path dragging.
 
 The production right-tab visual regression reproduces an eight-pixel moving click. It failed before the change because GPUI entered an active drag, then passed after the Windows policy was applied. The complete `zeron-ui` library suite passed with 789 tests.
+
+## File tree actions (2026-09-23)
+
+Workspace tree rows keep their row-wide drag on every platform, including
+Windows; GPUI's platform drag threshold protects ordinary clicks from jitter.
+Tree, search and file-tab payloads carry their originating surface and workspace
+context so a delayed drop cannot attach a path to a different session.

From b3d7f48b5a1c33fc345f802302a266bf46d88abb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Thu, 1 Oct 2026 00:52:30 -0300
Subject: [PATCH 18/74] Fix command and skill labels in the message queue
 (#682)

* Fix command and skill labels in the message queue

* Test queue row labels for commands, skills and files

Extract the row label into queue_row_text so the projection is covered by a
unit test alongside the attachment-trailer handling.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/queue.rs | 44 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/crates/ui/src/queue.rs b/crates/ui/src/queue.rs
index adbf4b0494..b727c7bf54 100644
--- a/crates/ui/src/queue.rs
+++ b/crates/ui/src/queue.rs
@@ -218,6 +218,17 @@ fn queue_visible_text(text: &str, attachments: &[String]) -> String {
     }
 }
 
+/// The row's one-line label. Commands, skills and file mentions show the same
+/// labels as the transcript; editing and delivery still read the stored text,
+/// which keeps their canonical links.
+fn queue_row_text(text: &str, attachments: &[String]) -> SharedString {
+    let visible = queue_visible_text(text, attachments);
+    let display = crate::composer::sent_mention_display(&visible)
+        .map(|(display, _)| display)
+        .unwrap_or(visible);
+    one_line(&display)
+}
+
 /// Presentation-only metadata. Never expose the observed accessibility payload.
 /// Rows show thumbnails only; these names surface as tooltips and labels.
 fn queue_attachment_labels(text: &str, paths: &[String]) -> Vec<String> {
@@ -433,7 +444,7 @@ impl Composer {
             Some(QueueDeliveryGate::ReviewRequired { .. }) if !being_edited => {
                 SharedString::from("Needs review")
             }
-            _ => one_line(&queue_visible_text(&item.text, &item.attachments)),
+            _ => queue_row_text(&item.text, &item.attachments),
         };
 
         let edit_id = item.id.clone();
@@ -2042,6 +2053,37 @@ mod tests {
         assert_eq!(super::queue_hidden_attachments_label(&[], 2), None);
     }
 
+    /// Rows label references the way the transcript does, never as raw
+    /// `zeron-invoke:`/`zeron-file:` links, and still hide attachment trailers.
+    #[test]
+    fn queue_rows_label_commands_skills_and_files() {
+        use zeron_proto::invocation::Invocation;
+        let command = Invocation::Command {
+            name: "compact".into(),
+        }
+        .link();
+        let skill = Invocation::Skill {
+            name: "review-pr".into(),
+            path: "/skills/review-pr/SKILL.md".into(),
+            command: None,
+        }
+        .link();
+        let file = zeron_proto::file_mentions::local_file_link("src/queue.rs", false);
+        let text = format!("{command} then {skill}\non {file}");
+        assert_eq!(
+            super::queue_row_text(&text, &[]).as_ref(),
+            "/compact then $review-pr on @queue.rs"
+        );
+
+        let paths = vec!["/tmp/image.png".to_string()];
+        let legacy = crate::attachments::with_attachments(&command, &paths);
+        assert_eq!(super::queue_row_text(&legacy, &paths).as_ref(), "/compact");
+        assert_eq!(
+            super::queue_row_text("plain  text", &[]).as_ref(),
+            "plain text"
+        );
+    }
+
     #[test]
     fn legacy_attachment_trailers_are_hidden_from_queue_text() {
         let paths = vec!["/tmp/image.png".to_string()];

From 42926c802a837097e6a05de89d48ca7ade326658 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Thu, 1 Oct 2026 01:50:50 -0300
Subject: [PATCH 19/74] Right panel tabs: close button on the right (#587)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Right panel tabs: close button on the right

The ✕ replaced the surface icon on hover in the leading slot. The icon
now stays put on the left, the title takes the free space, and the ✕
fades in on hover in a trailing slot at the tab's right edge (same size,
color and hover wash). The unsaved dot moves into that slot and swaps
with the ✕ on hover. Chip padding is now symmetric (4px).

* Right panel tabs: label the close button and pin its placement

Give the trailing close slot a "Close tab" tooltip, a button role and
an accessible label, matching the terminal drawer's "Close terminal"
tooltip. Add a regression test that the close sits after the title at
the chip's right edge.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/shell.rs | 151 +++++++++++++++++++++++------------------
 1 file changed, 85 insertions(+), 66 deletions(-)

diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index 46b26e3024..45f1e046ce 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -11033,8 +11033,7 @@ impl Shell {
                 .h(px(24.0))
                 .w(px(CHIP_W))
                 .flex_none()
-                .pl(px(4.0))
-                .pr(px(8.0))
+                .px(px(4.0))
                 .rounded(px(6.0))
                 .flex()
                 .flex_row()
@@ -11136,8 +11135,62 @@ impl Shell {
                     },
                 ))
                 .child(
-                    // Leading slot: icon normally, ✕ on tab hover — two
-                    // stacked layers opacity-swapped by the group hover.
+                    // Leading slot: the surface's icon.
+                    div()
+                        .flex_none()
+                        .size(px(18.0))
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .child(if subagent_running {
+                            loaders::mini_glyph_spinner(
+                                format!("subagent-tab-{ix}"),
+                                2.0,
+                                theme.glyph,
+                                cx.entity_id(),
+                                cx,
+                            )
+                            .into_any_element()
+                        } else if let Some(favicon) = browser_favicon {
+                            gpui::img(favicon).size(px(12.0)).into_any_element()
+                        } else if matches!(surface, RightSurface::File(_)) {
+                            crate::file_icons::icon(
+                                crate::file_icons::FileIconIdentity::file(
+                                    file_identity_path.as_ref(),
+                                ),
+                                theme.appearance,
+                            )
+                            .size(px(14.0))
+                            .when(!is_active, |icon| icon.opacity(0.78))
+                            .into_any_element()
+                        } else {
+                            icon(icon_path)
+                                .size(px(12.0))
+                                .text_color(if is_active {
+                                    theme.text_muted
+                                } else {
+                                    theme.text_muted.opacity(0.7)
+                                })
+                                .into_any_element()
+                        }),
+                )
+                .child(
+                    div()
+                        .flex_1()
+                        .min_w_0()
+                        .truncate()
+                        .text_size(crate::typography::ui_rems(11.5))
+                        .text_color(if is_active {
+                            theme.text
+                        } else {
+                            theme.text_muted
+                        })
+                        .child(title),
+                )
+                .child(
+                    // Trailing slot: the unsaved dot normally, ✕ on tab
+                    // hover — two stacked layers opacity-swapped by the
+                    // group hover.
                     div()
                         .id(("right-surface-close", ix))
                         .debug_selector(|| format!("right-surface-close-{ix}"))
@@ -11145,6 +11198,9 @@ impl Shell {
                         .size(px(18.0))
                         .rounded(px(4.0))
                         .relative()
+                        .role(gpui::Role::Button)
+                        .aria_label("Close tab")
+                        .tooltip(crate::settings::widgets::text_tooltip("Close tab"))
                         .hover(|s| s.bg(crate::theme::wash(0.12)))
                         // The tab owns a drag payload. Claim the close press
                         // before it reaches that parent or GPUI starts a tab
@@ -11157,46 +11213,18 @@ impl Shell {
                             cx.stop_propagation();
                             this.close_right_surface(surface, window, cx);
                         }))
-                        .child(
-                            div()
-                                .absolute()
-                                .inset_0()
-                                .flex()
-                                .items_center()
-                                .justify_center()
-                                .group_hover(group.clone(), |s| s.opacity(0.0))
-                                .child(if subagent_running {
-                                    loaders::mini_glyph_spinner(
-                                        format!("subagent-tab-{ix}"),
-                                        2.0,
-                                        theme.glyph,
-                                        cx.entity_id(),
-                                        cx,
-                                    )
-                                    .into_any_element()
-                                } else if let Some(favicon) = browser_favicon {
-                                    gpui::img(favicon).size(px(12.0)).into_any_element()
-                                } else if matches!(surface, RightSurface::File(_)) {
-                                    crate::file_icons::icon(
-                                        crate::file_icons::FileIconIdentity::file(
-                                            file_identity_path.as_ref(),
-                                        ),
-                                        theme.appearance,
-                                    )
-                                    .size(px(14.0))
-                                    .when(!is_active, |icon| icon.opacity(0.78))
-                                    .into_any_element()
-                                } else {
-                                    icon(icon_path)
-                                        .size(px(12.0))
-                                        .text_color(if is_active {
-                                            theme.text_muted
-                                        } else {
-                                            theme.text_muted.opacity(0.7)
-                                        })
-                                        .into_any_element()
-                                }),
-                        )
+                        .when(dirty, |slot| {
+                            slot.child(
+                                div()
+                                    .absolute()
+                                    .inset_0()
+                                    .flex()
+                                    .items_center()
+                                    .justify_center()
+                                    .group_hover(group.clone(), |s| s.opacity(0.0))
+                                    .child(div().size(px(6.0)).rounded_full().bg(theme.text_muted)),
+                            )
+                        })
                         .child(
                             div()
                                 .absolute()
@@ -11212,28 +11240,7 @@ impl Shell {
                                         .text_color(theme.text_muted),
                                 ),
                         ),
-                )
-                .child(
-                    div()
-                        .min_w_0()
-                        .truncate()
-                        .text_size(crate::typography::ui_rems(11.5))
-                        .text_color(if is_active {
-                            theme.text
-                        } else {
-                            theme.text_muted
-                        })
-                        .child(title),
-                )
-                .when(dirty, |chip| {
-                    chip.child(
-                        div()
-                            .flex_none()
-                            .size(px(6.0))
-                            .rounded_full()
-                            .bg(theme.text_muted),
-                    )
-                });
+                );
             // Sliding transform while a sibling drags over (the terminal
             // drawer's exact recipe): animate 150ms between committed
             // offsets; the dragged tab leaves an invisible spacer — the
@@ -15833,6 +15840,18 @@ mod right_tab_mouse_regressions {
         });
     }
 
+    #[gpui::test]
+    fn right_tab_close_sits_at_the_trailing_edge(cx: &mut TestAppContext) {
+        let (_shell, cx) = setup(cx);
+        let tab = cx.debug_bounds("right-surface-tab-0").unwrap();
+        let close = cx.debug_bounds("right-surface-close-0").unwrap();
+        assert!(
+            close.left() > tab.center().x,
+            "close is not after the title"
+        );
+        assert_eq!(close.right(), tab.right() - px(4.));
+    }
+
     #[gpui::test]
     fn tab_strip_scrolls_over_chips_inside_titlebar(cx: &mut TestAppContext) {
         let (shell, cx) = setup(cx);

From a73fa8fe4002c1f1fe393d6d4c5c05a858fd3763 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ga=C3=ABl=20Cado?=
 <130941423+gaelcado@users.noreply.github.com>
Date: Thu, 1 Oct 2026 12:06:08 +0200
Subject: [PATCH 20/74] Add optional compact model picker and effort controls
 (#471)

Compact model picker (on by default, General settings): effort slider with fast-mode toggle, provider button + provider page (Starred first), per-model effort memory, Cursor effort options on the slider, page-scoped keyboard shortcuts, per-edge/per-pixel edge fades (zui 667d0aa).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 Cargo.lock                                    |   46 +-
 Cargo.toml                                    |    8 +-
 crates/ui/Cargo.toml                          |    7 +-
 crates/ui/assets/icons/fast-tier-bold.svg     |    1 +
 crates/ui/examples/compact-picker-fixture.rs  |  322 ++++
 crates/ui/src/composer.rs                     |  221 +--
 crates/ui/src/edge_fade.rs                    |   26 +-
 crates/ui/src/glass.rs                        |  161 ++
 crates/ui/src/haptics.rs                      |   29 +
 crates/ui/src/icons.rs                        |    4 +-
 crates/ui/src/lib.rs                          |    2 +
 crates/ui/src/motion.rs                       |   39 +
 crates/ui/src/pickers.rs                      | 1209 ++++++++++++-
 crates/ui/src/pickers/compact.rs              | 1569 +++++++++++++++++
 crates/ui/src/popover.rs                      |   31 +-
 crates/ui/src/settings.rs                     |   23 +
 crates/ui/src/settings/composer.rs            |   27 +
 crates/ui/src/settings/shortcuts.rs           |   40 +
 crates/ui/src/shell.rs                        |   91 +-
 crates/ui/src/shell/tabs.rs                   |   15 +-
 crates/ui/src/state.rs                        |   90 +-
 docs/screenshots/compact-picker/README.md     |   16 +
 .../compact-picker/compact-fast-keyboard.png  |  Bin 0 -> 134697 bytes
 .../compact-model-list-light-narrow.png       |  Bin 0 -> 115039 bytes
 .../compact-panel-dark-wide.png               |  Bin 0 -> 115534 bytes
 .../compact-panel-light-wide.png              |  Bin 0 -> 108940 bytes
 .../compact-picker/switch-states.png          |  Bin 0 -> 165934 bytes
 27 files changed, 3714 insertions(+), 263 deletions(-)
 create mode 100644 crates/ui/assets/icons/fast-tier-bold.svg
 create mode 100644 crates/ui/examples/compact-picker-fixture.rs
 create mode 100644 crates/ui/src/glass.rs
 create mode 100644 crates/ui/src/haptics.rs
 create mode 100644 crates/ui/src/pickers/compact.rs
 create mode 100644 docs/screenshots/compact-picker/README.md
 create mode 100644 docs/screenshots/compact-picker/compact-fast-keyboard.png
 create mode 100644 docs/screenshots/compact-picker/compact-model-list-light-narrow.png
 create mode 100644 docs/screenshots/compact-picker/compact-panel-dark-wide.png
 create mode 100644 docs/screenshots/compact-picker/compact-panel-light-wide.png
 create mode 100644 docs/screenshots/compact-picker/switch-states.png

diff --git a/Cargo.lock b/Cargo.lock
index ebe7663a14..e67ec7e690 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -914,7 +914,7 @@ dependencies = [
  "bitflags 2.13.1",
  "cexpr",
  "clang-sys",
- "itertools 0.12.1",
+ "itertools 0.10.5",
  "log",
  "prettyplease",
  "proc-macro2",
@@ -1561,7 +1561,7 @@ dependencies = [
 [[package]]
 name = "collections"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "gpui_util",
  "indexmap",
@@ -2208,7 +2208,7 @@ dependencies = [
 [[package]]
 name = "derive_refineable"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3391,7 +3391,7 @@ dependencies = [
 [[package]]
 name = "gpui"
 version = "0.2.2"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "accesskit",
  "anyhow",
@@ -3477,7 +3477,7 @@ dependencies = [
 [[package]]
 name = "gpui-base"
 version = "0.5.2"
-source = "git+https://github.com/zeronsh/gpui-component?rev=103f13da91ff2c7c52941bdc2b1910f29716dc19#103f13da91ff2c7c52941bdc2b1910f29716dc19"
+source = "git+https://github.com/zeronsh/gpui-component?rev=2f73e5c2bc03d6768cb5fcc92442c4cf4b963b70#2f73e5c2bc03d6768cb5fcc92442c4cf4b963b70"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3507,7 +3507,7 @@ dependencies = [
 [[package]]
 name = "gpui_linux"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "accesskit",
  "accesskit_unix",
@@ -3559,7 +3559,7 @@ dependencies = [
 [[package]]
 name = "gpui_macos"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "accesskit",
  "accesskit_macos",
@@ -3608,7 +3608,7 @@ dependencies = [
 [[package]]
 name = "gpui_macros"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -3619,7 +3619,7 @@ dependencies = [
 [[package]]
 name = "gpui_platform"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "console_error_panic_hook",
  "gpui",
@@ -3632,7 +3632,7 @@ dependencies = [
 [[package]]
 name = "gpui_shared_string"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "schemars",
  "serde",
@@ -3642,7 +3642,7 @@ dependencies = [
 [[package]]
 name = "gpui_tokio"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "anyhow",
  "gpui",
@@ -3653,7 +3653,7 @@ dependencies = [
 [[package]]
 name = "gpui_util"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "anyhow",
  "log",
@@ -3663,7 +3663,7 @@ dependencies = [
 [[package]]
 name = "gpui_web"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -3687,7 +3687,7 @@ dependencies = [
 [[package]]
 name = "gpui_wgpu"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "anyhow",
  "bytemuck",
@@ -3716,7 +3716,7 @@ dependencies = [
 [[package]]
 name = "gpui_windows"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "accesskit",
  "accesskit_windows",
@@ -4048,7 +4048,7 @@ dependencies = [
 [[package]]
 name = "http_client"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "anyhow",
  "async-compression",
@@ -5221,7 +5221,7 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 [[package]]
 name = "media"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "anyhow",
  "bindgen",
@@ -5701,7 +5701,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
- "proc-macro-crate 3.5.0",
+ "proc-macro-crate 1.3.1",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -6364,7 +6364,7 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "perf"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "collections",
  "serde",
@@ -7443,7 +7443,7 @@ dependencies = [
 [[package]]
 name = "refineable"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "derive_refineable",
 ]
@@ -8129,7 +8129,7 @@ checksum = "c62751faa8bc286982334a082fe125184a29fc89d17775766e4f891b7d726980"
 [[package]]
 name = "scheduler"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "async-task",
  "backtrace",
@@ -8914,7 +8914,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "sum_tree"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "heapless 0.9.3",
  "log",
@@ -10331,7 +10331,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 [[package]]
 name = "util_macros"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=18a89af04cfe079d55275b111ac349d5640d9cda#18a89af04cfe079d55275b111ac349d5640d9cda"
+source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
 dependencies = [
  "perf",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 9f66383825..ad21a07a80 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -76,15 +76,15 @@ loro-protocol = "0.3"
 # Linux — the Metal path's snapshot/blur/composite, ported).
 # Paint-time rounded image masks (#9), bounded Windows backdrop blur and
 # translucent compositing, plus blur-aware scene batching (#10).
-gpui = { git = "https://github.com/zeronsh/zui", rev = "18a89af04cfe079d55275b111ac349d5640d9cda" }
-gpui_platform = { git = "https://github.com/zeronsh/zui", rev = "18a89af04cfe079d55275b111ac349d5640d9cda", features = [
+gpui = { git = "https://github.com/zeronsh/zui", rev = "667d0aaf9531d2d1b2d0674a5e55f977df1b09f6" }
+gpui_platform = { git = "https://github.com/zeronsh/zui", rev = "667d0aaf9531d2d1b2d0674a5e55f977df1b09f6", features = [
     "wayland",
     "x11",
     "font-kit",
     "runtime_shaders",
 ] }
-gpui_tokio = { git = "https://github.com/zeronsh/zui", rev = "18a89af04cfe079d55275b111ac349d5640d9cda" }
-gpui-base = { git = "https://github.com/zeronsh/gpui-component", rev = "103f13da91ff2c7c52941bdc2b1910f29716dc19" }
+gpui_tokio = { git = "https://github.com/zeronsh/zui", rev = "667d0aaf9531d2d1b2d0674a5e55f977df1b09f6" }
+gpui-base = { git = "https://github.com/zeronsh/gpui-component", rev = "2f73e5c2bc03d6768cb5fcc92442c4cf4b963b70" }
 
 # diffs
 similar = "2"
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 60bd67d758..3d66f80f3d 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -7,6 +7,7 @@ publish.workspace = true
 
 [features]
 project-palette-fixture = []
+compact-picker-fixture = ["gpui_platform/test-support"]
 
 browser-fixture = []
 windows-render-fixture = []
@@ -41,6 +42,10 @@ required-features = ["project-palette-fixture"]
 name = "sidebar-fixture"
 required-features = ["project-palette-fixture"]
 
+[[example]]
+name = "compact-picker-fixture"
+required-features = ["compact-picker-fixture"]
+
 [dependencies]
 url = "2"
 zeron-proto.workspace = true
@@ -89,7 +94,7 @@ wry = { version = "0.56", default-features = false, features = ["os-webview"] }
 raw-window-handle = "0.6"
 objc2 = "0.6"
 block2 = "0.6"
-objc2-app-kit = { version = "0.3.2", features = ["NSApplication", "NSBitmapImageRep", "NSImage", "NSEvent", "NSResponder", "NSView", "NSWindow"] }
+objc2-app-kit = { version = "0.3.2", features = ["NSApplication", "NSHapticFeedback", "NSBitmapImageRep", "NSImage", "NSEvent", "NSResponder", "NSView", "NSWindow"] }
 objc2-foundation = "0.3.2"
 objc2-web-kit = { version = "0.3.2", features = ["WKWebView", "WKNavigationDelegate", "WKNavigationAction", "WKSnapshotConfiguration"] }
 reqwest.workspace = true
diff --git a/crates/ui/assets/icons/fast-tier-bold.svg b/crates/ui/assets/icons/fast-tier-bold.svg
new file mode 100644
index 0000000000..cf4b3a0f4c
--- /dev/null
+++ b/crates/ui/assets/icons/fast-tier-bold.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"><path d="m14 3-9 11h6l-1 7 9-11h-6l1-7Z" fill="#000" stroke="#000" stroke-width="1.5" stroke-linejoin="round"/></svg>
\ No newline at end of file
diff --git a/crates/ui/examples/compact-picker-fixture.rs b/crates/ui/examples/compact-picker-fixture.rs
new file mode 100644
index 0000000000..6c5ab4b27d
--- /dev/null
+++ b/crates/ui/examples/compact-picker-fixture.rs
@@ -0,0 +1,322 @@
+//! Isolated visual and keyboard evidence for the compact model picker.
+use gpui::{
+    AppContext, AsyncApp, Bounds, Context, Entity, Render, Window, WindowBounds, WindowOptions,
+    div, prelude::*, px, size,
+};
+use std::{path::Path, path::PathBuf, time::Duration};
+use zeron_ui::*;
+
+struct Fixture {
+    pickers: Entity<pickers::Pickers>,
+    title: &'static str,
+}
+
+impl Render for Fixture {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = theme::Theme::of(cx).clone();
+        div()
+            .id("compact-picker-fixture")
+            .size_full()
+            .bg(theme.surface)
+            .text_color(theme.text)
+            .font_family(theme.font_sans.clone())
+            .p(px(24.0))
+            .child(
+                div()
+                    .size_full()
+                    .flex()
+                    .flex_col()
+                    .justify_end()
+                    .gap(px(16.0))
+                    .child(settings::widgets::page_header(&theme, self.title, None))
+                    .child(
+                        div()
+                            .relative()
+                            .h(px(48.0))
+                            .flex()
+                            .items_center()
+                            .child(self.pickers.clone()),
+                    ),
+            )
+    }
+}
+
+async fn pause(cx: &mut AsyncApp) {
+    cx.background_executor()
+        .timer(Duration::from_millis(260))
+        .await;
+}
+
+fn capture(
+    window: gpui::AnyWindowHandle,
+    cx: &mut AsyncApp,
+    output: &Path,
+    name: &str,
+) -> anyhow::Result<()> {
+    window.update(cx, |_, window, cx| {
+        window.draw(cx).clear();
+        window.render_to_image()?.save(output.join(name))?;
+        Ok(())
+    })?
+}
+
+fn press(window: gpui::AnyWindowHandle, cx: &mut AsyncApp, key: &str) -> anyhow::Result<()> {
+    window.update(cx, |_, window, cx| {
+        assert!(
+            window.dispatch_keystroke(gpui::Keystroke::parse(key).unwrap(), cx),
+            "compact picker did not handle {key}"
+        );
+    })?;
+    Ok(())
+}
+
+async fn capture_matrix_scene(
+    window: gpui::WindowHandle<Fixture>,
+    cx: &mut AsyncApp,
+    output: &Path,
+    appearance: appearance::AppearanceMode,
+    width: f32,
+    label: &str,
+) -> anyhow::Result<()> {
+    window.update(cx, |view, window, cx| {
+        appearance::set_mode(appearance, cx);
+        window.resize(size(px(width), px(560.0)));
+        view.title = if appearance == appearance::AppearanceMode::Light {
+            "Compact picker · light"
+        } else {
+            "Compact picker · dark"
+        };
+        cx.notify();
+    })?;
+    pause(cx).await;
+    capture(
+        window.into(),
+        cx,
+        output,
+        &format!("compact-panel-{label}.png"),
+    )?;
+    press(window.into(), cx, "enter")?;
+    pause(cx).await;
+    window.update(cx, |view, _, cx| {
+        assert!(view.pickers.read(cx).fixture_compact_state(cx).model_list);
+    })?;
+    capture(
+        window.into(),
+        cx,
+        output,
+        &format!("compact-model-list-{label}.png"),
+    )?;
+    press(window.into(), cx, "escape")?;
+    pause(cx).await;
+    Ok(())
+}
+
+fn main() -> anyhow::Result<()> {
+    let runtime = tokio::runtime::Runtime::new()?;
+    let _guard = runtime.enter();
+    let output = PathBuf::from(std::env::args().nth(1).expect("output directory"));
+    std::fs::create_dir_all(&output)?;
+    let temp = tempfile::tempdir()?;
+    let data = temp.path().to_path_buf();
+    gpui_platform::application()
+        .with_assets(icons::Assets)
+        .run(move |cx| {
+            gpui_tokio::init(cx);
+            gpui_base::init(cx);
+            let mut prefs = settings::UiSettings::default();
+            prefs.compact_model_picker = true;
+            settings::init(prefs.clone(), data.clone(), cx);
+            let fonts = typography::register_fonts(cx);
+            typography::init(
+                prefs.ui_font_family.clone(),
+                prefs.ui_font_size,
+                prefs.terminal_font_family.clone(),
+                prefs.terminal_font_size,
+                prefs.code_font_family.clone(),
+                prefs.code_font_size,
+                fonts,
+                cx,
+            );
+            theme_library::init(data, cx);
+            appearance::init(
+                appearance::AppearanceMode::Dark,
+                prefs.theme_selection,
+                prefs.accent,
+                prefs.surface,
+                cx,
+            );
+            composer::init(cx, prefs.composer_send_behavior);
+
+            let state = cx.new(|_| state::AppState::new());
+            let pickers = cx.new(|cx| {
+                let mut pickers = pickers::Pickers::new(state, cx);
+                pickers.fixture_compact_catalog(cx);
+                pickers
+            });
+            let window = cx
+                .open_window(
+                    WindowOptions {
+                        window_bounds: Some(WindowBounds::Windowed(Bounds::new(
+                            gpui::point(px(40.0), px(40.0)),
+                            size(px(840.0), px(560.0)),
+                        ))),
+                        ..Default::default()
+                    },
+                    |window, cx| {
+                        pickers.update(cx, |pickers, cx| {
+                            pickers.open_model_menu(window, cx)
+                        });
+                        cx.new(|_| Fixture {
+                            pickers,
+                            title: "Compact picker · dark",
+                        })
+                    },
+                )
+                .unwrap();
+            cx.activate(true);
+
+            cx.spawn(async move |cx| {
+                let result: anyhow::Result<()> = async {
+                    pause(cx).await;
+                    for (appearance, width, label) in [
+                        (appearance::AppearanceMode::Dark, 840.0, "dark-wide"),
+                        (appearance::AppearanceMode::Dark, 360.0, "dark-narrow"),
+                        (appearance::AppearanceMode::Light, 840.0, "light-wide"),
+                        (appearance::AppearanceMode::Light, 360.0, "light-narrow"),
+                    ] {
+                        capture_matrix_scene(window, cx, &output, appearance, width, label).await?;
+                    }
+
+                    window.update(cx, |view, window, cx| {
+                        appearance::set_mode(appearance::AppearanceMode::Dark, cx);
+                        window.resize(size(px(840.0), px(560.0)));
+                        view.title = "Compact picker · keyboard controls";
+                        cx.notify();
+                    })?;
+                    pause(cx).await;
+
+                    // Model → Fast → Effort, then choose the ladder's maximum
+                    // using the real keyboard path.
+                    for key in ["down", "down", "end"] {
+                        press(window.into(), cx, key)?;
+                    }
+                    pause(cx).await;
+                    window.update(cx, |view, _, cx| {
+                        let state = view.pickers.read(cx).fixture_compact_state(cx);
+                        assert_eq!(state.reasoning, Some(zeron_proto::ReasoningLevel::XHigh));
+                    })?;
+                    capture(
+                        window.into(),
+                        cx,
+                        &output,
+                        "compact-effort-keyboard-xhigh.png",
+                    )?;
+
+                    // Effort → Fast toggles the exact service-tier option.
+                    for key in ["up", "enter"] {
+                        press(window.into(), cx, key)?;
+                    }
+                    window.update(cx, |view, _, cx| {
+                        assert!(view.pickers.read(cx).fixture_compact_state(cx).fast);
+                    })?;
+                    pause(cx).await;
+                    capture(
+                        window.into(),
+                        cx,
+                        &output,
+                        "compact-fast-keyboard.png",
+                    )?;
+
+                    // Return to Model, enter the list, move by keyboard, and
+                    // star the focused model without changing the selection.
+                    for key in ["up", "enter", "down", "cmd-shift-f"] {
+                        press(window.into(), cx, key)?;
+                    }
+                    pause(cx).await;
+                    window.update(cx, |view, _, cx| {
+                        let state = view.pickers.read(cx).fixture_compact_state(cx);
+                        assert!(state.model_list);
+                        assert_eq!(state.focused_model.as_deref(), Some("gpt-5.3-codex"));
+                        assert!(state.focused_model_favorite);
+                    })?;
+                    capture(
+                        window.into(),
+                        cx,
+                        &output,
+                        "compact-favorite-keyboard.png",
+                    )?;
+
+                    press(window.into(), cx, "cmd-shift-f")?;
+                    pause(cx).await;
+                    window.update(cx, |view, _, cx| {
+                        let state = view.pickers.read(cx).fixture_compact_state(cx);
+                        assert_eq!(state.focused_model.as_deref(), Some("gpt-5.3-codex"));
+                        assert!(!state.focused_model_favorite);
+                    })?;
+                    capture(
+                        window.into(),
+                        cx,
+                        &output,
+                        "compact-favorite-removed-keyboard.png",
+                    )?;
+
+                    // Repeat the keyboard paths at the opposite visual and
+                    // geometry extreme so the dense controls are exercised,
+                    // rather than only photographed, in the narrow layout.
+                    press(window.into(), cx, "escape")?;
+                    window.update(cx, |view, window, cx| {
+                        appearance::set_mode(appearance::AppearanceMode::Light, cx);
+                        window.resize(size(px(360.0), px(560.0)));
+                        view.title = "Compact picker · light narrow keyboard";
+                        cx.notify();
+                    })?;
+                    // Fast turns back off, then Effort moves to its lowest level.
+                    for key in ["down", "enter", "down", "home"] {
+                        press(window.into(), cx, key)?;
+                    }
+                    pause(cx).await;
+                    window.update(cx, |view, _, cx| {
+                        let state = view.pickers.read(cx).fixture_compact_state(cx);
+                        assert!(!state.fast);
+                        assert_eq!(state.reasoning, Some(zeron_proto::ReasoningLevel::Low));
+                    })?;
+                    capture(
+                        window.into(),
+                        cx,
+                        &output,
+                        "compact-effort-keyboard-light-narrow.png",
+                    )?;
+
+                    for key in ["up", "up", "enter", "down", "cmd-shift-f"] {
+                        press(window.into(), cx, key)?;
+                    }
+                    pause(cx).await;
+                    window.update(cx, |view, _, cx| {
+                        let state = view.pickers.read(cx).fixture_compact_state(cx);
+                        assert!(state.model_list);
+                        assert_eq!(state.focused_model.as_deref(), Some("gpt-5.3-codex"));
+                        assert!(state.focused_model_favorite);
+                    })?;
+                    capture(
+                        window.into(),
+                        cx,
+                        &output,
+                        "compact-favorite-keyboard-light-narrow.png",
+                    )?;
+
+                    std::fs::write(
+                        output.join("result.txt"),
+                        "PASS: compact picker panel/list layout at dark/light and narrow/wide sizes; keyboard effort, fast tier, and favorite identity behavior.\n",
+                    )?;
+                    Ok(())
+                }
+                .await;
+                if let Err(error) = result {
+                    eprintln!("compact picker fixture failed: {error:#}");
+                }
+                cx.update(|cx| cx.quit());
+            })
+            .detach();
+        });
+    Ok(())
+}
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index fcb7c0c18b..658db0e7df 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -392,7 +392,7 @@ pub const CLUSTER_Y_DELTA: f32 =
     ACTIONS_BOTTOM_PAD + 16.0 + PILL_BORDER_V / 2.0 - COMPACT_TOTAL_HEIGHT / 2.0;
 
 /// Attachment and Send share an outer inset: compact 8px, expanded 12px.
-/// Glide both edges together while the model picker changes groups.
+/// Keep both action groups aligned with the changing surface inset.
 pub const CLUSTER_X_DELTA: f32 = 4.0;
 /// Optical join between the picker group and the paperclip. This is tighter
 /// than the structural spacing ladder because the narrow paperclip glyph
@@ -401,17 +401,6 @@ pub const ACTION_UTILITY_GAP: f32 = 2.0;
 /// Structural separation between utility actions and the primary Send action.
 pub const ACTION_PRIMARY_GAP: f32 = Theme::SPACE_SM;
 
-/// Fade out at the old endpoint, relocate while invisible, then fade in at
-/// the new endpoint. Only a six-pixel nudge is visible; a long label never
-/// sweeps across the prompt. Compact amount is reversible with the shared clock.
-fn model_handoff(compact: f32) -> (f32, f32, f32) {
-    let compact = compact.clamp(0.0, 1.0);
-    let side = if compact < 0.5 { 0.0 } else { 1.0 };
-    let opacity = ((compact - 0.5).abs() - 0.06).max(0.0) / 0.44;
-    let drift = (1.0 - opacity) * if side == 0.0 { 6.0 } else { -6.0 };
-    (side, opacity, drift)
-}
-
 /// The shared outer inset for the in-flight morph: eases from the OLD mode's resting
 /// inset to the committed mode's (compact 8 ↔ expanded 12).
 pub fn morph_cluster_inset(expanded: bool, progress: f32) -> f32 {
@@ -5376,9 +5365,7 @@ pub struct Composer {
     /// Pill height actually rendered last frame — a committed flip morphs
     /// from here, so mid-flight reversals hand off without a jump.
     last_rendered_height: f32,
-    model_handoff_position: f32,
-    model_handoff_from: f32,
-    model_handoff_morph: Option<FlipMorph>,
+    #[cfg(test)]
     model_bounds: Rc<std::cell::Cell<Option<Bounds<Pixels>>>>,
     dock_frame: Option<crate::composer_dock::DockFrame>,
     dock_reflow: crate::composer_dock::DockReflow,
@@ -5597,9 +5584,7 @@ impl Composer {
             settle_task: None,
             flip_morph: None,
             last_rendered_height: 0.0,
-            model_handoff_position: 1.0,
-            model_handoff_from: 1.0,
-            model_handoff_morph: None,
+            #[cfg(test)]
             model_bounds: Default::default(),
             dock_frame: None,
             dock_reflow: Default::default(),
@@ -9412,31 +9397,9 @@ impl Render for Composer {
         // The pill's bottom edge is stationary on screen (the composer sits at
         // the bottom of the shell column; growth moves the TOP edge), so the
         // controls pin to the bottom and only the text glides with the reveal
-        // (round-9 follow-up: the send/attach/chips must not ride the height,
-        // while the model picker fades between its two horizontal anchors).
+        // while the model selector stays in the right action group.
         let cluster_dy = morph_cluster_dy(layout_morph_t);
         let action_inset = morph_cluster_inset(expanded, layout_morph_t);
-        // Share the height/route timeline instead of starting an independent
-        // animation. Reversals continue from the current handoff phase.
-        if self.model_handoff_morph != self.flip_morph {
-            self.model_handoff_from = self.model_handoff_position;
-            self.model_handoff_morph = self.flip_morph;
-        }
-        let compact_target = if expanded { 0.0 } else { 1.0 };
-        self.model_handoff_position = if dock_owns_layout {
-            dock_compact_amount
-        } else {
-            self.flip_morph.map_or(compact_target, |morph| {
-                motion::lerp(
-                    self.model_handoff_from,
-                    compact_target,
-                    motion::EASE_IN_OUT.eval(morph.raw(now_ms)),
-                )
-            })
-        };
-        // The shell supplies this frame's animated width before rendering us.
-        // Measured bounds still belong to the previous frame here; using them
-        // would add the per-frame width delta to the model selector's glide.
         let surface_width = self.last_available_width.map_or_else(
             || {
                 self.surface_bounds
@@ -9447,37 +9410,23 @@ impl Render for Composer {
             },
             |width| (width - 2.0 * Theme::SPACE_LG).max(0.0),
         );
-        let model_travel = (surface_width
-            - PILL_BORDER_V
-            - action_inset
-            - 28.0
-            - ACTION_UTILITY_GAP
-            - self
-                .model_bounds
-                .get()
-                .map_or(0.0, |bounds| f32::from(bounds.size.width))
-            - ACTION_PRIMARY_GAP
-            - 28.0
-            - action_inset)
-            .max(0.0);
-        let (model_side, model_opacity, model_drift) = model_handoff(self.model_handoff_position);
-        let model_offset = (model_side - compact_target) * model_travel + model_drift;
-        let measured_model_bounds = self.model_bounds.clone();
         let model_picker = div()
             .min_w_0()
             .max_w(px(surface_width * 0.45))
             .relative()
-            .left(px(model_offset))
-            .opacity(model_opacity)
-            .child(self.pickers.clone())
-            .child(
+            .child(self.pickers.clone());
+        #[cfg(test)]
+        let model_picker = {
+            let measured_model_bounds = self.model_bounds.clone();
+            model_picker.child(
                 gpui::canvas(
                     move |bounds, _, _| measured_model_bounds.set(Some(bounds)),
                     |_, _, _, _| {},
                 )
                 .absolute()
                 .inset_0(),
-            );
+            )
+        };
         let body = if expanded {
             // Expanded: textarea on top (`px-4 pb-1 pt-4`), actions row
             // (8px bottom + 2px top, 32px chips → 42px) ABSOLUTE at the pill's
@@ -9486,7 +9435,7 @@ impl Render for Composer {
             // text viewport follows the animated height so it cannot paint
             // over the controls. Its width stays fixed (no tween rewraps);
             // top padding eases 12→16. Attachment and Send stay on the bottom
-            // anchor while the model chip fades between its horizontal slots.
+            // anchor with the model selector always beside Send.
             pill.h(px(pill_height))
                 .overflow_hidden()
                 .relative()
@@ -9515,9 +9464,7 @@ impl Render for Composer {
                         .flex()
                         .flex_row()
                         .items_center()
-                        // Shared group geometry (see CLUSTER_X_DELTA): the
-                        // attachment belongs to the utility pickers, while
-                        // Send has a larger structural separation.
+                        // Attachment stays left; model and Send stay right.
                         .gap(px(ACTION_PRIMARY_GAP))
                         .px(px(action_inset))
                         .pt(px(2.0))
@@ -9530,9 +9477,9 @@ impl Render for Composer {
                                 .flex_row()
                                 .items_center()
                                 .gap(px(ACTION_UTILITY_GAP))
-                                .child(attach)
-                                .child(model_picker),
+                                .child(attach),
                         )
+                        .child(model_picker)
                         .child(send_button),
                 )
         } else {
@@ -9542,7 +9489,7 @@ impl Render for Composer {
             // top sweeps down over a stationary row, the text walks down from
             // its expanded resting place via a decaying relative offset, and
             // attachment/Send hold their spots (the centering delta gliding
-            // in), with the model handoff sharing that same timeline.
+            // in). The model selector remains beside Send.
             let text_glide = if dock_owns_layout {
                 collapse_text_glide(dock_layout.hero_height, dock_compact_amount)
             } else {
@@ -9838,83 +9785,72 @@ mod tests {
         let input = handle
             .read_with(cx, |composer, _| composer.input.clone())
             .unwrap();
-        for thread_width in [436.0, 592.0, 768.0, 1232.0] {
-            for docked in [true, false] {
-                let amounts = if docked {
-                    [0.0, 0.2, 0.6, 0.98, 1.0]
-                } else {
-                    [1.0, 0.98, 0.6, 0.2, 0.0]
-                };
-                for amount in amounts {
-                    let outer_width = motion::lerp(COMPOSER_MAX_WIDTH, thread_width, amount);
-                    cx.update(|cx| {
-                    handle
-                        .update(cx, |composer, window, cx| {
-                            window.resize(size(px(outer_width), px(800.0)));
-                            composer.set_available_width(outer_width, cx);
-                            composer.state.update(cx, |state, _| {
-                                state.selected_chat = docked.then(|| "chat".into());
-                            });
-                            composer.on_state_changed(cx);
-                            composer
-                                .input
-                                .update(cx, |input, cx| input.set_text("Hi", cx));
-                            composer.expanded_mode = false;
-                            let mut frame = crate::composer_dock::DockFrame::settled(docked);
-                            frame.amount = amount;
-                            frame.active = amount != if docked { 1.0 } else { 0.0 };
-                            composer.set_dock_frame(frame, cx);
+        // The trigger stays beside Send whichever picker the chip opens.
+        for compact_picker in [false, true] {
+            cx.update(|cx| {
+                crate::settings::update(crate::settings::SavePolicy::Debounced, cx, |settings| {
+                    settings.compact_model_picker = compact_picker;
+                });
+            });
+            for thread_width in [436.0, 592.0, 768.0, 1232.0] {
+                for docked in [true, false] {
+                    let amounts = if docked {
+                        [0.0, 0.2, 0.6, 0.98, 1.0]
+                    } else {
+                        [1.0, 0.98, 0.6, 0.2, 0.0]
+                    };
+                    for amount in amounts {
+                        let outer_width = motion::lerp(COMPOSER_MAX_WIDTH, thread_width, amount);
+                        cx.update(|cx| {
+                        handle
+                            .update(cx, |composer, window, cx| {
+                                window.resize(size(px(outer_width), px(800.0)));
+                                composer.set_available_width(outer_width, cx);
+                                composer.state.update(cx, |state, _| {
+                                    state.selected_chat = docked.then(|| "chat".into());
+                                });
+                                composer.on_state_changed(cx);
+                                composer
+                                    .input
+                                    .update(cx, |input, cx| input.set_text("Hi", cx));
+                                composer.expanded_mode = false;
+                                let mut frame = crate::composer_dock::DockFrame::settled(docked);
+                                frame.amount = amount;
+                                frame.active = amount != if docked { 1.0 } else { 0.0 };
+                                composer.set_dock_frame(frame, cx);
+                            })
+                            .unwrap();
+                        cx.update_window(handle.into(), |_, window, cx| {
+                            window.refresh();
+                            window.draw(cx).clear();
                         })
                         .unwrap();
-                    cx.update_window(handle.into(), |_, window, cx| {
-                        window.refresh();
-                        window.draw(cx).clear();
-                    })
-                    .unwrap();
-                    // Inspect the first painted frame before TestAppContext
-                    // flushes effects and automatically draws dirty views.
-                    handle.read_with(cx, |composer, cx| {
-                    assert_eq!(composer.input, input);
-                    let surface = composer.surface_bounds.get().unwrap();
-                    assert!((f32::from(surface.size.width) - (outer_width - 2.0 * Theme::SPACE_LG)).abs() <= 1.0,
-                        "surface width clipped: docked={docked}, amount={amount}, outer={outer_width}, surface={surface:?}");
-                    let origin = input.read(cx).last_bounds.unwrap().origin;
-                    assert!((f32::from(origin.y - surface.top()) - (17.0 - 4.0 * amount)).abs() <= 1.0,
-                        "editor jumped: docked={docked}, amount={amount}, origin={origin:?}, surface={surface:?}");
-                    let model = composer.model_bounds.get().unwrap();
-                    let inset = motion::lerp(12.0, 8.0, amount);
-                    let left = surface.left() + px(1.0 + inset + 28.0 + ACTION_UTILITY_GAP);
-                    let travel = surface.size.width - px(2.0 + inset + 28.0 + ACTION_UTILITY_GAP
-                        + ACTION_PRIMARY_GAP + 28.0 + inset) - model.size.width;
-                    let (side, _, drift) = model_handoff(amount);
-                    let expected_x = left + travel * side + px(drift);
-                    assert!((f32::from(model.left() - expected_x)).abs() <= 1.0,
-                        "model jumped: docked={docked}, amount={amount}, actual={model:?}, expected={expected_x:?}");
-                    let expected = if docked { COMPACT_TOTAL_HEIGHT } else { COMPOSER_MIN_HEIGHT };
-                    assert!((composer.last_rendered_height + composer.dock_clearance_correction - expected).abs() < 0.1);
-                    assert!((composer.last_rendered_height - motion::lerp(COMPOSER_MIN_HEIGHT, COMPACT_TOTAL_HEIGHT, amount)).abs() < 0.1);
-                        }).unwrap();
-                    });
+                        // Inspect the first painted frame before TestAppContext
+                        // flushes effects and automatically draws dirty views.
+                        handle.read_with(cx, |composer, cx| {
+                        assert_eq!(composer.input, input);
+                        let surface = composer.surface_bounds.get().unwrap();
+                        assert!((f32::from(surface.size.width) - (outer_width - 2.0 * Theme::SPACE_LG)).abs() <= 1.0,
+                            "surface width clipped: docked={docked}, amount={amount}, outer={outer_width}, surface={surface:?}");
+                        let origin = input.read(cx).last_bounds.unwrap().origin;
+                        assert!((f32::from(origin.y - surface.top()) - (17.0 - 4.0 * amount)).abs() <= 1.0,
+                            "editor jumped: docked={docked}, amount={amount}, origin={origin:?}, surface={surface:?}");
+                        let model = composer.model_bounds.get().unwrap();
+                        let inset = motion::lerp(12.0, 8.0, amount);
+                        let expected_right = surface.right() - px(1.0 + inset + 28.0 + ACTION_PRIMARY_GAP);
+                        assert!((f32::from(model.right() - expected_right)).abs() <= 1.0,
+                            "model must stay right aligned: compact_picker={compact_picker}, docked={docked}, amount={amount}, actual={model:?}, expected={expected_right:?}");
+                        let expected = if docked { COMPACT_TOTAL_HEIGHT } else { COMPOSER_MIN_HEIGHT };
+                        assert!((composer.last_rendered_height + composer.dock_clearance_correction - expected).abs() < 0.1);
+                        assert!((composer.last_rendered_height - motion::lerp(COMPOSER_MIN_HEIGHT, COMPACT_TOTAL_HEIGHT, amount)).abs() < 0.1);
+                            }).unwrap();
+                        });
+                    }
                 }
             }
         }
     }
 
-    #[test]
-    fn model_handoff_hides_relocation_and_keeps_visible_motion_local() {
-        assert_eq!(model_handoff(0.0), (0.0, 1.0, 0.0));
-        assert_eq!(model_handoff(1.0), (1.0, 1.0, -0.0));
-        for amount in [0.44, 0.49, 0.50, 0.51, 0.56] {
-            assert!(model_handoff(amount).1 < 0.0001);
-        }
-        for step in 0..=100 {
-            let (side, opacity, drift) = model_handoff(step as f32 / 100.0);
-            assert!((0.0..=1.0).contains(&opacity));
-            assert!(drift.abs() <= 6.0);
-            assert!(side == 0.0 || side == 1.0);
-        }
-    }
-
     #[gpui::test]
     fn dock_reflow_paints_attachment_wrap_without_a_height_jump(cx: &mut gpui::TestAppContext) {
         let (_dir, handle) = composer_focus_window(cx);
@@ -10042,7 +9978,6 @@ mod tests {
                         "text growth jumped from {before} to {}",
                         composer.last_rendered_height
                     );
-                    assert!((composer.model_handoff_position - 0.7).abs() < 0.001);
                     assert!(
                         (f32::from(composer.model_bounds.get().unwrap().left() - model_before))
                             .abs()
@@ -10136,10 +10071,10 @@ mod tests {
             .read_with(cx, |composer, _| {
                 let surface = composer.surface_bounds.get().unwrap();
                 let model = composer.model_bounds.get().unwrap();
-                let left = surface.left() + px(1.0 + 12.0 + 28.0 + ACTION_UTILITY_GAP);
+                let right = surface.right() - px(1.0 + 12.0 + 28.0 + ACTION_PRIMARY_GAP);
                 assert!(
-                    (f32::from(model.left() - left)).abs() <= 1.0,
-                    "expanded controls must finish on the left"
+                    (f32::from(model.right() - right)).abs() <= 1.0,
+                    "expanded controls must remain on the right"
                 );
             })
             .unwrap();
diff --git a/crates/ui/src/edge_fade.rs b/crates/ui/src/edge_fade.rs
index c78b8999e7..d59b0e6f9e 100644
--- a/crates/ui/src/edge_fade.rs
+++ b/crates/ui/src/edge_fade.rs
@@ -63,6 +63,7 @@ pub fn edge_faded(band: f32, top: bool, bottom: bool, child: impl IntoElement) -
         overflow_y: None,
         scroll_x: None,
         smooth_overflow_x: false,
+        grow_x: false,
         child: child.into_any_element(),
     }
 }
@@ -81,6 +82,7 @@ pub struct EdgeFaded {
     overflow_y: Option<Box<dyn Fn(&App) -> (bool, bool)>>,
     scroll_x: Option<ScrollHandle>,
     smooth_overflow_x: bool,
+    grow_x: bool,
     child: AnyElement,
 }
 
@@ -139,6 +141,16 @@ impl EdgeFaded {
         self
     }
 
+    /// [`Self::fade_overflow_x`] for a scrolling strip: each side's ramp is
+    /// as wide as the content hidden past it, up to the band. The ramp still
+    /// reaches zero exactly at the clip edge, but a strip scrolled by 2 px
+    /// dims 2 px instead of a whole band — no snap as the fade switches on.
+    pub fn fade_scroll_x(mut self, handle: &ScrollHandle) -> Self {
+        self.scroll_x = Some(handle.clone());
+        self.grow_x = true;
+        self
+    }
+
     /// Ease a right-edge label fade into view as overflow grows from zero to
     /// one band. Unlike scroll chrome, a label should not suddenly dim its
     /// final characters as soon as it becomes a fraction too wide.
@@ -221,7 +233,17 @@ impl Element for EdgeFaded {
         }
         let (mut left, mut right) = (self.left, self.right);
         let mut outset_right = 0.0;
-        if let Some(scroll) = &self.scroll_x {
+        let (mut band_left, mut band_right) = (None, None);
+        if let Some(scroll) = &self.scroll_x
+            && self.grow_x
+        {
+            let hidden_left = (-f32::from(scroll.offset().x)).max(0.0);
+            let hidden_right = (f32::from(scroll.max_offset().x) - hidden_left).max(0.0);
+            left &= hidden_left > 0.5;
+            right &= hidden_right > 0.5;
+            band_left = Some(px(hidden_left.min(self.band)));
+            band_right = Some(px(hidden_right.min(self.band)));
+        } else if let Some(scroll) = &self.scroll_x {
             let scrolled = -f32::from(scroll.offset().x);
             let max_scroll = f32::from(scroll.max_offset().x);
             left &= scrolled > 1.0;
@@ -246,6 +268,8 @@ impl Element for EdgeFaded {
                 band: px(self.band),
                 band_top: self.band_top.map(px),
                 band_bottom: self.band_bottom.map(px),
+                band_left,
+                band_right,
                 top,
                 bottom,
                 left,
diff --git a/crates/ui/src/glass.rs b/crates/ui/src/glass.rs
new file mode 100644
index 0000000000..68df45fee9
--- /dev/null
+++ b/crates/ui/src/glass.rs
@@ -0,0 +1,161 @@
+//! Glass surfaces shared by controls: each is a vertical gradient (lit from
+//! above), a hairline rim, an inner top highlight, and a soft drop. Dark
+//! appearances keep the structure with translucent white instead of opaque
+//! fills. `light` is the neutral plate (a track), `accent` the active plate
+//! (Stop, an enabled switch, a slider's fill) and `thumb` the opaque handle
+//! that rides on either.
+use gpui::{
+    Background, Bounds, BoxShadow, Corners, Hsla, Pixels, Styled, Window, hsla, linear_color_stop,
+    linear_gradient, point, px,
+};
+
+use crate::theme::Theme;
+
+fn shadow(color: Hsla, y: f32, blur: f32, spread: f32, inset: bool) -> BoxShadow {
+    BoxShadow {
+        color,
+        offset: point(px(0.0), px(y)),
+        blur_radius: px(blur),
+        spread_radius: px(spread),
+        inset,
+    }
+}
+
+fn white(alpha: f32) -> Hsla {
+    hsla(0.0, 0.0, 1.0, alpha)
+}
+
+fn black(alpha: f32) -> Hsla {
+    hsla(0.0, 0.0, 0.0, alpha)
+}
+
+fn vertical(top: Hsla, bottom: Hsla) -> Background {
+    linear_gradient(
+        180.0,
+        linear_color_stop(top, 0.0),
+        linear_color_stop(bottom, 1.0),
+    )
+}
+
+/// A lighter tint of `color` for the lit top of a gradient.
+fn lift(color: Hsla, amount: f32) -> Hsla {
+    crate::motion::mix(color, white(color.a), amount)
+}
+
+/// One glass surface, applicable to an element or paintable in a canvas.
+pub(crate) struct Plate {
+    background: Background,
+    rim: Hsla,
+    shadows: Vec<BoxShadow>,
+}
+
+impl Plate {
+    pub(crate) fn apply<E: Styled>(self, el: E) -> E {
+        el.bg(self.background)
+            .border_1()
+            .border_color(self.rim)
+            .shadow(self.shadows)
+    }
+
+    /// Paints the plate the way a styled element would: drops beneath the
+    /// fill, the rim on it, and inset light above it.
+    pub(crate) fn paint(&self, window: &mut Window, bounds: Bounds<Pixels>, radius: f32) {
+        let corners = Corners::all(px(radius));
+        let (inset, drop): (Vec<_>, Vec<_>) = self.shadows.iter().cloned().partition(|s| s.inset);
+        window.paint_drop_shadows(bounds, corners, &drop);
+        window.paint_quad(gpui::quad(
+            bounds,
+            corners,
+            self.background,
+            px(1.0),
+            self.rim,
+            gpui::BorderStyle::default(),
+        ));
+        window.paint_inset_shadows(bounds, corners, &inset);
+    }
+}
+
+/// Neutral glass. `t` fades the whole treatment in. Dark appearances lift
+/// translucent white off the surface; light ones sink a translucent tint
+/// into it (shaded under the top edge, lit inside the bottom edge), since a
+/// near-white plate on a near-white surface washes out.
+pub(crate) fn light_plate(theme: &Theme, t: f32) -> Plate {
+    if theme.appearance.is_dark() {
+        return Plate {
+            background: vertical(white(0.08 * t), white(0.05 * t)),
+            rim: white(0.09 * t),
+            shadows: vec![
+                shadow(white(0.07 * t), 1.0, 0.0, 0.0, true),
+                shadow(black(0.16 * t), 1.0, 2.0, 0.0, false),
+            ],
+        };
+    }
+    Plate {
+        background: vertical(black(0.075 * t), black(0.04 * t)),
+        rim: black(0.08 * t),
+        // Inset only: GPUI paints drop shadows under the whole box, so an
+        // outer lip would show through the translucent fill and whiten it.
+        shadows: vec![
+            shadow(black(0.08 * t), 1.0, 2.0, 0.0, true),
+            shadow(white(0.55 * t), -1.0, 0.0, 0.0, true),
+        ],
+    }
+}
+
+/// Accent glass. `t` fades it in over the resting control; `glow` (0–1)
+/// spreads its coloured shadow.
+pub(crate) fn accent_plate(theme: &Theme, t: f32, glow: f32) -> Plate {
+    let dark = theme.appearance.is_dark();
+    // The theme's fill token, as every other accent fill uses. Dark plates
+    // keep their lighting faint so the token reads as itself, not a pastel.
+    let base = theme.accent_strong;
+    let top = lift(base, if dark { 0.06 } else { 0.22 });
+    // Light: a defined edge a shade deeper than the fill, with a paler ring
+    // just inside it. Dark: a soft lifted rim.
+    let rim = if dark {
+        lift(base, 0.35).opacity(0.35)
+    } else {
+        crate::motion::mix(base, black(1.0), 0.14)
+    };
+    let highlight = white(if dark { 0.12 } else { 0.32 });
+    let ring = white(if dark { 0.0 } else { 0.22 });
+    // Dark plates sit flat at rest; light ones keep a faint coloured glow.
+    let halo = base.opacity((if dark { 0.0 } else { 0.14 } + 0.3 * glow) * t);
+    Plate {
+        background: vertical(top.opacity(t), base.opacity(t)),
+        rim: rim.opacity(t),
+        shadows: vec![
+            shadow(highlight.opacity(t), 1.0, 0.0, 0.0, true),
+            shadow(ring.opacity(t), 0.0, 0.0, 1.0, true),
+            shadow(halo, 2.0 + 2.0 * glow, 6.0 + 14.0 * glow, 0.0, false),
+        ],
+    }
+}
+
+/// The opaque handle: the light-appearance neutral plate in every
+/// appearance, so it stays solid over translucent dark glass, with the
+/// appearance's own drop beneath it.
+pub(crate) fn thumb_plate(theme: &Theme) -> Plate {
+    let dark = theme.appearance.is_dark();
+    let mut shadows = vec![
+        shadow(white(0.8), 1.0, 0.0, 0.0, true),
+        shadow(black(if dark { 0.22 } else { 0.14 }), 1.0, 2.0, 0.0, false),
+    ];
+    if !dark {
+        // A wide, faint ambient drop separates it from pale tracks.
+        shadows.push(shadow(black(0.06), 2.0, 6.0, 0.0, false));
+    }
+    Plate {
+        background: vertical(hsla(0.0, 0.0, 1.0, 1.0), hsla(0.0, 0.0, 0.965, 1.0)),
+        rim: black(if dark { 0.12 } else { 0.11 }),
+        shadows,
+    }
+}
+
+pub(crate) fn light<E: Styled>(el: E, theme: &Theme, t: f32) -> E {
+    light_plate(theme, t).apply(el)
+}
+
+pub(crate) fn thumb<E: Styled>(el: E, theme: &Theme) -> E {
+    thumb_plate(theme).apply(el)
+}
diff --git a/crates/ui/src/haptics.rs b/crates/ui/src/haptics.rs
new file mode 100644
index 0000000000..ae2ae19b03
--- /dev/null
+++ b/crates/ui/src/haptics.rs
@@ -0,0 +1,29 @@
+//! Discrete native feedback for user-driven control detents.
+
+pub(crate) fn selection_step() {
+    #[cfg(all(target_os = "macos", not(test)))]
+    {
+        use objc2_app_kit::{
+            NSHapticFeedbackManager, NSHapticFeedbackPattern, NSHapticFeedbackPerformanceTime,
+            NSHapticFeedbackPerformer,
+        };
+        // UI input handlers run on the main thread. AppKit gracefully does
+        // nothing on devices without a haptic-capable trackpad.
+        if objc2::MainThreadMarker::new().is_some() {
+            NSHapticFeedbackManager::defaultPerformer().performFeedbackPattern_performanceTime(
+                NSHapticFeedbackPattern::LevelChange,
+                NSHapticFeedbackPerformanceTime::Now,
+            );
+        }
+    }
+    #[cfg(test)]
+    STEPS.with(|steps| steps.set(steps.get() + 1));
+}
+
+#[cfg(test)]
+thread_local! { static STEPS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; }
+
+#[cfg(test)]
+pub(crate) fn step_count() -> usize {
+    STEPS.with(|steps| steps.get())
+}
diff --git a/crates/ui/src/icons.rs b/crates/ui/src/icons.rs
index f747fec383..b211fc05e1 100644
--- a/crates/ui/src/icons.rs
+++ b/crates/ui/src/icons.rs
@@ -50,8 +50,10 @@ macro_rules! icon_assets {
 icon_assets![
     (PROJECT_DEFAULT, "project-default"),
     (REMOTE_SERVER, "remote-server"),
-    // Service-tier bolt, drawn in the toolbar family's linear weight.
+    // Service-tier bolt, drawn in the toolbar family's linear weight; the
+    // filled twin marks fast mode on.
     (FAST_TIER, "fast-tier"),
+    (FAST_TIER_BOLD, "fast-tier-bold"),
     // Solar Icons (Linear), CC BY 4.0 — 480 Design.
     (MONITOR, "monitor"),
     (SUN, "sun"),
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index 79a33d9886..e41a30df09 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -32,6 +32,8 @@ pub mod edge_fade;
 pub mod file_icons;
 pub mod files;
 pub mod frost;
+mod glass;
+mod haptics;
 pub mod history;
 pub mod icons;
 pub(crate) mod image_media;
diff --git a/crates/ui/src/motion.rs b/crates/ui/src/motion.rs
index 3363911098..3726af509c 100644
--- a/crates/ui/src/motion.rs
+++ b/crates/ui/src/motion.rs
@@ -547,6 +547,35 @@ where
     })
 }
 
+/// [`menu_in`] travelling from the trigger's side: `from` is the signed
+/// starting offset (negative above the resting place for dropdowns,
+/// positive below it for menus that open upward).
+pub fn menu_in_from<E>(id: impl Into<ElementId>, from: f32, element: E) -> AnimationElement<E>
+where
+    E: Styled + IntoElement + 'static,
+{
+    element.with_animation(id, MENU_IN.animation(), move |el, t| {
+        el.relative()
+            .opacity(0.3 + 0.7 * t)
+            .top(px(from * (1.0 - t)))
+    })
+}
+
+/// [`menu_out`] retreating toward the trigger by half the entrance travel.
+pub fn menu_out_toward<E>(
+    id: impl Into<ElementId>,
+    toward: f32,
+    t: f32,
+    element: E,
+) -> AnimationElement<E>
+where
+    E: Styled + IntoElement + 'static,
+{
+    element.with_animation(id, MENU_OUT.animation(), move |el, _| {
+        el.relative().opacity(1.0 - t).top(px(toward * 0.5 * t))
+    })
+}
+
 /// Popover exit: the reverse of [`menu_in`] — fade to 0 + translateY 0→−2 over
 /// [`MENU_OUT`]. Unlike the entrances, the eased progress `t` comes from the
 /// caller (computed off [`crate::popover::Popup`]'s closing instant at render
@@ -1419,3 +1448,13 @@ mod tests {
 #[cfg(windows)]
 #[path = "motion/windows_pulse.rs"]
 mod windows_pulse;
+
+/// A bounded activation sheen for Fast service tier; GPUI handles reduced motion.
+pub fn fast_tier(
+    id: impl Into<ElementId>,
+    element: impl IntoElement + gpui::Styled + 'static,
+) -> impl IntoElement {
+    element.with_animation(id, Animation::new(Duration::from_millis(700)), |el, t| {
+        el.opacity(1.0 - 0.35 * (1.0 - t) * (std::f32::consts::PI * t).sin())
+    })
+}
diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index ff7e800f6a..1bd2389404 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -11,6 +11,8 @@
 //! in free functions with unit tests; RPC results land in [`Loadable`] slots
 //! rendered as skeletons / inline errors with Retry.
 
+mod compact;
+
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::time::Duration;
@@ -364,6 +366,7 @@ const NO_ACTIVE_ROW: usize = usize::MAX;
 /// state; clicking a brand icon picks that harness.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 enum ModelRail {
+    All,
     Favorites,
     #[default]
     Harness,
@@ -526,8 +529,20 @@ pub struct Pickers {
     menu_geometry: HashMap<PickerKind, popover::MenuGeometry>,
     model_trigger_bounds: Option<gpui::Bounds<gpui::Pixels>>,
     // Keep the open menu anchored while its selected label and options change.
-    open_model_width: Option<gpui::Pixels>,
+    /// The model chip glides to its content's width as the model, effort
+    /// or fast tier changes; `chip_resizing` clips instead of truncating
+    /// while it moves.
+    chip_width: Option<compact::ScalarTransition>,
+    chip_resizing: bool,
     open_model_height: f32,
+    compact_model_list: bool,
+    /// The compact picker's provider page, entered from the panel's
+    /// provider button; exclusive with [`Self::compact_model_list`].
+    compact_providers: bool,
+    effort_dragging: bool,
+    compact_motion: compact::CompactMotion,
+    compact_keyboard: bool,
+    effort_bounds: Option<gpui::Bounds<gpui::Pixels>>,
     open: popover::Popup<PickerKind>,
     /// The harness/model picker's rail selection (favorites vs the effective
     /// harness's list). Re-primed on every open.
@@ -753,8 +768,15 @@ impl Pickers {
             target_generation: 0,
             menu_geometry: HashMap::new(),
             model_trigger_bounds: None,
-            open_model_width: None,
+            chip_width: None,
+            chip_resizing: false,
             open_model_height: model_menu_height(0),
+            compact_model_list: false,
+            compact_providers: false,
+            effort_dragging: false,
+            compact_motion: compact::CompactMotion::default(),
+            compact_keyboard: false,
+            effort_bounds: None,
             config: DraftConfig::default(),
             title,
             defaults,
@@ -935,8 +957,12 @@ impl Pickers {
         let explicit = self.config.reasoning.or_else(|| {
             match self.state.read(cx).selected_chat_row() {
                 Some(chat) => chat.config.as_ref().and_then(|c| c.reasoning),
-                // New chat: the remembered last-used level.
-                None => self.defaults.reasoning,
+                // New chat: the level last used with this model, else the
+                // last-used level overall.
+                None => self
+                    .effective_harness(cx)
+                    .and_then(|h| self.defaults.reasoning_for(h, self.effective_model_id(cx)))
+                    .or(self.defaults.reasoning),
             }
         });
         if self.selected_model(cx).is_none() {
@@ -1080,6 +1106,7 @@ impl Pickers {
     /// Outside clicks and navigation keep focus at the clicked destination.
     fn dismiss(&mut self, cx: &mut Context<Self>) {
         self.focus_on_mount = false;
+        self.effort_dragging = false;
         self.cancel_setting_hover();
         self.setting_menu = None;
         self.setting_bounds = None;
@@ -1135,8 +1162,12 @@ impl Pickers {
             return;
         }
         if kind == PickerKind::HarnessModel {
-            self.open_model_width = self.model_trigger_bounds.map(|bounds| bounds.size.width);
             self.open_model_height = model_menu_height(self.setting_groups(cx).len());
+            self.compact_model_list = false;
+            self.compact_providers = false;
+            self.effort_dragging = false;
+            self.compact_keyboard = false;
+            self.compact_motion = compact::CompactMotion::default();
         }
         self.open.open(kind);
         self.focus_on_mount = true;
@@ -1171,7 +1202,9 @@ impl Pickers {
             self.config.harness = None;
             self.model_rail = ModelRail::Harness;
         } else if kind == PickerKind::HarnessModel {
-            self.model_rail = if !self.harness_locked(cx) && !self.defaults.favorites.is_empty() {
+            self.model_rail = if self.compact_model_picker(cx) {
+                ModelRail::All
+            } else if !self.harness_locked(cx) && !self.defaults.favorites.is_empty() {
                 ModelRail::Favorites
             } else {
                 ModelRail::Harness
@@ -1635,7 +1668,7 @@ impl Pickers {
             // provider settings so both the picker and first createChat use the
             // new harness, even when its model catalog has not loaded yet.
             let model = self.defaults.model_for(harness).map(|m| m.id.clone());
-            let reasoning = self.defaults.reasoning;
+            let reasoning = self.defaults.reasoning_for(harness, model.as_deref());
             let options = model
                 .as_deref()
                 .and_then(|model| self.defaults.model_options_for(harness, model))
@@ -1688,7 +1721,9 @@ impl Pickers {
             self.update_chat_config(cx, move |config| config.model = Some(model_id));
         } else {
             // New chat: draft pick + sticky last-used memory for this harness.
+            // Effort follows the model: its own remembered level, if any.
             self.config.model = Some(model_id.clone());
+            self.config.reasoning = None;
             if let Some(harness) = self.effective_harness(cx) {
                 let label = self
                     .models
@@ -1710,7 +1745,13 @@ impl Pickers {
             self.update_chat_config(cx, move |config| config.reasoning = Some(level));
         } else {
             self.config.reasoning = Some(level);
-            self.defaults.reasoning = Some(level);
+            if let Some(harness) = self.effective_harness(cx) {
+                let model = self.effective_model_id(cx).map(str::to_owned);
+                self.defaults
+                    .remember_reasoning(harness, model.as_deref(), level);
+            } else {
+                self.defaults.reasoning = Some(level);
+            }
             self.save_defaults();
         }
         cx.notify();
@@ -1996,6 +2037,10 @@ impl Pickers {
     fn activate_model_row(&mut self, cx: &mut Context<Self>) {
         if self.setting_menu.is_some() {
             self.activate_setting_choice(cx);
+        } else if self.compact_model_picker(cx) && self.compact_providers {
+            self.activate_compact_provider(cx);
+        } else if self.compact_model_picker(cx) && self.compact_model_list {
+            self.activate_model_index(self.active, cx);
         } else if let Some(index) = self.active.checked_sub(self.model_rows_len(cx)) {
             if let Some(group) = self.setting_groups(cx).get(index) {
                 self.open_setting(SettingScope::Tray, group.id.clone(), cx);
@@ -2022,20 +2067,35 @@ impl Pickers {
             self.pick_harness(row.harness, cx);
         }
         self.pick_model(row.model.id, cx);
+        if self.compact_model_picker(cx) {
+            self.compact_model_list = false;
+            self.focus_on_mount = true;
+        }
     }
 
     /// Star/unstar a model and persist it with the sticky defaults.
     fn toggle_model_favorite(&mut self, harness: HarnessId, model: &str, cx: &mut Context<Self>) {
         self.reload_defaults();
+        let keyboard_row = (self.compact_model_picker(cx) && self.compact_keyboard)
+            .then(|| self.model_rows(cx).get(self.active).cloned())
+            .flatten();
         self.defaults.toggle_favorite(harness, model);
         self.persist_defaults();
         self.catalog_rev += 1;
-        // Starring REORDERS the list (stars float to the top / leave the
-        // favorites view) — re-home the keyboard highlight onto the SELECTED
-        // row so exactly one row reads highlighted afterwards. Following the
-        // starred row instead left its cursor wash next to the selected
-        // row's ring: "two highlighted rows" (user report, twice).
+        // Pointer interactions retain the selected-row highlight after sorting.
         self.active = self.selected_model_index(cx);
+        // Keyboard focus follows identity, independently of selection styling.
+        if let Some(row) = keyboard_row {
+            self.active = self
+                .model_rows(cx)
+                .iter()
+                .position(|candidate| {
+                    candidate.harness == row.harness && candidate.model.id == row.model.id
+                })
+                .unwrap_or(self.active);
+            self.model_scroll
+                .scroll_to_item(self.active, gpui::ScrollStrategy::Nearest);
+        }
         cx.notify();
     }
 
@@ -2513,6 +2573,23 @@ impl Pickers {
         if !self.open.is_open() {
             return;
         }
+        if self.open_kind() == Some(PickerKind::HarnessModel) && self.compact_model_picker(cx) {
+            // Escape only steps back a page or closes a submenu: it should
+            // not light focus rings on the controls it returns to. The next
+            // navigation key brings them back.
+            self.compact_keyboard = event.keystroke.key != "escape";
+            if self.compact_model_list
+                && event.keystroke.modifiers.platform
+                && event.keystroke.modifiers.shift
+                && event.keystroke.key.eq_ignore_ascii_case("f")
+            {
+                if let Some(row) = self.model_rows(cx).get(self.active).cloned() {
+                    self.toggle_model_favorite(row.harness, &row.model.id, cx);
+                }
+                cx.stop_propagation();
+                return;
+            }
+        }
         if self.setting_menu.is_some() {
             match event.keystroke.key.as_str() {
                 "escape" | "left" => {
@@ -2541,7 +2618,23 @@ impl Pickers {
             cx.notify();
             return;
         }
+        if self.open_kind() == Some(PickerKind::HarnessModel) && self.compact_model_picker(cx) {
+            if self.compact_providers {
+                self.compact_provider_key(event, cx);
+                return;
+            }
+            if !self.compact_model_list {
+                self.compact_panel_key(event, cx);
+                return;
+            }
+            if event.keystroke.key == "escape" {
+                self.show_compact_panel(cx);
+                cx.stop_propagation();
+                return;
+            }
+        }
         if event.keystroke.key == "right"
+            && !self.compact_model_picker(cx)
             && self.open_kind() == Some(PickerKind::HarnessModel)
             && self.active >= self.model_rows_len(cx)
         {
@@ -2579,7 +2672,12 @@ impl Pickers {
                     Some(PickerKind::Checkout) => 2,
                     // Continue from model rows into the pinned settings triggers.
                     Some(PickerKind::HarnessModel) => {
-                        self.model_rows_len(cx) + self.setting_groups(cx).len()
+                        self.model_rows_len(cx)
+                            + if self.compact_model_picker(cx) {
+                                0
+                            } else {
+                                self.setting_groups(cx).len()
+                            }
                     }
                     Some(PickerKind::Space) => self.filtered_space_rows(cx).len() + 1,
                     Some(PickerKind::Device) => self.filtered_device_rows(cx).len(),
@@ -2634,6 +2732,7 @@ impl Pickers {
 
     fn measure_trigger(&self, kind: PickerKind, cx: &Context<Self>) -> impl IntoElement {
         let entity = cx.entity().downgrade();
+        let compact = kind == PickerKind::HarnessModel && self.compact_model_picker(cx);
         // New-thread model and workspace menus open down, matching the
         // centered composer's layout. In-thread menus retain adaptive placement.
         let below = (self.title.is_some() || self.state.read(cx).selected_chat.is_none())
@@ -2654,21 +2753,25 @@ impl Pickers {
                 // Prefer below on the new-chat canvas only when it can fit
                 // useful content. Tall drafts/attachments can put the trigger
                 // near the window bottom; retain adaptive placement there.
-                if below && space_below >= 180.0 {
+                let prefer_below = below && space_below >= 180.0;
+                if prefer_below {
                     geometry = popover::MenuGeometry {
                         height: space_below,
                         below: true,
                     };
                 }
+                // The compact card opens down on the new-chat canvas like the
+                // standard menu, and up from the docked composer.
+                if compact && !prefer_below {
+                    geometry = popover::MenuGeometry {
+                        height: (f32::from(bounds.top()) - 14.0).clamp(0.0, 640.0),
+                        below: false,
+                    };
+                }
                 entity
                     .update(cx, |this, cx| {
                         if kind == PickerKind::HarnessModel {
                             this.model_trigger_bounds = Some(bounds);
-                            if this.mounted_kind() == Some(kind) && this.open_model_width.is_none()
-                            {
-                                this.open_model_width = Some(bounds.size.width);
-                                cx.notify();
-                            }
                         }
                         if this.menu_geometry.get(&kind) != Some(&geometry) {
                             this.menu_geometry.insert(kind, geometry);
@@ -2685,6 +2788,63 @@ impl Pickers {
 
     // ---- render ----
 
+    /// The model chip's content width (padding, brand slot, label, effort
+    /// and fast mark), eased toward on every change. The chip is anchored at
+    /// its trailing edge beside Send, as is its popover, so only its leading
+    /// edge moves and an open card stays put while the selection updates.
+    #[allow(clippy::too_many_arguments)]
+    fn model_chip_width(
+        &mut self,
+        window: &mut Window,
+        label: &SharedString,
+        suffix: Option<&SharedString>,
+        label_loading: bool,
+        fast: bool,
+        cx: &App,
+    ) -> f32 {
+        const GAP: f32 = 6.0;
+        let size = crate::typography::ui_rems(12.0).to_pixels(window.rem_size());
+        let mut font = window.text_style().font();
+        font.weight = gpui::FontWeight::MEDIUM;
+        let measure = |text: &SharedString| -> f32 {
+            let run = gpui::TextRun {
+                len: text.len(),
+                font: font.clone(),
+                color: gpui::black(),
+                background_color: None,
+                underline: None,
+                strikethrough: None,
+            };
+            f32::from(
+                window
+                    .text_system()
+                    .shape_line(text.clone(), size, &[run], None)
+                    .width,
+            )
+            .ceil()
+        };
+        let label_width = if label_loading { 56.0 } else { measure(label) };
+        let mut width = 2.0 * 6.0 + 16.0 + GAP + label_width;
+        if let Some(suffix) = suffix {
+            width += GAP + measure(suffix);
+        }
+        if fast {
+            width += GAP + 13.0;
+        }
+        let target = width.min(248.0);
+        let (value, moving) = compact::ScalarTransition::sample(
+            &mut self.chip_width,
+            target,
+            std::time::Instant::now(),
+            cx.reduce_motion(),
+        );
+        self.chip_resizing = moving;
+        if moving {
+            window.request_animation_frame();
+        }
+        value
+    }
+
     #[allow(clippy::too_many_arguments)]
     fn trigger_chip(
         &self,
@@ -2714,6 +2874,7 @@ impl Pickers {
         // this picker's entity.
         let id: SharedString = format!("{base}-{}", cx.entity_id()).into();
         let open = self.open_kind() == Some(kind);
+        let resizing = kind == PickerKind::HarnessModel && self.chip_resizing;
         // Ghost pill (zeron composer/styles.tsx `pill`): `h-8 rounded-lg px-2.5
         // gap-1.5 text-[12px] font-medium text-muted-foreground`, icons size-4,
         // hover/open wash — no border, no caret; the actions row stays quiet.
@@ -2723,10 +2884,6 @@ impl Pickers {
             .id(id.clone())
             .h(px(32.0))
             .max_w(px(248.0))
-            .when(
-                kind == PickerKind::HarnessModel && self.mounted_kind() == Some(kind),
-                |chip| chip.when_some(self.open_model_width, |chip, width| chip.w(width)),
-            )
             // Shrinkable under row pressure — four footer chips share one
             // line; without min_w_0 they overflowed and painted overlapped.
             .min_w_0()
@@ -2734,7 +2891,7 @@ impl Pickers {
             .flex_row()
             .items_center()
             .gap(px(6.0))
-            // The model trigger sits immediately beside the attachment.
+            // The model trigger sits beside the right-hand composer actions.
             // Its own padding participates in that visible gap; footer and
             // destination triggers keep their wider independent hit areas.
             .px(px(if kind == PickerKind::HarnessModel {
@@ -2793,7 +2950,11 @@ impl Pickers {
                 el.child(popover::skeleton_bar(56.0, cx.entity_id(), cx))
             })
             .when(!label_loading, |el| {
-                el.child(div().min_w_0().truncate().child(label))
+                el.child(if resizing {
+                    resizing_chip_text(format!("{id}-label").into(), 1.0, None, label)
+                } else {
+                    div().min_w_0().truncate().child(label).into_any_element()
+                })
             })
             // The effort half of the combined model+effort chip (and the space
             // chip's "@ device" tag): muted, no icon — one button, two tones.
@@ -2801,14 +2962,18 @@ impl Pickers {
             // pressure the suffix yields FIRST (large shrink factor) so the
             // model name — the run's identity — truncates last.
             .when_some(suffix, |el, (suffix, tint)| {
-                el.child(
+                let color = tint.unwrap_or(theme.text_muted.opacity(0.7));
+                el.child(if resizing {
+                    resizing_chip_text(format!("{id}-suffix").into(), 1000.0, Some(color), suffix)
+                } else {
                     div()
                         .flex_shrink(1000.0)
                         .min_w_0()
+                        .text_color(color)
                         .truncate()
-                        .text_color(tint.unwrap_or(theme.text_muted.opacity(0.7)))
-                        .child(suffix),
-                )
+                        .child(suffix)
+                        .into_any_element()
+                })
             })
     }
 
@@ -3263,6 +3428,9 @@ impl Pickers {
         popover::popover_card_flush(&theme)
             .w(px(width))
             .h(px(self.menu_geometry().height.min(self.open_model_height)))
+            .when(self.compact_model_picker(cx), |el| {
+                el.h(px(self.compact_motion.frame_height))
+            })
             .track_focus(&self.focus)
             .on_key_down(cx.listener(|this, event: &KeyDownEvent, window, cx| {
                 this.on_key_down(event, window, cx)
@@ -3351,7 +3519,9 @@ impl Pickers {
     /// through the exit animation, and the rail must keep measuring the
     /// closing menu's own handle, not `menu_scroll`'s idle geometry.
     fn active_menu_scroll(&self) -> gpui::ScrollHandle {
-        if self.mounted_kind() == Some(PickerKind::HarnessModel) {
+        if self.mounted_kind() == Some(PickerKind::HarnessModel)
+            && (self.model_rail != ModelRail::All || self.compact_model_list)
+        {
             self.model_scroll_base()
         } else {
             self.menu_scroll.clone()
@@ -3580,8 +3750,15 @@ impl Pickers {
     /// Model picker with favorites and harness tabs above a scoped search.
     /// Existing chats show only their own harness tab and models.
     fn render_harness_model_popover(&mut self, cx: &mut Context<Self>) -> AnyElement {
+        let compact = self.compact_model_picker(cx);
         let height = self.menu_geometry().height.min(self.open_model_height);
         let (list_height, tray_height) = model_menu_budgets(height, self.setting_groups(cx).len());
+        let list_height = if compact {
+            compact::compact_list_height(self.model_rows_len(cx))
+                .min((height - compact::LIST_HEADER - 2.0).max(0.0))
+        } else {
+            list_height
+        };
 
         let theme = Theme::of(cx).for_popup();
 
@@ -3745,6 +3922,10 @@ impl Pickers {
                 );
         }
 
+        if compact {
+            tabs = self.compact_list_header(cx);
+        }
+
         // ── search row: icon + borderless input over a full-bleed hairline.
         //    The placeholder names the scope — the query never leaves the
         //    viewed tab (user request; the old global search hid the rail).
@@ -3882,7 +4063,8 @@ impl Pickers {
         // ── traits tray: the reasoning ladder + model options PINNED under
         //    the list (the separate Traits popover folded in here — user
         //    request). Hidden entirely when the selected model has neither.
-        let has_tray = self.title.is_none()
+        let has_tray = !compact
+            && self.title.is_none()
             && (!self.trait_ladder(cx).is_empty()
                 || self
                     .selected_model(cx)
@@ -3907,7 +4089,8 @@ impl Pickers {
             .flex()
             .flex_col()
             .child(tabs)
-            .child(search_row)
+            // The compact header carries the filter beside its back button.
+            .when(!compact, |el| el.child(search_row))
             .children(refresh_error)
             .child(list_host)
             .children(tray)
@@ -3924,6 +4107,9 @@ impl Pickers {
         row: &ModelRowData,
         cx: &mut Context<Self>,
     ) -> AnyElement {
+        if self.compact_model_picker(cx) {
+            return self.render_compact_model_row(ix, row, cx);
+        }
         let theme = Theme::of(cx).for_popup();
         let effective = self.effective_harness(cx);
         let is_selected = Some(row.harness) == effective
@@ -4295,12 +4481,20 @@ impl Pickers {
     }
 
     /// The tray's settings. A model configured in place keeps them in its
-    /// hover card only.
+    /// hover card only — except in the compact picker, whose panel is the
+    /// one place the selected model's settings live.
     fn setting_groups(&self, cx: &App) -> Vec<SettingGroup> {
         // Titles always run at minimal reasoning with no model options.
-        if self.title.is_some() || self.selected_model(cx).is_some_and(configured_in_place) {
+        if self.title.is_some() {
             return Vec::new();
         }
+        if self.selected_model(cx).is_some_and(configured_in_place) {
+            return if self.compact_model_picker(cx) {
+                card_order(self.live_groups(cx))
+            } else {
+                Vec::new()
+            };
+        }
         self.live_groups(cx)
     }
 
@@ -4595,6 +4789,12 @@ impl Pickers {
             .into_iter()
             .filter(|g| tray || !is_toggle(g));
         for (ix, group) in groups.enumerate() {
+            if tray
+                && self.compact_model_picker(cx)
+                && !Self::compact_option_visible(&group.id, &self.compact_hidden_options(cx))
+            {
+                continue;
+            }
             let open = self.setting_scope == scope && self.setting_menu.as_ref() == Some(&group.id);
             let value = group
                 .choices
@@ -4615,7 +4815,11 @@ impl Pickers {
             )
             .id((row_id, ix))
             .relative()
-            .h(px(30.0))
+            .h(px(if self.compact_model_picker(cx) {
+                26.0
+            } else {
+                30.0
+            }))
             .py(px(0.0))
             .on_click(cx.listener(move |this, _, window, cx| {
                 if tray {
@@ -4823,16 +5027,132 @@ impl Pickers {
                     .child(row),
             );
         }
+        // The compact panel's own inset already closes the card below the
+        // last row; a second one left the bottom twice as deep as the sides.
+        let compact = tray && self.compact_model_picker(cx);
         div()
             .flex()
             .flex_col()
             .gap(px(2.0))
-            .py(px(popover::CARD_INSET))
+            .pt(px(popover::CARD_INSET))
+            .when(!compact, |el| el.pb(px(popover::CARD_INSET)))
             .children(rows)
             .into_any_element()
     }
 }
 
+/// Readable interaction state for the isolated compact-picker fixture.
+#[cfg(feature = "compact-picker-fixture")]
+pub struct CompactPickerFixtureState {
+    pub model_list: bool,
+    pub explicit_reasoning: Option<ReasoningLevel>,
+    pub reasoning: Option<ReasoningLevel>,
+    pub fast: bool,
+    pub focused_model: Option<String>,
+    pub focused_model_favorite: bool,
+}
+
+/// Synthetic catalog and assertions for the isolated compact-picker fixture.
+/// None of this is linked into production builds.
+#[cfg(feature = "compact-picker-fixture")]
+impl Pickers {
+    pub fn fixture_compact_catalog(&mut self, cx: &mut Context<Self>) {
+        self.config.harness = Some(HarnessId::Codex);
+        self.config.model = Some("gpt-5.4".into());
+        self.config.reasoning = None;
+        self.defaults
+            .model_options_mut(HarnessId::Codex, "gpt-5.4")
+            .clear();
+        self.harnesses = Loadable::Ready(
+            serde_json::from_value(serde_json::json!([
+                {
+                    "id":"codex",
+                    "name":"Codex",
+                    "installed":true,
+                    "enabled":true,
+                    "supportsSteering":true,
+                    "steeringMode":"step-boundary",
+                    "reasoningLevels":[]
+                }
+            ]))
+            .unwrap(),
+        );
+        self.models.insert(
+            HarnessId::Codex,
+            Loadable::Ready(
+                serde_json::from_value(serde_json::json!([
+                    {
+                        "id":"gpt-5.4",
+                        "label":"GPT-5.4",
+                        "description":"Best for complex coding and reasoning",
+                        "reasoningLevels":["low","medium","high","xhigh"],
+                        "options":[
+                            {
+                                "id":"serviceTier",
+                                "label":"Service tier",
+                                "defaultChoice":"standard",
+                                "choices":[
+                                    {"id":"standard","label":"Standard"},
+                                    {"id":"fast","label":"Fast"}
+                                ]
+                            },
+                            {
+                                "id":"contextWindow",
+                                "label":"Context window",
+                                "defaultChoice":"standard",
+                                "choices":[
+                                    {"id":"standard","label":"Standard"},
+                                    {"id":"1m","label":"1M tokens"}
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        "id":"gpt-5.3-codex",
+                        "label":"GPT-5.3 Codex",
+                        "description":"Optimized for agentic coding"
+                    },
+                    {
+                        "id":"gpt-5.2",
+                        "label":"GPT-5.2",
+                        "description":"General purpose reasoning"
+                    },
+                    {
+                        "id":"gpt-5.1-codex-mini",
+                        "label":"GPT-5.1 Codex Mini",
+                        "description":"Fast, efficient coding"
+                    }
+                ]))
+                .unwrap(),
+            ),
+        );
+        self.compact_model_list = false;
+        self.compact_keyboard = false;
+        self.active = 0;
+        self.catalog_rev += 1;
+        cx.notify();
+    }
+
+    pub fn fixture_compact_state(&self, cx: &App) -> CompactPickerFixtureState {
+        let focused = self
+            .compact_model_list
+            .then(|| self.model_rows(cx).get(self.active).cloned())
+            .flatten();
+        CompactPickerFixtureState {
+            model_list: self.compact_model_list,
+            explicit_reasoning: self.config.reasoning,
+            reasoning: self.effective_reasoning(cx),
+            fast: self
+                .compact_fast_choice(cx)
+                .is_some_and(|(_, _, _, fast)| fast),
+            focused_model_favorite: focused
+                .as_ref()
+                .is_some_and(|row| self.defaults.is_favorite(row.harness, &row.model.id)),
+            focused_model: focused.map(|row| row.model.id),
+        }
+    }
+}
+
 /// The floating-scrollbar treatment for every picker list
 /// ([`popover::rail`] folds the note/hide/metrics/render + pointer listeners
 /// into one call): one shared rail state, fed by whichever handle
@@ -4949,6 +5269,7 @@ fn scoped_model_rows<'a>(
         ambiguous: false,
     };
     let in_scope = |descriptor: &HarnessDescriptor, model: &Model| match rail {
+        ModelRail::All => true,
         ModelRail::Favorites => is_favorite(descriptor.id, &model.id),
         ModelRail::Harness => Some(descriptor.id) == effective,
     };
@@ -4985,22 +5306,31 @@ fn scoped_model_rows<'a>(
                 input_ix += 1;
             }
         }
-        ranked.sort_by_key(|(rank, unstarred, ix, _)| (*rank, *unstarred, *ix));
+        ranked.sort_by_key(|(rank, unstarred, ix, _)| {
+            if rail == ModelRail::All {
+                (*unstarred, *rank, *ix)
+            } else {
+                (*rank, *unstarred, *ix)
+            }
+        });
         return ranked.into_iter().map(|(_, _, _, row)| row).collect();
     }
     match rail {
-        ModelRail::Favorites => {
+        ModelRail::All | ModelRail::Favorites => {
             let mut rows = Vec::new();
             for descriptor in descriptors {
                 let Some(models) = models_for(descriptor.id) else {
                     continue;
                 };
                 for model in models {
-                    if is_favorite(descriptor.id, &model.id) {
+                    if rail == ModelRail::All || is_favorite(descriptor.id, &model.id) {
                         rows.push(row(descriptor, model));
                     }
                 }
             }
+            if rail == ModelRail::All {
+                rows.sort_by_key(|row| !is_favorite(row.harness, &row.model.id));
+            }
             rows
         }
         ModelRail::Harness => {
@@ -5220,6 +5550,64 @@ fn model_menu_budgets(height: f32, setting_count: usize) -> (f32, f32) {
     (body - tray, tray)
 }
 
+/// Chip text while the chip's width animates: clipped rather than
+/// ellipsized (an ellipsis would flicker in and out each frame), with the
+/// clip edge faded so a half-shown glyph never ends in a hard cut. The ramp
+/// is as wide as the hidden text, so it is zero exactly at the clip edge.
+fn resizing_chip_text(
+    id: SharedString,
+    shrink: f32,
+    color: Option<gpui::Hsla>,
+    text: SharedString,
+) -> AnyElement {
+    let overflow = gpui::ScrollHandle::new();
+    crate::edge_fade::edge_faded(
+        16.0,
+        false,
+        false,
+        div()
+            .id(id)
+            .flex_shrink(shrink)
+            .min_w_0()
+            .overflow_hidden()
+            .track_scroll(&overflow)
+            .flex()
+            .when_some(color, |el, color| el.text_color(color))
+            .child(div().flex_none().whitespace_nowrap().child(text)),
+    )
+    .fade_right(true)
+    .fade_scroll_x(&overflow)
+    .into_any_element()
+}
+
+/// Fast mode's `(on, off)` choices, whatever form a harness gives it: a
+/// `fastMode`/`fast_mode` on/off toggle (Claude), Cursor's `fast` true/false,
+/// or a tier/speed option offering `fast` (Codex, Devin). Off is the default
+/// when fast isn't, else the other choice — Cursor runs some models fast by
+/// default. Every model then gets the same fast-mode UI.
+fn fast_mode_values(option: &zeron_proto::ModelOption) -> Option<(&str, &str)> {
+    let has = |id: &str| option.choices.iter().any(|choice| choice.id == id);
+    let on = if matches!(option.id.as_str(), "fastMode" | "fast_mode") && has("on") {
+        "on"
+    } else if option.id == "fast" && has("true") {
+        "true"
+    } else if has("fast") {
+        "fast"
+    } else {
+        return None;
+    };
+    let off = if option.default_choice != on && has(&option.default_choice) {
+        option.default_choice.as_str()
+    } else {
+        option
+            .choices
+            .iter()
+            .map(|choice| choice.id.as_str())
+            .find(|id| *id != on)?
+    };
+    Some((on, off))
+}
+
 /// Attach the (single) open popover above a selector trigger.
 fn attach_overlay(
     chip: gpui::Stateful<gpui::Div>,
@@ -5419,38 +5807,81 @@ impl Render for Pickers {
             | Some(PickerKind::Space)
             | Some(PickerKind::Device) => None,
             Some(PickerKind::HarnessModel) => {
-                let content = self.render_harness_model_popover(cx);
-                Some((
-                    PickerKind::HarnessModel,
-                    // Compact single-harness pane (t3 ModelPickerContent
-                    // shrunk to its tabbed layout).
-                    self.popover_frame_flush(304.0, content, cx),
-                ))
+                let menu = if self.compact_model_picker(cx) {
+                    self.render_compact_menu(window, cx)
+                } else {
+                    let content = self.render_harness_model_popover(cx);
+                    self.popover_frame_flush(304.0, content, cx)
+                };
+                Some((PickerKind::HarnessModel, menu))
             }
             None => None,
         };
 
-        // The composer places this model chip beside the attachment button:
+        // The composer places this model chip beside Send:
         // brand icon + model name, then the effort as the chip's muted second
-        // tone. No suffix when the model has no reasoning ladder, nor for the
-        // title picker (titles always run at minimal reasoning).
-        let chip_suffix = effort.filter(|_| self.title.is_none()).map(|level| {
-            (
-                SharedString::from(reasoning_label(level)),
-                effort_customized.then(|| theme.text.opacity(0.85)),
-            )
+        // tone — the ladder's level, else an effort option's choice (Cursor).
+        // None for the title picker (titles always run at minimal reasoning).
+        let chip_suffix = effort
+            .filter(|_| self.title.is_none())
+            .map(|level| {
+                (
+                    SharedString::from(reasoning_label(level)),
+                    effort_customized.then(|| theme.text.opacity(0.85)),
+                )
+            })
+            .or_else(|| {
+                self.title
+                    .is_none()
+                    .then(|| self.compact_effort(cx))
+                    .flatten()
+                    .and_then(|e| e.labels.get(e.selected).cloned())
+                    .map(|label| (label, None))
+            });
+        let fast = self.selected_model(cx).is_some_and(|model| {
+            model.options.iter().any(|option| {
+                fast_mode_values(option).is_some_and(|(on, _)| {
+                    self.resolved(cx)
+                        .model_options
+                        .get(&option.id)
+                        .and_then(|value| value.as_str())
+                        .unwrap_or(&option.default_choice)
+                        == on
+                })
+            })
         });
-        let model_chip = self.trigger_chip(
-            PickerKind::HarnessModel,
-            model_label,
-            true,
-            Some(harness_icon),
-            chip_icon_loading,
+        let chip_width = self.model_chip_width(
+            window,
+            &model_label,
+            chip_suffix.as_ref().map(|(text, _)| text),
             chip_label_loading,
-            chip_suffix,
-            &theme,
+            fast,
             cx,
         );
+        let model_chip = self
+            .trigger_chip(
+                PickerKind::HarnessModel,
+                model_label,
+                true,
+                Some(harness_icon),
+                chip_icon_loading,
+                chip_label_loading,
+                chip_suffix,
+                &theme,
+                cx,
+            )
+            .when(fast, |chip| {
+                chip.child(motion::fast_tier(
+                    "composer-fast-tier",
+                    div().flex_none().child(
+                        crate::icons::icon(crate::icons::FAST_TIER_BOLD)
+                            .size(px(13.0))
+                            .text_color(theme.accent),
+                    ),
+                ))
+            });
+        let model_chip = model_chip.w(px(chip_width));
+        // Both presentations align to the chip's trailing edge beside Send.
         let model_chip = attach_overlay_end(
             model_chip,
             &mut overlay,
@@ -5999,11 +6430,73 @@ mod tests {
         }
     }
 
+    #[test]
+    fn every_fast_mode_encoding_gets_the_same_controls() {
+        let option = |id: &str, choices: &[&str], default: &str| ModelOption {
+            id: id.into(),
+            label: id.into(),
+            choices: choices
+                .iter()
+                .map(|c| ModelOptionChoice {
+                    id: (*c).into(),
+                    label: (*c).into(),
+                })
+                .collect(),
+            default_choice: default.into(),
+        };
+        // Codex tier, Claude toggle, ACP speed and the snake_case toggle.
+        assert_eq!(
+            fast_mode_values(&option("serviceTier", &["default", "fast"], "default")),
+            Some(("fast", "default"))
+        );
+        assert_eq!(
+            fast_mode_values(&option("fastMode", &["off", "on"], "off")),
+            Some(("on", "off"))
+        );
+        assert_eq!(
+            fast_mode_values(&option("speed", &["standard", "fast"], "standard")),
+            Some(("fast", "standard"))
+        );
+        assert_eq!(
+            fast_mode_values(&option("fast_mode", &["off", "on"], "off")),
+            Some(("on", "off"))
+        );
+        // Cursor's true/false switch, off by default (Opus) and on by
+        // default (Grok, Composer): both still toggle between the two.
+        assert_eq!(
+            fast_mode_values(&option("fast", &["false", "true"], "false")),
+            Some(("true", "false"))
+        );
+        assert_eq!(
+            fast_mode_values(&option("fast", &["false", "true"], "true")),
+            Some(("true", "false"))
+        );
+        assert_eq!(
+            fast_mode_values(&option("serviceTier", &["default", "fast"], "fast")),
+            Some(("fast", "default"))
+        );
+        // Not fast mode: other toggles, including Cursor's true/false ones.
+        assert_eq!(
+            fast_mode_values(&option("thinking", &["off", "on"], "off")),
+            None
+        );
+        assert_eq!(
+            fast_mode_values(&option("thinking", &["false", "true"], "true")),
+            None
+        );
+        assert_eq!(
+            fast_mode_values(&option("contextWindow", &["200k", "1m"], "200k")),
+            None
+        );
+    }
+
     #[gpui::test]
-    fn open_model_trigger_keeps_its_width_across_model_and_option_changes(
-        cx: &mut gpui::TestAppContext,
-    ) {
-        cx.update(|cx| cx.set_global(Theme::dark()));
+    fn open_model_trigger_follows_the_selection_while_open(cx: &mut gpui::TestAppContext) {
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            // Settle the width glide in one frame.
+            motion::set_reduced_motion(cx, true);
+        });
         let handle = cx.add_window(|_, cx| {
             let state = cx.new(|_| AppState::new());
             let mut pickers = Pickers::new(state, cx);
@@ -6037,15 +6530,18 @@ mod tests {
             cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
                 .unwrap();
             handle
-                .read_with(cx, |pickers, _| pickers.model_trigger_bounds.unwrap())
+                .read_with(cx, |pickers, _| {
+                    pickers.model_trigger_bounds.unwrap().size.width
+                })
                 .unwrap()
         };
-        let before = draw(cx);
+        let short = draw(cx);
         handle
             .update(cx, |pickers, window, cx| {
                 pickers.open_model_menu(window, cx)
             })
             .unwrap();
+        let mut widths = Vec::new();
         for (model, fast) in [("long", false), ("long", true), ("short", false)] {
             handle
                 .update(cx, |pickers, _, cx| {
@@ -6060,12 +6556,14 @@ mod tests {
                     cx.notify();
                 })
                 .unwrap();
-            assert_eq!(
-                draw(cx),
-                before,
-                "open trigger moved for {model}, fast={fast}"
-            );
+            widths.push(draw(cx));
         }
+        // The open chip names the live selection instead of keeping the
+        // width it opened with: longer for the long model, longer again
+        // with its effort and fast mark, and back once the short one returns.
+        assert!(widths[0] > short, "{widths:?} vs {short:?}");
+        assert!(widths[1] > widths[0], "{widths:?}");
+        assert_eq!(widths[2], short);
     }
 
     #[gpui::test]
@@ -7215,6 +7713,569 @@ mod tests {
             supports_steering: false,
         }
     }
+    #[gpui::test]
+    fn compact_panel_shortcuts_drive_models_providers_and_effort(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let laddered = |id: &str, label: &str| {
+            let mut model = bare_model(id, label);
+            model.reasoning_levels = vec![ReasoningLevel::Low, ReasoningLevel::High];
+            model
+        };
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            let mut picker = Pickers::new(state, cx);
+            picker.config.harness = Some(HarnessId::Codex);
+            picker.harnesses = Loadable::Ready(vec![
+                descriptor(HarnessId::Codex, "Codex"),
+                descriptor(HarnessId::ClaudeCode, "Claude"),
+            ]);
+            picker.models.insert(
+                HarnessId::Codex,
+                Loadable::Ready(vec![
+                    laddered("model", "Model"),
+                    laddered("other", "Other model"),
+                    laddered("third", "Third model"),
+                ]),
+            );
+            picker.models.insert(
+                HarnessId::ClaudeCode,
+                Loadable::Ready(vec![laddered("claude", "Claude model")]),
+            );
+            picker
+        });
+        handle
+            .update(cx, |picker, window, cx| picker.open_model_menu(window, cx))
+            .unwrap();
+        cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+            .unwrap();
+        // Down opens the list on the model after the selected one; Enter
+        // picks it and lands back on the panel.
+        cx.simulate_keystrokes(handle.into(), "down");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(picker.compact_model_list);
+                assert_eq!(picker.model_rows(cx)[picker.active].model.id, "other");
+            })
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "enter");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(!picker.compact_model_list);
+                assert_eq!(picker.selected_model(cx).unwrap().id, "other");
+            })
+            .unwrap();
+        // Up opens it on the model before; Escape steps back without a pick.
+        cx.simulate_keystrokes(handle.into(), "up");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(picker.compact_model_list);
+                assert_eq!(picker.model_rows(cx)[picker.active].model.id, "model");
+            })
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "escape");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(!picker.compact_model_list);
+                assert_eq!(picker.selected_model(cx).unwrap().id, "other");
+            })
+            .unwrap();
+        // In the list, ⌘⇧F stars the highlighted model without picking it,
+        // and the highlight follows that model through the re-sort.
+        cx.simulate_keystrokes(handle.into(), "down");
+        cx.simulate_keystrokes(handle.into(), "cmd-shift-f");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(picker.defaults.is_favorite(HarnessId::Codex, "third"));
+                assert_eq!(picker.active, 0, "Favorite should move to the first row");
+                assert_eq!(picker.model_rows(cx)[picker.active].model.id, "third");
+                assert_eq!(picker.selected_model(cx).unwrap().id, "other");
+            })
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "cmd-shift-f");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(!picker.defaults.is_favorite(HarnessId::Codex, "third"));
+                assert_eq!(
+                    picker.active, 2,
+                    "Focus must follow the unstarred model back"
+                );
+                assert_eq!(picker.model_rows(cx)[picker.active].model.id, "third");
+            })
+            .unwrap();
+        // Tab cycles providers in place, each at its last-used model.
+        cx.simulate_keystrokes(handle.into(), "escape");
+        cx.simulate_keystrokes(handle.into(), "tab");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert!(!picker.compact_model_list && !picker.compact_providers);
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
+            })
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "tab");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::Codex));
+                assert_eq!(picker.selected_model(cx).unwrap().id, "other");
+            })
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "shift-tab");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
+            })
+            .unwrap();
+        // Left/Right and Home/End set the effort, one haptic per change
+        // and none at an unchanged endpoint.
+        let haptics_before = handle
+            .read_with(cx, |_, _| crate::haptics::step_count())
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "home home");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert_eq!(picker.effective_reasoning(cx), Some(ReasoningLevel::Low))
+            })
+            .unwrap();
+        cx.simulate_keystrokes(handle.into(), "right right left right");
+        handle
+            .read_with(cx, |picker, cx| {
+                assert_eq!(picker.effective_reasoning(cx), Some(ReasoningLevel::High));
+                assert_eq!(crate::haptics::step_count() - haptics_before, 4);
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn compact_panel_lists_settings_of_models_configured_in_place(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Pickers::new(state, cx)
+        });
+        let option = |id: &str, label: &str, choices: &[(&str, &str)]| ModelOption {
+            id: id.into(),
+            label: label.into(),
+            default_choice: choices[0].0.into(),
+            choices: choices
+                .iter()
+                .map(|(id, label)| ModelOptionChoice {
+                    id: (*id).into(),
+                    label: (*label).into(),
+                })
+                .collect(),
+        };
+        handle
+            .update(cx, |pickers, _, cx| {
+                let mut fusion = bare_model("fusion", "Fusion");
+                fusion.reasoning_levels = vec![ReasoningLevel::Medium, ReasoningLevel::High];
+                fusion.options = vec![
+                    option(
+                        "sidekick",
+                        "Sidekick",
+                        &[("swe-2", "SWE-2"), ("swe-3", "SWE-3")],
+                    ),
+                    option("lead", "Lead", &[("fable", "Fable"), ("sol", "Sol")]),
+                ];
+                pickers.config.harness = Some(HarnessId::Devin);
+                pickers.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Devin, "Devin")]);
+                pickers.models.insert(
+                    HarnessId::Devin,
+                    Loadable::Ready(vec![bare_model("adaptive", "Adaptive"), fusion]),
+                );
+                pickers.pick_model("fusion".into(), cx);
+                // No hover card in the compact panel: Lead leads, as in the card.
+                let hidden = pickers.compact_hidden_options(cx);
+                let visible: Vec<_> = pickers
+                    .setting_groups(cx)
+                    .into_iter()
+                    .filter(|g| Pickers::compact_option_visible(&g.id, &hidden))
+                    .map(|g| g.id)
+                    .collect();
+                assert_eq!(
+                    visible,
+                    [
+                        ModelSetting::Option("lead".into()),
+                        ModelSetting::Option("sidekick".into())
+                    ]
+                );
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn compact_fast_button_toggles_cursor_fast_by_default_models(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Pickers::new(state, cx)
+        });
+        handle
+            .update(cx, |pickers, _, cx| {
+                let mut grok = bare_model("grok-4.6", "Grok 4.6");
+                grok.options = vec![ModelOption {
+                    id: "fast".into(),
+                    label: "Fast".into(),
+                    default_choice: "true".into(),
+                    choices: [("false", "false"), ("true", "Fast\u{200b}")]
+                        .iter()
+                        .map(|(id, label)| ModelOptionChoice {
+                            id: (*id).into(),
+                            label: (*label).into(),
+                        })
+                        .collect(),
+                }];
+                pickers.config.harness = Some(HarnessId::Cursor);
+                pickers.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Cursor, "Cursor")]);
+                pickers
+                    .models
+                    .insert(HarnessId::Cursor, Loadable::Ready(vec![grok]));
+                pickers.pick_model("grok-4.6".into(), cx);
+                // On by default: the button starts lit and turning it off is
+                // an explicit pick; turning it back on returns to the default.
+                let (option, next, default, fast) = pickers.compact_fast_choice(cx).unwrap();
+                assert_eq!((next.as_str(), default, fast), ("false", false, true));
+                pickers.pick_option(option, next, default, cx);
+                let (option, next, default, fast) = pickers.compact_fast_choice(cx).unwrap();
+                assert_eq!((next.as_str(), default, fast), ("true", true, false));
+                pickers.pick_option(option, next, default, cx);
+                assert!(pickers.compact_fast_choice(cx).unwrap().3);
+                assert!(!pickers.explicit_options(cx).contains_key("fast"));
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn compact_list_hides_loading_and_failed_harnesses(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            let mut picker = Pickers::new(state, cx);
+            picker.config.harness = Some(HarnessId::Codex);
+            picker.harnesses = Loadable::Ready(vec![
+                descriptor(HarnessId::Codex, "Codex"),
+                descriptor(HarnessId::ClaudeCode, "Claude"),
+                descriptor(HarnessId::Grok, "Grok"),
+            ]);
+            picker.models.insert(
+                HarnessId::Codex,
+                Loadable::Ready(vec![bare_model("model", "Model")]),
+            );
+            picker.models.insert(
+                HarnessId::ClaudeCode,
+                Loadable::Error("Catalog timed out".into()),
+            );
+            picker.models.insert(HarnessId::Grok, Loadable::Loading);
+            picker
+        });
+        handle
+            .update(cx, |picker, window, cx| {
+                picker.open_model_menu(window, cx);
+                picker.show_compact_models(cx);
+                assert_eq!(picker.model_rows_len(cx), 1);
+            })
+            .unwrap();
+        cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+            .unwrap();
+        // Only the ready model is navigable: no status rows follow it.
+        cx.simulate_keystrokes(handle.into(), "down");
+        handle
+            .read_with(cx, |picker, _| assert_eq!(picker.active, 0))
+            .unwrap();
+        handle
+            .update(cx, |picker, _, cx| {
+                picker.models.insert(
+                    HarnessId::ClaudeCode,
+                    Loadable::Ready(vec![bare_model("claude", "Claude model")]),
+                );
+                picker.catalog_rev += 1;
+                // The list holds one provider's models; the provider page
+                // switches to the newly loaded one.
+                assert_eq!(picker.model_rows_len(cx), 1);
+                picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
+                picker.show_compact_models(cx);
+                assert_eq!(picker.model_rows_len(cx), 1);
+                assert_eq!(picker.model_rows(cx)[0].harness, HarnessId::ClaudeCode);
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn compact_slider_drives_cursor_effort_option(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Pickers::new(state, cx)
+        });
+        handle
+            .update(cx, |picker, _, cx| {
+                // Cursor's shape: no reasoning ladder, effort as an option.
+                let mut opus = bare_model("claude-opus-5", "Claude Opus 5");
+                opus.options = vec![ModelOption {
+                    id: "effort".into(),
+                    label: "Effort".into(),
+                    default_choice: "high".into(),
+                    choices: [("low", "Low"), ("medium", "Medium"), ("high", "High")]
+                        .iter()
+                        .map(|(id, label)| ModelOptionChoice {
+                            id: (*id).into(),
+                            label: (*label).into(),
+                        })
+                        .collect(),
+                }];
+                picker.config.harness = Some(HarnessId::Cursor);
+                picker.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Cursor, "Cursor")]);
+                picker
+                    .models
+                    .insert(HarnessId::Cursor, Loadable::Ready(vec![opus]));
+                picker.pick_model("claude-opus-5".into(), cx);
+                let effort = picker.compact_effort(cx).unwrap();
+                assert_eq!(effort.labels, ["Low", "Medium", "High"]);
+                assert_eq!(effort.selected, 2);
+                // The slider owns it: no Effort row in the panel.
+                assert_eq!(picker.compact_hidden_options(cx), ["effort"]);
+                picker.pick_compact_effort(effort, 0, cx);
+                assert_eq!(picker.resolved(cx).model_options["effort"], "low");
+                assert_eq!(picker.compact_effort(cx).unwrap().selected, 0);
+                // Back to the default clears the explicit pick.
+                let effort = picker.compact_effort(cx).unwrap();
+                picker.pick_compact_effort(effort, 2, cx);
+                assert!(!picker.explicit_options(cx).contains_key("effort"));
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn switching_provider_restores_its_last_model_and_effort(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Pickers::new(state, cx)
+        });
+        let laddered = |id: &str, label: &str| {
+            let mut model = bare_model(id, label);
+            model.reasoning_levels = vec![
+                ReasoningLevel::Low,
+                ReasoningLevel::Medium,
+                ReasoningLevel::High,
+            ];
+            model
+        };
+        handle
+            .update(cx, |picker, _, cx| {
+                picker.harnesses = Loadable::Ready(vec![
+                    descriptor(HarnessId::Codex, "Codex"),
+                    descriptor(HarnessId::ClaudeCode, "Claude"),
+                ]);
+                picker.models.insert(
+                    HarnessId::Codex,
+                    Loadable::Ready(vec![laddered("gpt-a", "A"), laddered("gpt-b", "B")]),
+                );
+                picker.models.insert(
+                    HarnessId::ClaudeCode,
+                    Loadable::Ready(vec![laddered("opus", "Opus")]),
+                );
+                picker.pick_harness(HarnessId::Codex, cx);
+                picker.pick_model("gpt-b".into(), cx);
+                picker.pick_reasoning(ReasoningLevel::Low, cx);
+                picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
+                picker.pick_reasoning(ReasoningLevel::High, cx);
+                // Back to Codex: its last model, at that model's last effort.
+                picker.pick_compact_provider(HarnessId::Codex, cx);
+                assert_eq!(picker.resolved(cx).model.as_deref(), Some("gpt-b"));
+                assert_eq!(picker.effective_reasoning(cx), Some(ReasoningLevel::Low));
+                // A model with no effort of its own takes the last one used
+                // anywhere (High, on Claude).
+                picker.pick_model("gpt-a".into(), cx);
+                assert_eq!(picker.effective_reasoning(cx), Some(ReasoningLevel::High));
+                picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
+                assert_eq!(picker.resolved(cx).model.as_deref(), Some("opus"));
+                assert_eq!(picker.effective_reasoning(cx), Some(ReasoningLevel::High));
+                // Starring adds a Starred entry ahead of the providers; it
+                // opens the starred models from every provider.
+                assert!(matches!(
+                    picker.compact_provider_rows(cx).first(),
+                    Some(compact::ProviderRow::Harness(_))
+                ));
+                picker.toggle_model_favorite(HarnessId::Codex, "gpt-a", cx);
+                picker.show_compact_providers(cx);
+                assert!(matches!(
+                    picker.compact_provider_rows(cx).first(),
+                    Some(compact::ProviderRow::Starred)
+                ));
+                picker.active = 0;
+                picker.activate_compact_provider(cx);
+                assert!(picker.compact_model_list && !picker.compact_providers);
+                let rows = picker.model_rows(cx);
+                assert_eq!(rows.len(), 1);
+                assert_eq!(
+                    (rows[0].harness, rows[0].model.id.as_str()),
+                    (HarnessId::Codex, "gpt-a")
+                );
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn compact_picker_shares_selection_reset_and_thread_restrictions(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            let mut picker = Pickers::new(state, cx);
+            picker.config.harness = Some(HarnessId::Codex);
+            picker.config.model = Some("codex-model".into());
+            picker.harnesses = Loadable::Ready(vec![
+                descriptor(HarnessId::Codex, "Codex"),
+                descriptor(HarnessId::ClaudeCode, "Claude"),
+            ]);
+            let mut model = bare_model("codex-model", "Codex model");
+            model.reasoning_levels = vec![ReasoningLevel::Low, ReasoningLevel::High];
+            picker
+                .models
+                .insert(HarnessId::Codex, Loadable::Ready(vec![model]));
+            picker.models.insert(
+                HarnessId::ClaudeCode,
+                Loadable::Ready(vec![bare_model("claude-model", "Claude model")]),
+            );
+            picker
+        });
+        handle
+            .update(cx, |picker, window, cx| {
+                picker.open_model_menu(window, cx);
+                assert!(!picker.compact_model_list);
+                // The list holds the current provider's models only.
+                picker.show_compact_models(cx);
+                assert_eq!(picker.model_rows_len(cx), 1);
+                assert_eq!(picker.model_rows(cx)[0].harness, HarnessId::Codex);
+                // The provider page lists every provider, highlighting the
+                // current one, and a pick lands back on the panel.
+                picker.show_compact_providers(cx);
+                assert!(picker.compact_providers && !picker.compact_model_list);
+                assert_eq!(picker.compact_provider_rows(cx).len(), 2);
+                assert_eq!(picker.active, 0);
+                picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
+                assert!(!picker.compact_providers && !picker.compact_model_list);
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
+                assert_eq!(picker.resolved(cx).model.as_deref(), Some("claude-model"));
+                picker.pick_harness(HarnessId::Codex, cx);
+                picker.pick_model("codex-model".into(), cx);
+                picker.pick_reasoning(ReasoningLevel::Low, cx);
+                assert_eq!(picker.config.model.as_deref(), Some("codex-model"));
+                picker.state.update(cx, |state, cx| {
+                    state.selected_chat = Some("thread".into());
+                    cx.notify();
+                });
+                picker.show_compact_models(cx);
+                assert_eq!(picker.model_rows_len(cx), 1);
+                assert_eq!(picker.rail_descriptors(cx)[0].id, HarnessId::Codex);
+                // A chat's provider is fixed: the provider page stays shut.
+                picker.compact_model_list = false;
+                picker.show_compact_providers(cx);
+                assert!(!picker.compact_providers);
+                picker.focus_on_mount = true;
+            })
+            .unwrap();
+        cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+            .unwrap();
+        handle
+            .read_with(cx, |picker, _| assert!(picker.effort_bounds.is_some()))
+            .unwrap();
+        handle
+            .update(cx, |picker, _, cx| {
+                picker.show_compact_models(cx);
+                picker
+                    .search
+                    .update(cx, |input, cx| input.set_text("no-matching-model", cx));
+                picker.active = 0;
+                picker.activate_model_row(cx);
+                assert!(
+                    picker.setting_menu.is_none(),
+                    "Empty search must not activate hidden settings"
+                );
+                picker.search.update(cx, |input, cx| input.set_text("", cx));
+            })
+            .unwrap();
+        cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+            .unwrap();
+    }
+
+    #[test]
+    fn compact_all_models_keeps_favorites_first_in_catalog_and_search() {
+        let descriptors = vec![
+            descriptor(HarnessId::ClaudeCode, "Claude"),
+            descriptor(HarnessId::Codex, "Codex"),
+        ];
+        let claude = vec![
+            bare_model("plain-a", "Model A"),
+            bare_model("star-a", "My Model A"),
+        ];
+        let codex = vec![
+            bare_model("plain-b", "Model B"),
+            bare_model("star-b", "My Model B"),
+        ];
+        for query in ["", "model"] {
+            let rows = scoped_model_rows(
+                query,
+                ModelRail::All,
+                Some(HarnessId::Codex),
+                &descriptors,
+                |harness| match harness {
+                    HarnessId::ClaudeCode => Some(claude.as_slice()),
+                    HarnessId::Codex => Some(codex.as_slice()),
+                    _ => None,
+                },
+                |_, id| id.starts_with("star"),
+            );
+            assert_eq!(
+                rows.iter()
+                    .map(|row| row.model.id.as_str())
+                    .collect::<Vec<_>>(),
+                vec!["star-a", "star-b", "plain-a", "plain-b"]
+            );
+        }
+    }
 
     #[test]
     fn tab_search_never_leaves_the_viewed_harness() {
diff --git a/crates/ui/src/pickers/compact.rs b/crates/ui/src/pickers/compact.rs
new file mode 100644
index 0000000000..c242be2e69
--- /dev/null
+++ b/crates/ui/src/pickers/compact.rs
@@ -0,0 +1,1569 @@
+//! Alternate presentation of the same model and option mutations.
+use super::*;
+
+pub(super) const COMPACT_WIDTH: f32 = 256.0;
+/// One-line model rows (plus the 2px gap) so about seven fit at once.
+pub(super) const COMPACT_ROW_HEIGHT: f32 = 32.0;
+pub(super) const COMPACT_LIST_ROWS: f32 = 7.0;
+/// The list fits its rows, up to [`COMPACT_LIST_ROWS`]; empty and loading
+/// states keep room for a few skeleton rows.
+pub(super) fn compact_list_height(rows: usize) -> f32 {
+    let rows = if rows == 0 {
+        4.0
+    } else {
+        (rows as f32).min(COMPACT_LIST_ROWS)
+    };
+    rows * (COMPACT_ROW_HEIGHT + popover::MENU_GAP) + 2.0 * popover::CARD_INSET
+}
+// A 28px rail under a 44x32 pill thumb that overhangs it by 2px, so the
+// handle reads as the thing to grab. Stops and pointer input share the
+// thumb's centre inset; the fill runs a rail radius past the centre, always
+// hidden under the thumb.
+const SLIDER_HEIGHT: f32 = 36.0;
+const RAIL_HEIGHT: f32 = 28.0;
+const RAIL_TOP: f32 = (SLIDER_HEIGHT - RAIL_HEIGHT) / 2.0;
+const THUMB_WIDTH: f32 = 44.0;
+const THUMB_HEIGHT: f32 = 32.0;
+const THUMB_INSET: f32 = THUMB_WIDTH / 2.0;
+const FILL_PAST: f32 = RAIL_HEIGHT / 2.0;
+/// Both header buttons fill the header's height, so they sit one card inset
+/// from the card's top and sides and their radius is concentric with its
+/// corners. 8pt of padding around the two-line title puts its text 12pt
+/// from the card's top and leading edges.
+const HEADER_HEIGHT: f32 = 48.0;
+/// A model without an effort ladder titles the header with its name alone.
+const HEADER_HEIGHT_SINGLE: f32 = 36.0;
+/// Flush with the card inset, a 15pt glyph centred in 32pt ends 12pt from
+/// the card edge: the slider rail's end. The provider button mirrors it on
+/// the leading side.
+const FAST_BUTTON_WIDTH: f32 = 32.0;
+/// The header inside the card inset, then the slider block and the space
+/// above the option rows. The slider's 4pt below its box leaves the rail
+/// 12pt from the card's bottom when no options follow.
+fn header_block(effort: bool) -> f32 {
+    2.0 * popover::CARD_INSET
+        + if effort {
+            HEADER_HEIGHT
+        } else {
+            HEADER_HEIGHT_SINGLE
+        }
+}
+const SLIDER_TOP: f32 = 2.0;
+const SLIDER_BOTTOM: f32 = 4.0;
+const EFFORT_BLOCK: f32 = SLIDER_TOP + SLIDER_HEIGHT + SLIDER_BOTTOM;
+const OPTIONS_GAP: f32 = 4.0;
+/// The card's 1pt border, top and bottom, sits inside its height.
+const CARD_BORDERS: f32 = 2.0;
+/// The list pages' one header row: back button and filter side by side.
+pub(super) const LIST_HEADER: f32 = 40.0;
+/// Option rows (26pt plus a 2pt gap) all show up to this many, then scroll.
+const OPTIONS_MAX_ROWS: usize = 6;
+/// The rows' 4pt top inset, then the rows; the panel's inset closes below.
+fn options_height(count: usize) -> f32 {
+    2.0 + count.min(OPTIONS_MAX_ROWS) as f32 * 28.0
+}
+
+/// Option ids Cursor uses for an effort ladder (its models carry none).
+const EFFORT_OPTION_IDS: [&str; 3] = ["effort", "reasoning", "reasoning_effort"];
+
+pub(super) struct CompactEffort {
+    pub labels: Vec<SharedString>,
+    pub selected: usize,
+    stops: EffortStops,
+}
+
+enum EffortStops {
+    Reasoning(Vec<ReasoningLevel>),
+    Option {
+        id: String,
+        choices: Vec<String>,
+        default: String,
+    },
+}
+
+/// One entry on the provider page: the starred models, or a provider.
+#[derive(Clone)]
+pub(super) enum ProviderRow {
+    Starred,
+    Harness(HarnessDescriptor),
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum CompactPage {
+    Panel,
+    Models,
+    Providers,
+}
+
+#[derive(Default)]
+pub(super) struct CompactMotion {
+    effort: Option<ScalarTransition>,
+    press: Option<ScalarTransition>,
+    drag_fraction: Option<f32>,
+    energy: Option<ScalarTransition>,
+    /// Shimmer clock for fast mode and the top effort levels, integrated
+    /// per frame so changing intensity never jumps the band.
+    shimmer_phase: f32,
+    shimmer_last_frame: Option<std::time::Instant>,
+    fast: Option<ScalarTransition>,
+    height: Option<ScalarTransition>,
+    page: Option<CompactPage>,
+    reveal: Option<ScalarTransition>,
+    pub frame_height: f32,
+}
+
+pub(super) struct ScalarTransition {
+    from: f32,
+    to: f32,
+    started: std::time::Instant,
+}
+impl ScalarTransition {
+    pub(super) fn value(&self, now: std::time::Instant) -> f32 {
+        let progress = motion::RESIZE.progress(
+            now.duration_since(self.started).as_secs_f32()
+                / motion::RESIZE
+                    .total()
+                    .mul_f32(motion::speed_scale())
+                    .as_secs_f32(),
+        );
+        motion::lerp(self.from, self.to, progress)
+    }
+    pub(super) fn sample(
+        state: &mut Option<Self>,
+        target: f32,
+        now: std::time::Instant,
+        reduced: bool,
+    ) -> (f32, bool) {
+        let Some(transition) = state else {
+            *state = Some(Self {
+                from: target,
+                to: target,
+                started: now,
+            });
+            return (target, false);
+        };
+        if reduced {
+            transition.from = target;
+            transition.to = target;
+            return (target, false);
+        }
+        if transition.to != target {
+            transition.from = transition.value(now);
+            transition.to = target;
+            transition.started = now;
+        }
+        let value = transition.value(now);
+        (value, (value - target).abs() > 0.001)
+    }
+}
+
+impl Pickers {
+    pub(super) fn render_compact_model_row(
+        &mut self,
+        ix: usize,
+        row: &ModelRowData,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let theme = Theme::of(cx).for_popup();
+        let selected = self.effective_harness(cx) == Some(row.harness)
+            && self
+                .selected_model(cx)
+                .is_some_and(|model| model.id == row.model.id);
+        let favorite = self.defaults.is_favorite(row.harness, &row.model.id);
+        let (icon, tint) = harness_brand_icon(row.harness);
+        let harness = row.harness;
+        let model = row.model.id.clone();
+        let label: SharedString = row.model.label.clone().into();
+        // The brand mark names the provider; a description appears only to
+        // tell identically named rows apart.
+        let attribution: Option<SharedString> = row
+            .model
+            .description
+            .as_deref()
+            .map(str::trim)
+            .filter(|d| row.ambiguous && !d.is_empty())
+            .map(|d| SharedString::from(d.to_owned()));
+        let hovered = self.active == ix;
+        let details: SharedString = match row.model.description.as_deref() {
+            Some(description) => format!(
+                "{} · {}\n{}",
+                row.model.label, row.harness_name, description
+            )
+            .into(),
+            None => format!("{} · {}", row.model.label, row.harness_name).into(),
+        };
+        let accessible_name = details.clone();
+        let favorite_hint: SharedString = format!(
+            "{} {} {}",
+            if favorite { "Remove" } else { "Add" },
+            row.model.label,
+            if favorite {
+                "from favorites"
+            } else {
+                "to favorites"
+            }
+        )
+        .into();
+        let favorite_tooltip: SharedString =
+            format!("{}\n⌘⇧F on the highlighted model", favorite_hint).into();
+        let item = div()
+            .id(("model-row", ix))
+            .role(gpui::Role::ListBoxOption)
+            .aria_label(accessible_name)
+            .aria_selected(selected)
+            .tooltip(move |_, cx| cx.new(|_| PickerHint(details.clone())).into())
+            .tooltip_show_delay(std::time::Duration::from_millis(500))
+            .h(px(COMPACT_ROW_HEIGHT))
+            .pl(px(8.0))
+            .pr(px(4.0))
+            .rounded(px(popover::MENU_ITEM_RADIUS))
+            .flex()
+            .items_center()
+            .gap(px(8.0))
+            .cursor_pointer()
+            .text_color(theme.text)
+            // Every row reserves the glass rim so selection doesn't shift content.
+            .border_1()
+            .border_color(gpui::transparent_black())
+            .when(selected, |el| crate::glass::light(el, &theme, 1.0))
+            .when(!selected && self.active == ix, |el| {
+                el.bg(crate::theme::ink(0.05))
+            })
+            .when(self.compact_keyboard && self.active == ix, |el| {
+                el.aria_active_descendant()
+            })
+            .on_hover(cx.listener(move |this, hovered: &bool, _, cx| {
+                if *hovered && (this.active != ix || this.compact_keyboard) {
+                    this.compact_keyboard = false;
+                    this.active = ix;
+                    cx.notify();
+                }
+            }))
+            .on_click(cx.listener(move |this, _, _, cx| this.activate_model_index(ix, cx)))
+            .child(
+                crate::icons::icon(icon)
+                    .size(px(14.0))
+                    .flex_none()
+                    .text_color(tint.unwrap_or(theme.text_muted)),
+            )
+            .child(
+                div()
+                    .flex_1()
+                    .min_w_0()
+                    .flex()
+                    .items_baseline()
+                    .gap(px(6.0))
+                    .text_size(crate::typography::ui_rems(12.0))
+                    .child(
+                        div()
+                            .flex_none()
+                            .max_w_full()
+                            .truncate()
+                            .font_weight(gpui::FontWeight::MEDIUM)
+                            .child(label),
+                    )
+                    .when_some(attribution, |el, attribution| {
+                        el.child(
+                            div()
+                                .min_w_0()
+                                .truncate()
+                                .text_size(crate::typography::ui_rems(11.0))
+                                .text_color(theme.text_muted)
+                                .child(attribution),
+                        )
+                    }),
+            )
+            .child(
+                div()
+                    .id(("model-star", ix))
+                    .role(gpui::Role::Button)
+                    .aria_label(favorite_hint)
+                    .aria_toggled(if favorite {
+                        gpui::Toggled::True
+                    } else {
+                        gpui::Toggled::False
+                    })
+                    .aria_keyshortcuts("Meta+Shift+F")
+                    .tooltip(move |_, cx| cx.new(|_| PickerHint(favorite_tooltip.clone())).into())
+                    .size(px(24.0))
+                    .rounded(px(6.0))
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    // Quiet until the row is hovered or the model is starred.
+                    .when(!favorite && !hovered, |el| el.opacity(0.0))
+                    .hover(|s| s.bg(crate::theme::ink(0.08)))
+                    .on_click(cx.listener(move |this, _, _, cx| {
+                        cx.stop_propagation();
+                        this.toggle_model_favorite(harness, &model, cx);
+                    }))
+                    .child(
+                        crate::icons::icon(if favorite {
+                            crate::icons::STAR_BOLD
+                        } else {
+                            crate::icons::STAR
+                        })
+                        .size(px(13.0))
+                        .text_color(if favorite {
+                            theme.accent
+                        } else {
+                            theme.text_muted
+                        }),
+                    ),
+            );
+        div()
+            .pb(px(popover::MENU_GAP))
+            .child(item)
+            .into_any_element()
+    }
+
+    pub(super) fn compact_model_picker(&self, cx: &App) -> bool {
+        self.title.is_none() && crate::settings::compact_model_picker(cx)
+    }
+
+    pub(super) fn show_compact_models(&mut self, cx: &mut Context<Self>) {
+        // The provider button picks the provider; the list holds its models.
+        self.show_compact_list(ModelRail::Harness, "Search models…", cx);
+    }
+
+    /// The starred models across providers, opened from the provider page.
+    fn show_compact_starred(&mut self, cx: &mut Context<Self>) {
+        self.show_compact_list(ModelRail::Favorites, "Search starred…", cx);
+    }
+
+    fn show_compact_list(
+        &mut self,
+        rail: ModelRail,
+        placeholder: &'static str,
+        cx: &mut Context<Self>,
+    ) {
+        self.setting_menu = None;
+        self.compact_providers = false;
+        self.compact_model_list = true;
+        self.model_rail = rail;
+        self.reset_compact_search(placeholder, cx);
+        // Open on the current model, at the top when it is near the start.
+        let selected = self.selected_model_index(cx);
+        self.active = selected;
+        if selected < COMPACT_LIST_ROWS as usize - 2 {
+            self.model_scroll_base().set_offset(gpui::Point::default());
+        } else {
+            self.model_scroll
+                .scroll_to_item_strict(selected, gpui::ScrollStrategy::Center);
+        }
+        self.focus_on_mount = true;
+        cx.notify();
+    }
+
+    pub(super) fn show_compact_providers(&mut self, cx: &mut Context<Self>) {
+        if self.harness_locked(cx) {
+            return;
+        }
+        self.setting_menu = None;
+        self.compact_model_list = false;
+        self.compact_providers = true;
+        self.reset_compact_search("Search providers…", cx);
+        let effective = self.effective_harness(cx);
+        self.active = self
+            .compact_provider_rows(cx)
+            .iter()
+            .position(|row| matches!(row, ProviderRow::Harness(d) if Some(d.id) == effective))
+            .unwrap_or(0);
+        popover::reset_menu_scroll(&self.menu_scroll, &mut self.menu_bar);
+        self.focus_on_mount = true;
+        cx.notify();
+    }
+
+    /// Back from either list page to the panel.
+    pub(super) fn show_compact_panel(&mut self, cx: &mut Context<Self>) {
+        self.compact_model_list = false;
+        self.compact_providers = false;
+        self.focus_on_mount = true;
+        cx.notify();
+    }
+
+    /// Clear the shared filter for a new page without letting the clear's
+    /// Edited event reset the highlight anchored right after.
+    fn reset_compact_search(&mut self, placeholder: &'static str, cx: &mut Context<Self>) {
+        self.search_reset_muted = !self.search.read(cx).text().is_empty();
+        self.search.update(cx, |input, cx| {
+            input.set_placeholder(placeholder, cx);
+            if !input.text().is_empty() {
+                input.set_text("", cx);
+            }
+        });
+    }
+
+    /// Starred models first (once any are starred), then the providers on
+    /// offer, narrowed by the filter.
+    pub(super) fn compact_provider_rows(&self, cx: &App) -> Vec<ProviderRow> {
+        let query = self.search.read(cx).text().trim().to_lowercase();
+        let matches = |name: &str| query.is_empty() || name.to_lowercase().contains(&query);
+        let starred = (!self.defaults.favorites.is_empty() && matches("Starred"))
+            .then_some(ProviderRow::Starred);
+        starred
+            .into_iter()
+            .chain(
+                self.rail_descriptors(cx)
+                    .into_iter()
+                    .filter(|d| matches(&d.name))
+                    .map(ProviderRow::Harness),
+            )
+            .collect()
+    }
+
+    /// Picking a provider runs its last-used model at that model's last
+    /// settings (the remembered defaults take over once the harness moves).
+    pub(super) fn pick_compact_provider(&mut self, harness: HarnessId, cx: &mut Context<Self>) {
+        self.model_rail = ModelRail::Harness;
+        self.pick_harness(harness, cx);
+        self.show_compact_panel(cx);
+    }
+
+    /// Both list pages share one header row: back to the panel, then the
+    /// page's filter beside it.
+    pub(super) fn compact_list_header(&mut self, cx: &mut Context<Self>) -> gpui::Div {
+        let theme = Theme::of(cx).for_popup();
+        div()
+            .h(px(40.0))
+            .flex_none()
+            .px(px(popover::CARD_INSET))
+            .border_b_1()
+            .border_color(crate::theme::hairline(0.08))
+            .flex()
+            .items_center()
+            .gap(px(4.0))
+            .child(
+                popover::menu_row(&theme, false, "compact-list-back")
+                    .id("compact-list-back")
+                    .role(gpui::Role::Button)
+                    .aria_label("Back")
+                    .flex_none()
+                    .on_click(cx.listener(|this, _, _, cx| this.show_compact_panel(cx)))
+                    .child(
+                        crate::icons::icon(crate::icons::ALT_ARROW_LEFT)
+                            .size(px(14.0))
+                            .text_color(theme.text_muted),
+                    ),
+            )
+            .child(
+                div()
+                    .flex_1()
+                    .min_w_0()
+                    .text_size(crate::typography::ui_rems(13.0))
+                    .child(self.search.clone()),
+            )
+    }
+
+    pub(super) fn render_compact_provider_page(&mut self, cx: &mut Context<Self>) -> AnyElement {
+        let theme = Theme::of(cx).for_popup();
+        let rows = self.compact_provider_rows(cx);
+        let effective = self.effective_harness(cx);
+        let list_height = compact_list_height(rows.len())
+            .min((self.menu_geometry().height - LIST_HEADER - CARD_BORDERS).max(0.0));
+        let items: Vec<AnyElement> = if rows.is_empty() {
+            vec![empty_list_note(&theme, "No providers found")]
+        } else {
+            rows.into_iter()
+                .enumerate()
+                .map(|(ix, row)| {
+                    let (icon, tint, name, selected): (_, _, SharedString, bool) = match &row {
+                        ProviderRow::Starred => {
+                            (crate::icons::STAR_BOLD, None, "Starred".into(), false)
+                        }
+                        ProviderRow::Harness(descriptor) => {
+                            let (icon, tint) = harness_brand_icon(descriptor.id);
+                            (
+                                icon,
+                                tint,
+                                descriptor.name.clone().into(),
+                                effective == Some(descriptor.id),
+                            )
+                        }
+                    };
+                    let item = div()
+                        .id(("compact-provider", ix))
+                        .role(gpui::Role::ListBoxOption)
+                        .aria_label(name.clone())
+                        .aria_selected(selected)
+                        .h(px(COMPACT_ROW_HEIGHT))
+                        .pl(px(8.0))
+                        .pr(px(8.0))
+                        .rounded(px(popover::MENU_ITEM_RADIUS))
+                        .flex()
+                        .items_center()
+                        .gap(px(8.0))
+                        .cursor_pointer()
+                        .text_color(theme.text)
+                        .border_1()
+                        .border_color(gpui::transparent_black())
+                        .when(selected, |el| crate::glass::light(el, &theme, 1.0))
+                        .when(!selected && self.active == ix, |el| {
+                            el.bg(crate::theme::ink(0.05))
+                        })
+                        .when(self.compact_keyboard && self.active == ix, |el| {
+                            el.aria_active_descendant()
+                        })
+                        .on_hover(cx.listener(move |this, hovered: &bool, _, cx| {
+                            if *hovered && (this.active != ix || this.compact_keyboard) {
+                                this.compact_keyboard = false;
+                                this.active = ix;
+                                cx.notify();
+                            }
+                        }))
+                        .on_click(cx.listener(move |this, _, _, cx| {
+                            this.activate_provider_row(row.clone(), cx)
+                        }))
+                        .child(
+                            crate::icons::icon(icon)
+                                .size(px(14.0))
+                                .flex_none()
+                                .text_color(tint.unwrap_or(theme.text_muted)),
+                        )
+                        .child(
+                            div()
+                                .flex_1()
+                                .min_w_0()
+                                .truncate()
+                                .text_size(crate::typography::ui_rems(12.0))
+                                .font_weight(gpui::FontWeight::MEDIUM)
+                                .child(name),
+                        );
+                    div()
+                        .pb(px(popover::MENU_GAP))
+                        .child(item)
+                        .into_any_element()
+                })
+                .collect()
+        };
+        let scrollbar = popover::rail(self, "compact-providers-scrollbar", &theme, cx);
+        let list = div()
+            .id("compact-providers-host")
+            .relative()
+            .flex_none()
+            .h(px(list_height))
+            .py(px(popover::CARD_INSET))
+            .bg(crate::theme::ink(0.02))
+            .on_hover(cx.listener(Self::on_menu_list_hover))
+            .child(popover::faded_menu_list(
+                &self.menu_scroll,
+                popover::menu_scroll_list("compact-providers", &self.menu_scroll)
+                    .size_full()
+                    .child(div().flex().flex_col().children(items)),
+            ))
+            .children(scrollbar);
+        div()
+            .flex()
+            .flex_col()
+            .child(self.compact_list_header(cx))
+            .child(list)
+            .into_any_element()
+    }
+
+    pub(super) fn compact_provider_key(&mut self, event: &KeyDownEvent, cx: &mut Context<Self>) {
+        let count = self.compact_provider_rows(cx).len();
+        match event.keystroke.key.as_str() {
+            "escape" => self.show_compact_panel(cx),
+            "up" | "down" => {
+                let current = (self.active < count).then_some(self.active);
+                self.active = popover::menu_step(
+                    current,
+                    count,
+                    if event.keystroke.key == "up" { -1 } else { 1 },
+                )
+                .unwrap_or(0);
+                self.compact_keyboard = true;
+                cx.notify();
+            }
+            "enter" => self.activate_compact_provider(cx),
+            _ => return,
+        }
+        cx.stop_propagation();
+    }
+
+    pub(super) fn activate_compact_provider(&mut self, cx: &mut Context<Self>) {
+        if let Some(row) = self.compact_provider_rows(cx).get(self.active).cloned() {
+            self.activate_provider_row(row, cx);
+        }
+    }
+
+    fn activate_provider_row(&mut self, row: ProviderRow, cx: &mut Context<Self>) {
+        match row {
+            ProviderRow::Starred => self.show_compact_starred(cx),
+            ProviderRow::Harness(descriptor) => self.pick_compact_provider(descriptor.id, cx),
+        }
+    }
+
+    pub(super) fn compact_fast_choice(&self, cx: &App) -> Option<(String, String, bool, bool)> {
+        let (option, on, off) = self
+            .selected_model(cx)?
+            .options
+            .iter()
+            .find_map(|o| fast_mode_values(o).map(|(on, off)| (o, on, off)))?;
+        let options = self.explicit_options(cx);
+        let fast = options
+            .get(&option.id)
+            .and_then(|v| v.as_str())
+            .unwrap_or(&option.default_choice)
+            == on;
+        let next = if fast { off } else { on };
+        Some((
+            option.id.clone(),
+            next.to_owned(),
+            next == option.default_choice,
+            fast,
+        ))
+    }
+
+    /// The selected model's fast-mode option id, whichever form it takes.
+    pub(super) fn fast_option_id(&self, cx: &App) -> Option<String> {
+        self.selected_model(cx)?
+            .options
+            .iter()
+            .find(|o| fast_mode_values(o).is_some())
+            .map(|o| o.id.clone())
+    }
+
+    /// The slider's stops: the model's reasoning ladder, else an option
+    /// shaped like one (Cursor's `effort`/`reasoning` choices), so every
+    /// model with an effort gets the same slider.
+    pub(super) fn compact_effort(&self, cx: &App) -> Option<CompactEffort> {
+        let levels = self.trait_ladder(cx);
+        if !levels.is_empty() {
+            let current = self.effective_reasoning(cx);
+            return Some(CompactEffort {
+                labels: levels.iter().map(|l| reasoning_label(*l).into()).collect(),
+                selected: levels.iter().position(|l| Some(*l) == current).unwrap_or(0),
+                stops: EffortStops::Reasoning(levels),
+            });
+        }
+        let option = self
+            .selected_model(cx)?
+            .options
+            .iter()
+            .find(|o| EFFORT_OPTION_IDS.contains(&o.id.as_str()) && o.choices.len() > 1)?;
+        let options = self.explicit_options(cx);
+        let current = options
+            .get(&option.id)
+            .and_then(|v| v.as_str())
+            .unwrap_or(&option.default_choice);
+        Some(CompactEffort {
+            labels: option
+                .choices
+                .iter()
+                .map(|c| SharedString::from(c.label.clone()))
+                .collect(),
+            selected: option
+                .choices
+                .iter()
+                .position(|c| c.id == current)
+                .unwrap_or(0),
+            stops: EffortStops::Option {
+                id: option.id.clone(),
+                choices: option.choices.iter().map(|c| c.id.clone()).collect(),
+                default: option.default_choice.clone(),
+            },
+        })
+    }
+
+    /// Option ids the compact card draws as its own controls, not rows.
+    pub(super) fn compact_hidden_options(&self, cx: &App) -> Vec<String> {
+        let effort = match self.compact_effort(cx).map(|e| e.stops) {
+            Some(EffortStops::Option { id, .. }) => Some(id),
+            _ => None,
+        };
+        self.fast_option_id(cx).into_iter().chain(effort).collect()
+    }
+
+    pub(super) fn pick_effort_at(&mut self, x: gpui::Pixels, cx: &mut Context<Self>) {
+        let Some(bounds) = self.effort_bounds else {
+            return;
+        };
+        let Some(effort) = self.compact_effort(cx) else {
+            return;
+        };
+        let count = effort.labels.len();
+        let Some(index) = effort_index(
+            f32::from(x - bounds.left()),
+            f32::from(bounds.size.width),
+            count,
+        ) else {
+            return;
+        };
+        if self.effort_dragging {
+            let fraction =
+                effort_fraction(f32::from(x - bounds.left()), f32::from(bounds.size.width));
+            self.compact_motion.drag_fraction = Some(if count > 1 { fraction } else { 0.0 });
+            cx.notify();
+        }
+        self.pick_compact_effort(effort, index, cx);
+    }
+
+    /// Effort and fast mode have their own controls in the compact card.
+    pub(super) fn compact_option_visible(id: &ModelSetting, hidden: &[String]) -> bool {
+        !matches!(id, ModelSetting::Reasoning)
+            && !matches!(id, ModelSetting::Option(id) if hidden.contains(id))
+    }
+
+    pub(super) fn pick_compact_effort(
+        &mut self,
+        effort: CompactEffort,
+        index: usize,
+        cx: &mut Context<Self>,
+    ) {
+        if index == effort.selected {
+            return;
+        }
+        match effort.stops {
+            EffortStops::Reasoning(levels) => {
+                let Some(level) = levels.get(index).copied() else {
+                    return;
+                };
+                self.pick_reasoning(level, cx);
+            }
+            EffortStops::Option {
+                id,
+                choices,
+                default,
+            } => {
+                let Some(choice) = choices.get(index).cloned() else {
+                    return;
+                };
+                let is_default = choice == default;
+                self.pick_option(id, choice, is_default, cx);
+            }
+        }
+        crate::haptics::selection_step();
+    }
+
+    pub(super) fn render_compact_menu(
+        &mut self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let hidden = self.compact_hidden_options(cx);
+        let options = self
+            .setting_groups(cx)
+            .iter()
+            .filter(|g| Self::compact_option_visible(&g.id, &hidden))
+            .count();
+        let effort = self.compact_effort(cx).is_some();
+        let panel_height = CARD_BORDERS
+            + header_block(effort)
+            + if effort { EFFORT_BLOCK } else { 0.0 }
+            + if options == 0 {
+                0.0
+            } else {
+                OPTIONS_GAP + options_height(options)
+            };
+        let page = if self.compact_providers {
+            CompactPage::Providers
+        } else if self.compact_model_list {
+            CompactPage::Models
+        } else {
+            CompactPage::Panel
+        };
+        let target = self.menu_geometry().height.min(match page {
+            CompactPage::Models => {
+                LIST_HEADER + compact_list_height(self.model_rows_len(cx)) + CARD_BORDERS
+            }
+            CompactPage::Providers => {
+                LIST_HEADER
+                    + compact_list_height(self.compact_provider_rows(cx).len())
+                    + CARD_BORDERS
+            }
+            CompactPage::Panel => panel_height,
+        });
+        let (height, moving) = ScalarTransition::sample(
+            &mut self.compact_motion.height,
+            target,
+            std::time::Instant::now(),
+            cx.reduce_motion(),
+        );
+        self.compact_motion.frame_height = height;
+        if moving {
+            window.request_animation_frame();
+        }
+        let content = match page {
+            CompactPage::Models => self.render_harness_model_popover(cx),
+            CompactPage::Providers => self.render_compact_provider_page(cx),
+            CompactPage::Panel => self.render_compact_model_panel(window, cx),
+        };
+        let now = std::time::Instant::now();
+        if self.compact_motion.page.is_some_and(|last| last != page) {
+            self.compact_motion.reveal = Some(ScalarTransition {
+                from: 0.0,
+                to: 1.0,
+                started: now,
+            });
+        }
+        self.compact_motion.page = Some(page);
+        let (reveal, revealing) = ScalarTransition::sample(
+            &mut self.compact_motion.reveal,
+            1.0,
+            now,
+            cx.reduce_motion(),
+        );
+        if revealing {
+            window.request_animation_frame();
+        }
+        // The new page fades in while the card resizes to it: the swap
+        // never shows at full strength and nothing slides sideways against
+        // the vertical resize. Initial opening uses the popover entrance.
+        let content = div().opacity(reveal).child(content).into_any_element();
+        self.popover_frame_flush(COMPACT_WIDTH, content, cx)
+    }
+
+    /// The panel's shortcuts, live only while it is the picker's page: Up
+    /// and Down open the model list on the model beside the selected one,
+    /// Tab cycles providers, Left/Right (Home/End) set the effort.
+    pub(super) fn compact_panel_key(&mut self, event: &KeyDownEvent, cx: &mut Context<Self>) {
+        self.compact_keyboard = true;
+        match event.keystroke.key.as_str() {
+            "escape" => self.animate_close(cx),
+            "up" | "down" => {
+                self.show_compact_models(cx);
+                let delta = if event.keystroke.key == "up" { -1 } else { 1 };
+                if let Some(next) =
+                    popover::menu_step(Some(self.active), self.model_rows_len(cx), delta)
+                {
+                    self.active = next;
+                    self.model_scroll
+                        .scroll_to_item(next, gpui::ScrollStrategy::Nearest);
+                }
+            }
+            "enter" | "space" => self.show_compact_models(cx),
+            "tab" => {
+                let delta = if event.keystroke.modifiers.shift {
+                    -1
+                } else {
+                    1
+                };
+                self.cycle_compact_provider(delta, cx);
+            }
+            "left" | "right" | "home" | "end" => {
+                if let Some(effort) = self.compact_effort(cx) {
+                    let last = effort.labels.len().saturating_sub(1);
+                    let next = match event.keystroke.key.as_str() {
+                        "left" => effort.selected.saturating_sub(1),
+                        "right" => (effort.selected + 1).min(last),
+                        "home" => 0,
+                        _ => last,
+                    };
+                    self.pick_compact_effort(effort, next, cx);
+                }
+            }
+            _ => return,
+        }
+        cx.notify();
+        cx.stop_propagation();
+    }
+
+    /// Tab on the panel: the next provider on offer, wrapping, at its
+    /// last-used model. A chat's fixed provider stays put.
+    fn cycle_compact_provider(&mut self, delta: isize, cx: &mut Context<Self>) {
+        if self.harness_locked(cx) {
+            return;
+        }
+        let providers = self.rail_descriptors(cx);
+        let current = self
+            .effective_harness(cx)
+            .and_then(|harness| providers.iter().position(|d| d.id == harness));
+        if let Some(next) = popover::menu_step(current, providers.len(), delta) {
+            self.pick_compact_provider(providers[next].id, cx);
+        }
+    }
+
+    pub(super) fn render_compact_model_panel(
+        &mut self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let theme = Theme::of(cx).for_popup();
+        let (levels, selected) = self
+            .compact_effort(cx)
+            .map_or((Vec::new(), 0), |e| (e.labels, e.selected));
+        let label: SharedString = self
+            .selected_model(cx)
+            .map(|m| m.label.clone())
+            .unwrap_or_else(|| "Select model".into())
+            .into();
+        let effort: SharedString = levels
+            .get(selected)
+            .cloned()
+            .unwrap_or_else(|| "Default".into());
+        let model_accessible: SharedString =
+            format!("{} · {} · Change model", effort, label).into();
+        let now = std::time::Instant::now();
+        let reduced = cx.reduce_motion();
+        // Fast mode alone brings the fill to life: a sheen and speed streaks
+        // racing toward the thumb, and a breathing glow.
+        let fast = self
+            .compact_fast_choice(cx)
+            .is_some_and(|(_, _, _, fast)| fast);
+        let (intensity, powering) = ScalarTransition::sample(
+            &mut self.compact_motion.energy,
+            if fast { 1.0 } else { 0.0 },
+            now,
+            reduced,
+        );
+        if powering {
+            window.request_animation_frame();
+        }
+        let dt = self
+            .compact_motion
+            .shimmer_last_frame
+            .replace(now)
+            .map_or(0.0, |last| now.duration_since(last).as_secs_f32().min(0.05));
+        let alive =
+            intensity > 0.001 && !reduced && window.is_window_active() && self.open.is_open();
+        if alive {
+            self.compact_motion.shimmer_phase =
+                (self.compact_motion.shimmer_phase + dt * (0.32 + 0.22 * intensity)).fract();
+            window.request_animation_frame();
+        }
+        let phase = self.compact_motion.shimmer_phase;
+        let breath = if alive {
+            0.5 + 0.5 * (std::f32::consts::TAU * phase).sin()
+        } else {
+            0.5
+        };
+        // The effort titles the model's name as one button filling the row
+        // up to fast mode, its text on the rail's and option rows' edge; fast
+        // mode is a small icon button whose glyph ends where the rail does.
+        // The chevron leans toward the list on hover.
+        let model_key: SharedString = format!("compact-model-link-{}", cx.entity_id()).into();
+        let hover = motion::hover_t(&model_key);
+        let lean = motion::EASE_OUT_QUINT.eval(hover);
+        let title = div()
+            .id("compact-select-model")
+            .role(gpui::Role::Button)
+            .aria_label(model_accessible)
+            .flex_1()
+            .min_w_0()
+            .h_full()
+            .px(px(8.0))
+            .rounded(px(popover::MENU_ITEM_RADIUS))
+            .bg(crate::theme::ink(0.05 * hover))
+            .flex()
+            .flex_col()
+            .items_start()
+            .justify_center()
+            .cursor_pointer()
+            .on_hover(motion::hover_listener(model_key))
+            .on_click(cx.listener(|this, _, _, cx| {
+                this.compact_keyboard = false;
+                this.show_compact_models(cx);
+            }))
+            .when(!levels.is_empty(), |el| {
+                el.child(
+                    div()
+                        .text_size(crate::typography::ui_rems(14.0))
+                        .line_height(px(17.0))
+                        .font_weight(gpui::FontWeight::SEMIBOLD)
+                        .text_color(theme.text)
+                        .child(effort.clone()),
+                )
+            })
+            .child(
+                div()
+                    .max_w_full()
+                    .min_w_0()
+                    .flex()
+                    .items_center()
+                    .gap(px(3.0))
+                    .map(|el| {
+                        if levels.is_empty() {
+                            // The name is the whole title: no effort above it.
+                            el.text_size(crate::typography::ui_rems(14.0))
+                                .line_height(px(17.0))
+                                .font_weight(gpui::FontWeight::SEMIBOLD)
+                                .text_color(theme.text)
+                        } else {
+                            el.text_size(crate::typography::ui_rems(12.0))
+                                .line_height(px(15.0))
+                                .text_color(motion::mix(theme.text_muted, theme.text, hover))
+                        }
+                    })
+                    .child(div().min_w_0().truncate().child(label.clone()))
+                    .child(
+                        // Leans 3pt toward the list and firms up on hover.
+                        div()
+                            .flex_none()
+                            .relative()
+                            .left(px(3.0 * lean))
+                            .opacity(0.55 + 0.45 * lean)
+                            .child(
+                                crate::icons::icon(crate::icons::ALT_ARROW_RIGHT)
+                                    .size(px(10.0))
+                                    .text_color(motion::mix(theme.text_muted, theme.text, lean)),
+                            ),
+                    ),
+            );
+        let mut fast_button = None;
+        if let Some((option, choice, default, fast)) = self.compact_fast_choice(cx) {
+            let (fast_t, fading) = ScalarTransition::sample(
+                &mut self.compact_motion.fast,
+                if fast { 1.0 } else { 0.0 },
+                now,
+                reduced,
+            );
+            if fading {
+                window.request_animation_frame();
+            }
+            let fast_key: SharedString = format!("compact-fast-{}", cx.entity_id()).into();
+            let fast_hover = motion::hover_t(&fast_key);
+            fast_button = Some(
+                div()
+                    .id("compact-fast")
+                    .role(gpui::Role::Button)
+                    .aria_label("Fast mode")
+                    .aria_toggled(if fast {
+                        gpui::Toggled::True
+                    } else {
+                        gpui::Toggled::False
+                    })
+                    .tooltip(move |_, cx| {
+                        cx.new(|_| {
+                            PickerHint(
+                                if fast {
+                                    "Fast mode on · Turn off"
+                                } else {
+                                    "Fast mode off · Turn on"
+                                }
+                                .into(),
+                            )
+                        })
+                        .into()
+                    })
+                    // Bare like the model button beside it: a plate only on
+                    // hover. The glyph's colour is the state, and the
+                    // slider's fill carries the accent.
+                    .w(px(FAST_BUTTON_WIDTH))
+                    .h_full()
+                    .flex_none()
+                    .rounded(px(popover::MENU_ITEM_RADIUS))
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .cursor_pointer()
+                    .bg(crate::theme::ink(0.05 * fast_hover))
+                    .on_hover(motion::hover_listener(fast_key))
+                    .on_click(cx.listener(move |this, _, _, cx| {
+                        this.compact_keyboard = false;
+                        this.pick_option(option.clone(), choice.clone(), default, cx);
+                    }))
+                    .child({
+                        let color = motion::mix(
+                            motion::mix(theme.text_muted, theme.text, fast_hover),
+                            theme.accent,
+                            fast_t,
+                        );
+                        // On fills the bolt: the solid twin fades in over the
+                        // outline, which shares its silhouette.
+                        div()
+                            .relative()
+                            .size(px(15.0))
+                            .child(
+                                crate::icons::icon(crate::icons::FAST_TIER)
+                                    .size(px(15.0))
+                                    .text_color(color),
+                            )
+                            .when(fast_t > 0.0, |el| {
+                                el.child(
+                                    crate::icons::icon(crate::icons::FAST_TIER_BOLD)
+                                        .absolute()
+                                        .top_0()
+                                        .left_0()
+                                        .size(px(15.0))
+                                        .text_color(color.opacity(fast_t)),
+                                )
+                            })
+                    }),
+            );
+        }
+        // The provider is a square button as tall as the title, leading it.
+        // A chat whose harness is fixed shows the mark without the button.
+        let header_height = if levels.is_empty() {
+            HEADER_HEIGHT_SINGLE
+        } else {
+            HEADER_HEIGHT
+        };
+        let locked = self.harness_locked(cx);
+        let provider_button = self.effective_harness(cx).map(|harness| {
+            let (icon, tint) = harness_brand_icon(harness);
+            let name: SharedString = self
+                .rail_descriptors(cx)
+                .into_iter()
+                .find(|d| d.id == harness)
+                .map(|d| d.name)
+                .unwrap_or_default()
+                .into();
+            let provider_key: SharedString = format!("compact-provider-{}", cx.entity_id()).into();
+            let provider_hover = if locked {
+                0.0
+            } else {
+                motion::hover_t(&provider_key)
+            };
+            let hint: SharedString = if locked {
+                name.clone()
+            } else {
+                format!("{name} · Change provider").into()
+            };
+            div()
+                .id("compact-select-provider")
+                .w(px(FAST_BUTTON_WIDTH))
+                .h_full()
+                .flex_none()
+                .rounded(px(popover::MENU_ITEM_RADIUS))
+                .flex()
+                .items_center()
+                .justify_center()
+                .bg(crate::theme::ink(0.05 * provider_hover))
+                .tooltip(move |_, cx| cx.new(|_| PickerHint(hint.clone())).into())
+                .when(!locked, |el| {
+                    el.role(gpui::Role::Button)
+                        .aria_label(SharedString::from(format!("{name} · Change provider")))
+                        .cursor_pointer()
+                        .on_hover(motion::hover_listener(provider_key))
+                        .on_click(cx.listener(|this, _, _, cx| {
+                            this.compact_keyboard = false;
+                            this.show_compact_providers(cx);
+                        }))
+                })
+                .child(
+                    crate::icons::icon(icon)
+                        .size(px(16.0))
+                        .text_color(tint.unwrap_or(theme.text_muted)),
+                )
+        });
+        let header = div()
+            .h(px(header_height))
+            .flex_none()
+            .flex()
+            .gap(px(popover::CARD_INSET))
+            .children(provider_button)
+            .child(title)
+            .children(fast_button);
+        let mut panel = div()
+            .p(px(popover::CARD_INSET))
+            .flex()
+            .flex_col()
+            .child(header);
+        if !levels.is_empty() {
+            let target = if levels.len() > 1 {
+                selected as f32 / (levels.len() - 1) as f32
+            } else {
+                0.0
+            };
+            let (mut fraction, moving) =
+                ScalarTransition::sample(&mut self.compact_motion.effort, target, now, reduced);
+            if self.effort_dragging {
+                fraction = self.compact_motion.drag_fraction.unwrap_or(target);
+                // Keep the release animation rooted at the actual pointer, not the previous stop.
+                self.compact_motion.effort = Some(ScalarTransition {
+                    from: fraction,
+                    to: fraction,
+                    started: now,
+                });
+            }
+            if moving {
+                window.request_animation_frame();
+            }
+            let (press, pressing) = ScalarTransition::sample(
+                &mut self.compact_motion.press,
+                if self.effort_dragging { 1.0 } else { 0.0 },
+                now,
+                reduced,
+            );
+            if pressing {
+                window.request_animation_frame();
+            }
+            let entity = cx.entity().downgrade();
+            let drag_entity = entity.clone();
+            let slider = div()
+                .id("compact-effort-slider")
+                .role(gpui::Role::Slider)
+                .aria_label("Reasoning effort")
+                .aria_value(effort.clone())
+                .aria_numeric_value(selected as f64)
+                .aria_min_numeric_value(0.0)
+                .aria_max_numeric_value(levels.len().saturating_sub(1) as f64)
+                .aria_numeric_value_step(1.0)
+                .aria_orientation(gpui::Orientation::Horizontal)
+                .aria_description("Use Left and Right to adjust reasoning; Home and End select the first and last levels")
+                .relative()
+                .h(px(SLIDER_HEIGHT))
+                .cursor_pointer()
+                .on_mouse_down(
+                    gpui::MouseButton::Left,
+                    cx.listener(|this, event: &gpui::MouseDownEvent, window, cx| {
+                        window.focus(&this.focus, cx);
+                        this.compact_keyboard = false;
+                        this.active = NO_ACTIVE_ROW;
+                        this.effort_dragging = true;
+                        this.pick_effort_at(event.position.x, cx);
+                        cx.notify();
+                        cx.stop_propagation();
+                    }),
+                )
+                .child(
+                    gpui::canvas(
+                        move |bounds, _, cx| {
+                            let _ = entity.update(cx, |this, _| this.effort_bounds = Some(bounds));
+                        },
+                        move |_, _, window, _| {
+                            let release = drag_entity.clone();
+                            window.on_mouse_event(move |_: &gpui::MouseUpEvent, phase, _, cx| {
+                                if phase == gpui::DispatchPhase::Bubble {
+                                    let _ = release.update(cx, |this, cx| {
+                                        if this.effort_dragging {
+                                            this.effort_dragging = false;
+                                            this.compact_motion.drag_fraction = None;
+                                            cx.notify();
+                                        }
+                                    });
+                                }
+                            });
+                            let entity = drag_entity.clone();
+                            window.on_mouse_event(
+                                move |event: &gpui::MouseMoveEvent, phase, _, cx| {
+                                    if phase == gpui::DispatchPhase::Bubble
+                                        && event.pressed_button == Some(gpui::MouseButton::Left)
+                                    {
+                                        let _ = entity.update(cx, |this, cx| {
+                                            if this.effort_dragging {
+                                                this.pick_effort_at(event.position.x, cx);
+                                            }
+                                        });
+                                    }
+                                },
+                            );
+                        },
+                    )
+                    .absolute()
+                    .inset_0(),
+                )
+                .child(crate::glass::light(
+                    div()
+                        .absolute()
+                        .left_0()
+                        .right_0()
+                        .top(px(RAIL_TOP))
+                        .h(px(RAIL_HEIGHT))
+                        .rounded_full(),
+                    &theme,
+                    1.0,
+                ))
+                // A contained glow: it must not wash over the option rows.
+                .child(effort_fill(
+                    &theme,
+                    fraction,
+                    levels.len(),
+                    Shimmer {
+                        intensity,
+                        phase,
+                        breath,
+                    },
+                ))
+                .child({
+                    // A plain handle that keeps its size; a press only lifts
+                    // it on a softer, wider drop.
+                    let (w, h) = (THUMB_WIDTH, THUMB_HEIGHT);
+                    // Fast mode breathes a soft accent halo under the thumb.
+                    let live = intensity * (0.55 + 0.45 * breath);
+                    let place = |el: gpui::Div| {
+                        el.absolute()
+                            .left(gpui::relative(fraction))
+                            .ml(px(-w / 2.0))
+                            .w(px(w))
+                            .h(px(h))
+                            .rounded_full()
+                    };
+                    div()
+                        .absolute()
+                        .left(px(THUMB_INSET))
+                        .right(px(THUMB_INSET))
+                        .top(px((SLIDER_HEIGHT - h) / 2.0))
+                        .when(intensity > 0.001, |el| {
+                            el.child(place(div()).shadow(vec![gpui::BoxShadow {
+                                color: theme.accent.opacity(0.35 * live),
+                                offset: gpui::point(px(0.0), px(1.0)),
+                                blur_radius: px(10.0),
+                                spread_radius: px(0.0),
+                                inset: false,
+                            }]))
+                        })
+                        .when(press > 0.001, |el| {
+                            el.child(place(div()).shadow(vec![gpui::BoxShadow {
+                                color: gpui::black().opacity(0.12 * press),
+                                offset: gpui::point(px(0.0), px(2.0 * press)),
+                                blur_radius: px(8.0),
+                                spread_radius: px(0.0),
+                                inset: false,
+                            }]))
+                        })
+                        .child(
+                            crate::glass::thumb(place(div()), &theme),
+                        )
+                });
+            // The rail starts on the same edge as the title and row labels.
+            panel = panel.child(
+                div()
+                    .px(px(8.0))
+                    .pt(px(SLIDER_TOP))
+                    .pb(px(SLIDER_BOTTOM))
+                    .child(slider),
+            );
+        }
+        let hidden = self.compact_hidden_options(cx);
+        let option_count = self
+            .setting_groups(cx)
+            .iter()
+            .filter(|g| Self::compact_option_visible(&g.id, &hidden))
+            .count();
+        if option_count > 0 {
+            let options = self.render_traits_sections(cx);
+            let scrollbar = popover::rail(self, "compact-options-scrollbar", &theme, cx);
+            let chrome = CARD_BORDERS
+                + header_block(!levels.is_empty())
+                + if levels.is_empty() { 0.0 } else { EFFORT_BLOCK }
+                + OPTIONS_GAP;
+            // Space, not a rule, separates the options from the effort group.
+            panel = panel.child(
+                div().mt(px(OPTIONS_GAP)).child(
+                    popover::menu_scroll_host("compact-options-host")
+                        .on_hover(cx.listener(Self::on_menu_list_hover))
+                        .child(popover::faded_menu_list(
+                            &self.menu_scroll,
+                            popover::menu_scroll_list("compact-options", &self.menu_scroll)
+                                .max_h(px(options_height(option_count)
+                                    .min((self.menu_geometry().height - chrome).max(0.0))))
+                                .child(options),
+                        ))
+                        .children(scrollbar),
+                ),
+            );
+        }
+        panel.into_any_element()
+    }
+}
+
+/// The accent glass fill from the rail's start to just past the thumb, with
+/// the stops painted over rail and fill in one coordinate space.
+#[derive(Clone, Copy)]
+struct Shimmer {
+    /// 0 at rest, up to 1 for fast mode on a top level.
+    intensity: f32,
+    /// 0–1 position of the band's sweep.
+    phase: f32,
+    /// 0–1 breathing of the glow.
+    breath: f32,
+}
+
+fn effort_fill(theme: &Theme, fraction: f32, count: usize, shimmer: Shimmer) -> AnyElement {
+    let Shimmer {
+        intensity,
+        phase,
+        breath,
+    } = shimmer;
+    // A contained glow that breathes; it must not wash over the option rows.
+    let fill = crate::glass::accent_plate(theme, 1.0, intensity * (0.2 + 0.25 * breath));
+    let accent = theme.accent;
+    // Quiet stops: a hint of the ladder, not a second focal point.
+    let filled_stop = gpui::white().opacity(0.4);
+    let open_stop = theme.text_muted.opacity(0.28);
+    gpui::canvas(
+        |_, _, _| (),
+        move |bounds, _, window, _| {
+            let width = f32::from(bounds.size.width);
+            let run = (width - 2.0 * THUMB_INSET).max(0.0);
+            let center = THUMB_INSET + fraction * run;
+            let rect = |x: f32, y: f32, w: f32, h: f32| {
+                gpui::Bounds::new(
+                    bounds.origin + gpui::point(px(x), px(y)),
+                    gpui::size(px(w), px(h)),
+                )
+            };
+            fill.paint(
+                window,
+                rect(0.0, RAIL_TOP, (center + FILL_PAST).min(width), RAIL_HEIGHT),
+                RAIL_HEIGHT / 2.0,
+            );
+            // Fast mode: a band of light flows through the whole fill toward
+            // the thumb. Two slow waves drift at different speeds, shading
+            // the fill between a lifted accent and a hue-shifted one, and the
+            // light gathers just before the thumb. It is painted in thin
+            // strips whose gradients join end to end; the end strips carry
+            // the fill's corner radius, so it never leaves the rounded ends.
+            let fill_end = (center + FILL_PAST).min(width);
+            if intensity > 0.001 && fill_end > RAIL_HEIGHT {
+                let inset = 1.0;
+                let height = RAIL_HEIGHT - 2.0 * inset;
+                let radius = height / 2.0;
+                let (from, to) = (inset, fill_end - inset);
+                let base = accent;
+                let lifted = motion::mix(base, gpui::white(), 0.45);
+                let shifted = gpui::hsla(
+                    (base.h + 0.07).fract(),
+                    base.s,
+                    (base.l + 0.14).min(0.9),
+                    1.0,
+                );
+                let tau = std::f32::consts::TAU;
+                let flow = |x: f32| -> gpui::Hsla {
+                    let slow = 0.5 + 0.5 * (tau * (x / 150.0 - 2.0 * phase)).sin();
+                    let quick = 0.5 + 0.5 * (tau * (x / 64.0 - 3.0 * phase) + 1.7).sin();
+                    let glow = (0.65 * slow + 0.35 * quick).powi(2);
+                    let charge = (-(center - x).max(0.0) / 40.0).exp() * (0.6 + 0.4 * breath);
+                    let lead = ((x - from) / 28.0).clamp(0.0, 1.0);
+                    let alpha = intensity * ((0.08 + 0.34 * glow) * lead + 0.22 * charge);
+                    motion::mix(shifted, lifted, slow).opacity(alpha.min(1.0))
+                };
+                let mut edges = vec![from, (from + radius).min(to)];
+                let inner_end = (to - radius).max(edges[1]);
+                let mut x = edges[1];
+                while x + 4.0 < inner_end {
+                    x += 4.0;
+                    edges.push(x);
+                }
+                if inner_end > *edges.last().unwrap() {
+                    edges.push(inner_end);
+                }
+                if to > *edges.last().unwrap() {
+                    edges.push(to);
+                }
+                let last = edges.len().saturating_sub(2);
+                for (i, pair) in edges.windows(2).enumerate() {
+                    let (x0, x1) = (pair[0], pair[1]);
+                    if x1 - x0 < 0.1 {
+                        continue;
+                    }
+                    let r = px(radius.min(x1 - x0));
+                    let zero = px(0.0);
+                    let corners = gpui::Corners {
+                        top_left: if i == 0 { r } else { zero },
+                        bottom_left: if i == 0 { r } else { zero },
+                        top_right: if i == last { r } else { zero },
+                        bottom_right: if i == last { r } else { zero },
+                    };
+                    window.paint_quad(gpui::quad(
+                        rect(x0, RAIL_TOP + inset, x1 - x0, height),
+                        corners,
+                        gpui::linear_gradient(
+                            90.0,
+                            gpui::linear_color_stop(flow(x0), 0.0),
+                            gpui::linear_color_stop(flow(x1), 1.0),
+                        ),
+                        px(0.0),
+                        gpui::transparent_black(),
+                        gpui::BorderStyle::default(),
+                    ));
+                }
+            }
+            for i in 0..count {
+                let stop = if count > 1 {
+                    i as f32 / (count - 1) as f32
+                } else {
+                    0.0
+                };
+                let x = THUMB_INSET + stop * run;
+                // Filled stops follow the animated front, never jump ahead of it.
+                let color = if stop <= fraction {
+                    filled_stop
+                } else {
+                    open_stop
+                };
+                window.paint_quad(gpui::quad(
+                    rect(x - 2.0, SLIDER_HEIGHT / 2.0 - 2.0, 4.0, 4.0),
+                    px(2.0),
+                    color,
+                    px(0.0),
+                    gpui::transparent_black(),
+                    gpui::BorderStyle::default(),
+                ));
+            }
+        },
+    )
+    .absolute()
+    .inset_0()
+    .into_any_element()
+}
+
+fn effort_fraction(x: f32, width: f32) -> f32 {
+    ((x - THUMB_INSET) / (width - THUMB_INSET * 2.0).max(1.0)).clamp(0.0, 1.0)
+}
+
+/// Slider stops include both endpoints and only advertised reasoning levels.
+fn effort_index(x: f32, width: f32, count: usize) -> Option<usize> {
+    (count > 0)
+        .then(|| (effort_fraction(x, width) * count.saturating_sub(1) as f32).round() as usize)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compact_transitions_start_settled_and_retarget_without_jumping() {
+        let start = std::time::Instant::now();
+        let mut state = None;
+        assert_eq!(
+            ScalarTransition::sample(&mut state, 0.5, start, false),
+            (0.5, false)
+        );
+        assert_eq!(
+            ScalarTransition::sample(&mut state, 1.0, start, false).0,
+            0.5
+        );
+        let middle = start + motion::RESIZE.total().mul_f32(motion::speed_scale() * 0.5);
+        let before = state.as_ref().unwrap().value(middle);
+        let retargeted = ScalarTransition::sample(&mut state, 0.0, middle, false).0;
+        assert!((before - retargeted).abs() < 0.0001);
+        assert_eq!(
+            ScalarTransition::sample(&mut state, 0.0, middle, true),
+            (0.0, false)
+        );
+    }
+
+    #[test]
+    fn continuous_drag_and_stops_share_inset_geometry() {
+        let width = 228.0;
+        for count in 2..=8 {
+            for index in 0..count {
+                let fraction = index as f32 / (count - 1) as f32;
+                let x = THUMB_INSET + fraction * (width - THUMB_INSET * 2.0);
+                assert!((effort_fraction(x, width) - fraction).abs() < 0.00001);
+                assert_eq!(effort_index(x, width, count), Some(index));
+                assert!(x - 2.0 >= 0.0 && x + 2.0 <= width);
+            }
+        }
+        assert!((effort_fraction(68.0, width) - 0.25).abs() < 0.00001);
+        assert_eq!(effort_fraction(-100.0, width), 0.0);
+        assert_eq!(effort_fraction(500.0, width), 1.0);
+    }
+
+    #[test]
+    fn effort_stops_clamp_and_round_to_advertised_levels() {
+        assert_eq!(effort_index(100.0, 200.0, 0), None);
+        assert_eq!(effort_index(100.0, 200.0, 1), Some(0));
+        assert_eq!(effort_index(-20.0, 200.0, 5), Some(0));
+        assert_eq!(effort_index(100.0, 200.0, 5), Some(2));
+        assert_eq!(effort_index(250.0, 200.0, 5), Some(4));
+    }
+}
+
+struct PickerHint(SharedString);
+impl Render for PickerHint {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = Theme::of(cx).for_popup();
+        let card = popover::popover_card(&theme)
+            .max_w(px(320.0))
+            .p(px(8.0))
+            .text_size(crate::typography::ui_rems(12.0))
+            .line_height(px(17.0))
+            .text_color(theme.text)
+            .child(self.0.clone());
+        crate::frost::frosted(popover::CARD_RADIUS, crate::frost::MENU_BLUR, card)
+    }
+}
diff --git a/crates/ui/src/popover.rs b/crates/ui/src/popover.rs
index 7f11259b44..c9b28e287c 100644
--- a/crates/ui/src/popover.rs
+++ b/crates/ui/src/popover.rs
@@ -513,14 +513,29 @@ fn frosted_menu(exit: Option<f32>, content: AnyElement) -> AnyElement {
 /// and the overlay also keeps stray clicks from reaching whatever sits
 /// underneath.
 fn menu_motion(id: SharedString, exit: Option<f32>, inner: gpui::Div) -> AnyElement {
+    menu_motion_from(id, exit, inner, -2.0)
+}
+
+/// [`menu_motion`] with the entrance travelling `from` px (signed) out of
+/// the trigger's side, and the exit retreating back toward it.
+fn menu_motion_from(
+    id: SharedString,
+    exit: Option<f32>,
+    inner: gpui::Div,
+    from: f32,
+) -> AnyElement {
     if let Some(t) = exit {
         let inner = inner.relative().child(div().absolute().inset_0().occlude());
-        motion::menu_out(SharedString::from(format!("{id}-out")), t, inner).into_any_element()
+        motion::menu_out_toward(SharedString::from(format!("{id}-out")), from, t, inner)
+            .into_any_element()
     } else {
-        motion::menu_in(id, inner).into_any_element()
+        motion::menu_in_from(id, from, inner).into_any_element()
     }
 }
 
+/// Entrance travel for menus that open away from a trigger edge.
+const MENU_TRAVEL: f32 = 4.0;
+
 /// Wrap popover content in a floating anchored layer attached to the trigger:
 /// the caller `.child(anchored_menu(...))`s this from the trigger element while
 /// open. Plays `menu-in` (0.14s fade + 2px drop); `closing` (the [`Popup`]
@@ -583,10 +598,11 @@ pub fn anchored_menu_below_end(
                 gpui::anchored()
                     .anchor(Anchor::TopRight)
                     .snap_to_window_with_margin(px(8.0))
-                    .child(menu_motion(
+                    .child(menu_motion_from(
                         id.into(),
                         exit,
                         div().occlude().pt(px(6.0)).child(content),
+                        -MENU_TRAVEL,
                     )),
             )
             .priority(1)
@@ -684,10 +700,11 @@ pub fn anchored_menu_below_layer(
                 gpui::anchored()
                     .anchor(Anchor::TopLeft)
                     .snap_to_window_with_margin(px(8.0))
-                    .child(menu_motion(
+                    .child(menu_motion_from(
                         id.into(),
                         exit,
                         div().occlude().pt(px(gap)).child(content),
+                        -MENU_TRAVEL,
                     )),
             )
             .priority(priority)
@@ -711,10 +728,11 @@ pub fn anchored_menu_above(
             gpui::anchored()
                 .anchor(Anchor::BottomLeft)
                 .snap_to_window_with_margin(px(8.0))
-                .child(menu_motion(
+                .child(menu_motion_from(
                     id.into(),
                     exit,
                     div().occlude().pb(px(6.0)).child(content),
+                    MENU_TRAVEL,
                 )),
         )
         .priority(1)
@@ -783,10 +801,11 @@ pub fn anchored_menu_above_end(
                 gpui::anchored()
                     .anchor(Anchor::BottomRight)
                     .snap_to_window_with_margin(px(8.0))
-                    .child(menu_motion(
+                    .child(menu_motion_from(
                         id.into(),
                         exit,
                         div().occlude().pb(px(6.0)).child(content),
+                        MENU_TRAVEL,
                     )),
             )
             .priority(1)
diff --git a/crates/ui/src/settings.rs b/crates/ui/src/settings.rs
index e142454e63..6aaad42a3d 100644
--- a/crates/ui/src/settings.rs
+++ b/crates/ui/src/settings.rs
@@ -348,6 +348,12 @@ pub fn current(cx: &App) -> UiSettings {
         .unwrap_or_default()
 }
 
+/// Read the picker preference without cloning the full settings for each model row.
+pub fn compact_model_picker(cx: &App) -> bool {
+    cx.try_global::<SettingsStore>()
+        .is_some_and(|store| store.current.compact_model_picker)
+}
+
 /// Copy a selected image into Zeron's device-local data directory and make it
 /// the new-thread canvas background. A unique file name avoids stale image
 /// caches when the background is replaced.
@@ -787,6 +793,8 @@ pub struct UiSettings {
     pub skills_in_slash_menu: bool,
     pub skill_completion_by_harness:
         std::collections::HashMap<zeron_proto::HarnessId, SkillCompletionSettings>,
+    /// Open model selection with an effort slider and a separate model list.
+    pub compact_model_picker: bool,
     pub sidebar_width: f32,
     pub sidebar_collapsed: bool,
     /// Legacy: the grouped-by-project toggle predates spaces (which group by
@@ -998,6 +1006,7 @@ impl Default for UiSettings {
             composer_send_behavior: ComposerSendBehavior::default(),
             skills_in_slash_menu: false,
             skill_completion_by_harness: Default::default(),
+            compact_model_picker: true,
             appshots_enabled: false,
             appshot_sound_enabled: true,
             appshot_destination: crate::appshots::AppshotDestination::Automatic,
@@ -1830,6 +1839,19 @@ mod tests {
         assert!(UiSettings::load(dir.path()).skills_in_slash_menu);
     }
 
+    #[test]
+    fn compact_model_picker_is_default_and_opt_out_persists() {
+        let legacy: UiSettings = serde_json::from_str("{}").unwrap();
+        assert!(legacy.compact_model_picker);
+        let settings = UiSettings {
+            compact_model_picker: false,
+            ..legacy
+        };
+        let saved = serde_json::to_string(&settings).unwrap();
+        let loaded: UiSettings = serde_json::from_str(&saved).unwrap();
+        assert!(!loaded.compact_model_picker);
+    }
+
     #[test]
     fn composer_send_behavior_is_opt_in_for_old_and_partial_settings() {
         let dir = tempfile::tempdir().unwrap();
@@ -2534,6 +2556,7 @@ mod tests {
             composer_send_behavior: ComposerSendBehavior::ModEnter,
             skills_in_slash_menu: true,
             skill_completion_by_harness: Default::default(),
+            compact_model_picker: true,
             appshots_enabled: false,
             appshot_sound_enabled: true,
             // The destination is only persisted where Appshots exist (macOS and
diff --git a/crates/ui/src/settings/composer.rs b/crates/ui/src/settings/composer.rs
index 66e6fd85ec..7a10356c4b 100644
--- a/crates/ui/src/settings/composer.rs
+++ b/crates/ui/src/settings/composer.rs
@@ -49,7 +49,11 @@ pub struct ComposerDefaults {
     /// Last model picked, per harness (restored on harness switch).
     pub model_by_harness: HashMap<HarnessId, RememberedModel>,
     /// Last reasoning level picked (global, like zeron's `reasoning` key).
+    /// The fallback for models with no level of their own yet.
     pub reasoning: Option<ReasoningLevel>,
+    /// Last reasoning level picked per harness and model id, so switching
+    /// back to a model (or its provider) restores the effort it was run at.
+    pub reasoning_by_model: HashMap<HarnessId, HashMap<String, ReasoningLevel>>,
     /// Last non-default model option picks (option id → choice id), per
     /// harness and model id. Model-scoped because each pick was validated
     /// against that model's catalog row, so it stays safe to send before the
@@ -143,6 +147,29 @@ impl ComposerDefaults {
             .or_default()
     }
 
+    /// The remembered reasoning level for one model, else the global one.
+    pub fn reasoning_for(&self, harness: HarnessId, model: Option<&str>) -> Option<ReasoningLevel> {
+        model
+            .and_then(|model| self.reasoning_by_model.get(&harness)?.get(model).copied())
+            .or(self.reasoning)
+    }
+
+    /// Remember a reasoning pick for one model (and as the global fallback).
+    pub fn remember_reasoning(
+        &mut self,
+        harness: HarnessId,
+        model: Option<&str>,
+        level: ReasoningLevel,
+    ) {
+        self.reasoning = Some(level);
+        if let Some(model) = model {
+            self.reasoning_by_model
+                .entry(harness)
+                .or_default()
+                .insert(model.to_string(), level);
+        }
+    }
+
     /// The cached display label for a model id, if ever seen.
     pub fn label_for(&self, id: &str) -> Option<&str> {
         self.model_labels.get(id).map(String::as_str)
diff --git a/crates/ui/src/settings/shortcuts.rs b/crates/ui/src/settings/shortcuts.rs
index e64a47a486..a461748d1d 100644
--- a/crates/ui/src/settings/shortcuts.rs
+++ b/crates/ui/src/settings/shortcuts.rs
@@ -594,6 +594,45 @@ impl Render for ShortcutsPage {
                         cx.notify();
                     })),
             );
+        let compact_model_picker = crate::settings::compact_model_picker(cx);
+        let compact_model_picker_row = widgets::card_row(&theme, false)
+            .child(
+                div()
+                    .flex_1()
+                    .min_w_0()
+                    .child(widgets::row_title(&theme, "Compact model picker"))
+                    .child(widgets::meta_line(
+                        &theme,
+                        vec![
+                            div()
+                                .child("Adjust effort with a slider, then open the model list when needed.")
+                                .into_any_element(),
+                        ],
+                    )),
+            )
+            .child(
+                widgets::toggle_switch(&theme, compact_model_picker, "compact-model-picker")
+                    .id("compact-model-picker-toggle")
+                    .tab_index(0)
+                    .role(gpui::Role::Switch)
+                    .aria_label("Compact model picker")
+                    .aria_toggled(if compact_model_picker {
+                        gpui::Toggled::True
+                    } else {
+                        gpui::Toggled::False
+                    })
+                    .focus_visible(|s| s.border_2().border_color(theme.accent))
+                    .cursor_pointer()
+                    .on_click(cx.listener(move |_, _, _, cx| {
+                        crate::settings::update(
+                            crate::settings::SavePolicy::Debounced,
+                            cx,
+                            |settings| settings.compact_model_picker = !compact_model_picker,
+                        );
+                        cx.refresh_windows();
+                        cx.notify();
+                    })),
+            );
         let escape_behavior_row = widgets::card_row(&theme, false)
             .child(
                 div()
@@ -655,6 +694,7 @@ impl Render for ShortcutsPage {
                                         widgets::section_card(&theme)
                                             .child(send_behavior_row)
                                             .child(compact_mode_row)
+                                            .child(compact_model_picker_row)
                                             .child(escape_behavior_row),
                                     )
                                     .child(self.thread_naming.clone()),
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index 45f1e046ce..b788e66744 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -2763,14 +2763,18 @@ impl Shell {
             if state.read(cx).selected_chat.is_none() {
                 // A set sidebar filter is an explicit standing choice — the
                 // canvas defaults (project AND its device) follow it, even
-                // over a remembered "no project" opt-out. Otherwise the last
-                // selected project stands, unless opted out.
+                // over a remembered "no project" opt-out. Otherwise the canvas's
+                // own last pick stands (`last_space_id` also follows opened
+                // chats, so it is only the fallback), unless opted out.
                 let exists = |id: &String| state.read(cx).space_row(id).is_some();
                 let filter = self.settings.space_filter.clone().filter(&exists);
                 let target = match filter {
                     Some(filter) => Some(filter),
                     None if !state.read(cx).no_project => {
-                        self.settings.last_space_id.clone().filter(&exists)
+                        crate::settings::composer::ComposerDefaults::load(&self.data_dir)
+                            .project
+                            .filter(&exists)
+                            .or_else(|| self.settings.last_space_id.clone().filter(&exists))
                     }
                     None => None,
                 };
@@ -4487,6 +4491,7 @@ impl Shell {
         self.settings.skills_in_slash_menu = current.skills_in_slash_menu;
         self.settings.reduce_motion = current.reduce_motion;
         self.settings.pause_animations_in_background = current.pause_animations_in_background;
+        self.settings.compact_model_picker = current.compact_model_picker;
     }
 
     fn retry_engine(&mut self, cx: &mut Context<Self>) {
@@ -14999,6 +15004,86 @@ mod exit_regressions {
             .unwrap();
     }
 
+    #[gpui::test]
+    fn new_session_reopens_where_it_was_left_after_visiting_a_chat(cx: &mut TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            crate::history::init(
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                cx,
+            );
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let window = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Shell::new(
+                state,
+                EngineBootConfig {
+                    data_dir: dir.path().into(),
+                    ipc_port: 0,
+                    edge_url: "http://127.0.0.1:1".into(),
+                    edge_token: None,
+                    org_id: None,
+                    workos_client_id: None,
+                    default_harness: zeron_proto::HarnessId::Mock,
+                },
+                cx,
+            )
+        });
+        let space = |id: &str, device: &str| zeron_proto::Space {
+            id: id.into(),
+            device_id: device.into(),
+            path: format!("/{id}"),
+            name: None,
+            git_detected: false,
+            git_checked_at: None,
+            checkout_id: None,
+            created_at: Utc::now(),
+        };
+        window
+            .update(cx, |shell, _, cx| {
+                shell.state.update(cx, |state, cx| {
+                    state.apply_spaces(vec![space("mine", "local"), space("other", "remote")]);
+                    state.apply_chats(vec![zeron_proto::Chat {
+                        id: "elsewhere".into(),
+                        device_id: "remote".into(),
+                        title: None,
+                        archived: false,
+                        cwd: None,
+                        branch: None,
+                        checkout_id: None,
+                        source_context: None,
+                        config: None,
+                        last_message_preview: None,
+                        last_message_at: None,
+                        created_at: Utc::now(),
+                        harness_session_id: None,
+                        harness_session_cwd: None,
+                        parent_chat_id: None,
+                        space_id: Some("other".into()),
+                        last_seen_at: None,
+                        room_gen: None,
+                    }]);
+                    state.select_space(Some("mine".into()), cx);
+                });
+                shell.settings.space_filter = None;
+                shell.open_chat("elsewhere".into(), cx);
+                assert_eq!(shell.state.read(cx).selected_space.as_deref(), Some("other"));
+                shell.open_new_session(cx);
+                let state = shell.state.read(cx);
+                assert!(state.selected_chat.is_none());
+                assert_eq!(state.selected_space.as_deref(), Some("mine"));
+                assert_eq!(state.effective_device_id().as_deref(), Some("local"));
+            })
+            .unwrap();
+    }
+
     #[cfg(any(target_os = "macos", target_os = "linux"))]
     #[gpui::test]
     fn transcript_links_open_new_tabs_and_reject_stale_sessions(cx: &mut TestAppContext) {
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index 8aa5e6a2a5..88e07be64d 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -213,8 +213,8 @@ impl Shell {
     }
 
     /// `+` in the titlebar: open the new-session canvas. A set sidebar filter
-    /// re-homes the canvas onto that project; under "All" the current pick
-    /// (the last selected project, restored from composer defaults) stands.
+    /// re-homes the canvas onto that project; under "All" the canvas reopens
+    /// on the project/device it was left at (see `AppState::canvas_target`).
     ///
     /// A new chat always starts with the terminal hidden: when the drawer is
     /// open it just hides (detach, not close — the source chat's tabs and
@@ -246,17 +246,20 @@ impl Shell {
         };
         let defaults = crate::settings::composer::ComposerDefaults::load(&self.data_dir);
         self.state.update(cx, |s, cx| {
+            // Leaving a chat puts the canvas's own target back; the filter
+            // (an explicit standing choice) then applies on top of it.
+            let restores = s.canvas_target.is_some();
+            s.select_chat(None, cx);
             if target.is_some() {
                 s.select_space(target, cx);
-            } else if defaults.no_project {
-                // Opening an existing project session (including boot's last
-                // session) must not erase the saved new-session opt-out.
+            } else if !restores && defaults.no_project {
+                // No canvas target was set aside (e.g. after a runtime swap):
+                // fall back to the saved new-session opt-out.
                 s.select_space(None, cx);
                 if let Some(device) = defaults.device {
                     s.select_device(device, cx);
                 }
             }
-            s.select_chat(None, cx);
         });
         // The canvas never restores a drawer: a previously opened canvas
         // terminal must not pop open on a fresh new chat.
diff --git a/crates/ui/src/state.rs b/crates/ui/src/state.rs
index a8618b4017..cd485d7336 100644
--- a/crates/ui/src/state.rs
+++ b/crates/ui/src/state.rs
@@ -661,6 +661,14 @@ pub fn canvas_panel_key(space_id: Option<&str>) -> String {
     format!("{CANVAS_PANEL_PREFIX}{}", space_id.unwrap_or(""))
 }
 
+/// The new-session canvas's project/device pick, see [`AppState::canvas_target`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CanvasTarget {
+    space: Option<String>,
+    no_project: bool,
+    device: Option<String>,
+}
+
 /// Root application state. Reducer methods (`apply_*`, [`Self::session_for`], …)
 /// are plain `&mut self` functions so tests construct the struct directly; gpui
 /// glue ([`Self::bootstrap`], [`Self::select_chat`]) layers subscriptions on top.
@@ -712,6 +720,10 @@ pub struct AppState {
     /// device whose projects the project picker lists. `None` falls back to
     /// the local device.
     pub selected_device: Option<String>,
+    /// The new-session canvas's own target, set aside while a chat is open
+    /// (a chat implies ITS project/device) and put back on return, so the
+    /// canvas always reopens where the user left it.
+    pub(crate) canvas_target: Option<CanvasTarget>,
     pub selected_chat: Option<String>,
     /// Boot auto-select happened (or a manual selection superseded it).
     pub auto_selected: bool,
@@ -829,6 +841,7 @@ impl AppState {
             selected_space: None,
             no_project: false,
             selected_device: None,
+            canvas_target: None,
             selected_chat: None,
             transcript: Vec::new(),
             queue: Vec::new(),
@@ -1056,6 +1069,7 @@ impl AppState {
             self.transcript_baselines.remove(selected);
             self.prepared_transcripts.remove(selected);
             self.selected_chat = None;
+            self.restore_canvas_target();
             self.transcript.clear();
             self.context_usage = None;
             self.transcript_revision = self.transcript_revision.wrapping_add(1);
@@ -1792,6 +1806,34 @@ impl AppState {
         }
     }
 
+    fn current_canvas_target(&self) -> CanvasTarget {
+        CanvasTarget {
+            space: self.selected_space.clone(),
+            no_project: self.no_project,
+            device: self.selected_device.clone(),
+        }
+    }
+
+    /// Put back the canvas target set aside when a chat opened. A project
+    /// deleted meanwhile heals the way [`Self::apply_spaces`] would.
+    fn restore_canvas_target(&mut self) {
+        let Some(target) = self.canvas_target.take() else {
+            return;
+        };
+        self.selected_device = target.device;
+        self.no_project = target.no_project;
+        self.selected_space = target.space;
+        if self.spaces_synced
+            && !self.no_project
+            && self
+                .selected_space
+                .as_ref()
+                .is_none_or(|id| !self.spaces.iter().any(|s| &s.id == id))
+        {
+            self.selected_space = self.first_space_on_picked_device();
+        }
+    }
+
     pub fn selected_space_row(&self) -> Option<&Space> {
         if self.no_project {
             return None;
@@ -2014,6 +2056,7 @@ impl AppState {
         self.selected_space = None;
         self.no_project = false;
         self.selected_device = None;
+        self.canvas_target = None;
         self.selected_chat = None;
         self.auto_selected = false;
         self.chats_synced = false;
@@ -2364,6 +2407,11 @@ impl AppState {
             }
             return;
         }
+        match (&self.selected_chat, &chat_id) {
+            (None, Some(_)) => self.canvas_target = Some(self.current_canvas_target()),
+            (Some(_), None) => self.restore_canvas_target(),
+            _ => {}
+        }
         // Take the destination before trimming: switching to the oldest warm
         // transcript must not evict the very entry we are about to display.
         let cached = self
@@ -2454,7 +2502,7 @@ impl AppState {
         self.queue_task = None;
         if let Some(id) = chat_id.as_deref() {
             // A chat implies its project (or the lack of one); `select_chat(None)`
-            // (the new-session canvas) keeps the current project pick.
+            // (the new-session canvas) restores the pick set aside above.
             if let Some(chat) = self.chats.iter().find(|c| c.id == id) {
                 match chat.space_id.clone() {
                     Some(space_id) => {
@@ -4494,6 +4542,46 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    fn canvas_reopens_on_its_own_target_after_visiting_chats(cx: &mut gpui::TestAppContext) {
+        let state = cx.new(|_| AppState::new());
+        state.update(cx, |state, cx| {
+            state.apply_spaces(vec![
+                space("s1", "dev", "/a", 1),
+                space("s2", "remote", "/b", 2),
+            ]);
+            let mut remote = chat("remote-chat", 1, None);
+            remote.device_id = "remote".into();
+            remote.space_id = Some("s2".into());
+            let mut loose = chat("loose-chat", 2, None);
+            loose.device_id = "remote".into();
+            state.apply_chats(vec![remote, loose.clone()]);
+            state.select_space(Some("s1".into()), cx);
+
+            // Chats imply their own target while open…
+            state.select_chat(Some("remote-chat".into()), cx);
+            assert_eq!(state.selected_space.as_deref(), Some("s2"));
+            state.select_chat(Some("loose-chat".into()), cx);
+            assert!(state.no_project);
+            // …and the canvas returns to where it was left.
+            state.select_chat(None, cx);
+            assert!(!state.no_project);
+            assert_eq!(state.selected_space.as_deref(), Some("s1"));
+            assert_eq!(state.effective_device_id().as_deref(), Some("dev"));
+
+            // A projectless canvas survives a project chat, and a chat deleted
+            // elsewhere lands back on it too.
+            state.select_space(None, cx);
+            state.select_device("remote".into(), cx);
+            state.select_chat(Some("remote-chat".into()), cx);
+            state.apply_chats(vec![loose]);
+            assert!(state.selected_chat.is_none());
+            assert!(state.no_project);
+            assert!(state.selected_space.is_none());
+            assert_eq!(state.effective_device_id().as_deref(), Some("remote"));
+        });
+    }
+
     #[test]
     fn chats_in_space_filters_and_orders() {
         let mut state = AppState::new();
diff --git a/docs/screenshots/compact-picker/README.md b/docs/screenshots/compact-picker/README.md
new file mode 100644
index 0000000000..d1f58607a9
--- /dev/null
+++ b/docs/screenshots/compact-picker/README.md
@@ -0,0 +1,16 @@
+# Compact picker runtime evidence
+
+Captured from clean `codex/compact-picker` source `6ec139a2` (rebased on `main` `26e2b0dd`) on 2026-09-30. The fixture uses synthetic catalogs and temporary settings (default Zeron accent), with no real conversation or IPC server.
+
+Build and run: `cargo run -p zeron-ui --features compact-picker-fixture --example compact-picker-fixture -- <output>`.
+Executable: `target/debug/examples/compact-picker-fixture`; SHA256 `e5d97ac0f1ae1cb9a5b3afe047398435acc2c39460e599dad2c6745f5face7f5`. Exited successfully with the fixture PASS marker.
+
+All keyboard assertions passed for effort selection, fast tier and favorite identity across dark/light and 840/360 logical widths, height 560. The included captures were visually inspected: both header buttons sit one card inset from the card's top and sides, the title, rail and option labels share one leading edge, fast mode shows an accent glyph on a neutral plate, the slider thumb is a plain glass handle, and fills use the theme's accent fill token. Static screenshots do not establish animation performance or live provider compatibility.
+
+`switch-states.png` is not produced by the committed fixture: it was captured from the same source with a local, uncommitted fixture patch that adds one on and one off `toggle_switch`, then cropped (dark above, light below). Measured mark contrast against the surface beneath: dark 3.13 (bar) / 2.95 (oval), light 3.02 / 3.23.
+
+- `compact-panel-dark-wide.png`: SHA256 `9aa1d38d637a3c1fd70b7a616b1d945c30cecc6741913af15c4056940cc590f5`
+- `compact-panel-light-wide.png`: SHA256 `e74b07d800de2cf5234d13b3c9d0d283cab2abff68bddfe22b06952ce4dda3f2`
+- `compact-fast-keyboard.png`: SHA256 `313331b7f545e9b11fd610796b7b72adada1b4b43cf7662c778ad73764c71073`
+- `compact-model-list-light-narrow.png`: SHA256 `3ae45a842492448d02177b4a0a9d5d3a38ff5c1e56d2debd5f74fca8ebb63d31`
+- `switch-states.png`: SHA256 `4f5021ea3be5f8cdc297fe7f1e6774f113654da8e71cf8e12a5b8434dcd012ce`
diff --git a/docs/screenshots/compact-picker/compact-fast-keyboard.png b/docs/screenshots/compact-picker/compact-fast-keyboard.png
new file mode 100644
index 0000000000000000000000000000000000000000..3aa0b443a2af57cab2ec354905ce191b552b17cb
GIT binary patch
literal 134697
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%0AYIQ0m08D;{|MSHY(MVmy6
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%0A#&1`G_NyGo>bN&_m!k-`gAw%woM>o(W
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
VrrXp?_`f+bUw`GBmzQn*e*jk60=obJ

literal 0
HcmV?d00001

diff --git a/docs/screenshots/compact-picker/compact-model-list-light-narrow.png b/docs/screenshots/compact-picker/compact-model-list-light-narrow.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f682a78a8e0e85c5e71cf868ba6e0420bc940ef
GIT binary patch
literal 115039
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
bhupuPe&M$puN6r6wKVvZ#b^HX#`gaL1wm4!

literal 0
HcmV?d00001

diff --git a/docs/screenshots/compact-picker/compact-panel-dark-wide.png b/docs/screenshots/compact-picker/compact-panel-dark-wide.png
new file mode 100644
index 0000000000000000000000000000000000000000..c2a2f0c9534b482fda8ef6a25f9d28d51731286d
GIT binary patch
literal 115534
zcmeFaeO!!r|2BTkG-al(H8YLXnq6k5(ZgD#GOVYjG18=>?5^tyHAJLoJuX?)ltCe;
z2M-C63g5j`NnsZiHmuUFY)Y*nvX(7rDSDXS@i~)yxY+Cd{dd3adtTSYQqB4BIp6Q&
zeH_R8{W-->^O<aEKERx!C`*-x(vPCd^c2NXv(508reXbBD8_|;Dy7?};f&vkOb$r@
zy|bjnu&OEUa_Qk^Q-Y3#)fBw?f5_JTJ3X`aJ2^|5UaUO1=&Q_4V?%$+{$lasl&_C{
z^Xvco({IuB|M+cucz>MnN8YrG#&vmf<QUh*xGt|j#~2L8U@!*5KNVnOg?&?TrN3qb
z4<mRO!NUk1|EXY%$Y4YUBQh9~!H5h-qV#4YG_H$rU0zoRV=x$l!59oiC;va`f)N>v
z$Y4YUBQh9~fkr|j92()!2!}>EG{T_~4*vlOjb-8=7RT6|c=O^I*TuLluepUW7>vPS
z3<hHZ?>~vA5gClgU_=HZG8mD;sIuOSgvNC-uFLBRVGIUiFc^cu=ve<JT`(ep5gClg
zU_=HZGSEn9ghL}78sX3ghekLw!r?z4p|MQ-!{Qiw6K`G|<GL8v<u$i327@sejKN@R
z;Qc4jG$Ml$8H~taL<S==7**Drk<hp<#&vmJA&kLb3<hH`7#-{Xqzgu5Fd~By8H~ta
zL<SlOjc{m$!~gr?@OuN5A$WQ2@S`!F4oQCY8KT(NPD)*gENi5H=!r_}OYw887iKN}
z>9ZNLzx<EihO>4UY<b0VbJenxAKS*i{*lO!RX6;P=0BBRaLftF{`at5^K4&#?=J^>
zHtUDy&kJ4*|I~BN^5uzfah6RBQl5QPHhSCE29MCV$^iwZdl9KSOzP`-FiCOq%N4UP
zX=D@mZDYrbx%=dazH-1@4(+vY&6=9d{?)f`%?%CR(vkJ~keyctfBn<u*Ed;MvUb9P
z+<!TymY=RGE@t%U(`VLy-Xad(Pg`*EWLf0#V~?tC-_C4aL*Y1^Hf`G4aJlzhp4A<C
zG)6XR)W1J|kFvN>)ZIOyVf3>9SS@m$hEV#d?EF7|?}M=`EwoENsIIG9a5i9h?@xD?
zJEoM8^E?_u4V(SV#bu}Oy)hRJC+U@&di?b1E6<<HsL7Kj&-!M?A5SncGw9N`+}vCS
zxf)#U8*lBIfxp8bO-V`7EM9DqQ&?DzWq7@shFQCY%}&cN!O?4KYN!te4t&ckjb#})
z?`<(9KSVBJ{d$wvAZmE=?z``vTJexi;kzHd_s;8YynYC{xtEcf>RtbJ^GkX`y1LeF
z+qUi0>&M<Udd!%)k&%P6xSb!r{P6YF^)5YmVqJxb`>s{5R^fvWK3MW<F%379{9@RW
z=omTQU{!7Fe8tNtv2wuh|G^b{I%qVSoU>=kHoVjS^~wHnbq33i3{eFI1;2FcU;4pm
z+`_9<KZ{gl?eHJMD>j%V*k?@hWQd%TGh;*cg!_`4KlTVepOrO~+;;Ch{PnP=(FRe5
z00*Y3>gpc6dbZu!G3?;H_t(`~@j4gx<Ndy_TqCoQg!?{jZZ^ru&!6P5;m-^98k)KT
zMeThN0i2>`r|10<M27xJe!I&bB>A-$rX`(UJK=EB`9gd<Z`LqIRc-BC;;BEo+eFC{
z3Wa}u()5waf;$68rj*%dJQ@DUxN$6XP|*6AH~$MJhE^N|kD2=X>wbS^fT3m*E3bO1
z;SuhTSNx9iHk+@1GS_}LxA@P`@HM&^9`HK*>@EwYKHfE@cjXMx#~!sC(jJZJ9(?sa
zUt6sydFw~V?(qAiV_?ny`g}<5ha<oBACe*HF2utMy}#k#S)W%ShdmwMoDh)%iVLUL
zwNd};W@zu{4blEX40SjBU+lscsh8(^pIPtsdmf>og5ACEn`0*G4<`41Bl256bA-t#
zo}0sl{=pwiroK7W@a9}5pY?R0{y>zj#r=7mk^OjQ92-V6r+MCa%g2s%;&!P&;F+wn
zA#f6FxL2s9*3bOS$&%`RzwT%fQyv=kDyCl64U@DRK9Ypb@eiev{N56`E*}|u5~!TA
zS1aGO*e=$PEp0hpWhU=UjlZI2SE_q&BEIoL$P+LBfAdG~N5-FPUR~I>CUW2}lOunh
zJUX&_-0;i7!j_aL`c30>9bHx1yX+ra+h<b0-nD&V_>LK?KWl31AKCI??Qb_DEDgQ`
zpXY39-MF}YW9{Nqt9A`~d2rC1lls*I{^r+6$BztKN`svzG&M}v-{)mk-AnIlsjlU%
zdH>Qpc@}7}9QQ+W=e6b~O|_p;17BR8+_EV9`J&q9`g*OwV|&E!hhCi8-Vxr^cH;2(
zxc|+QZBo54zy64jXW0|)8*+dCdCPzMxetzXx<20!*lxP^ry1)8x20tMQRCj66%WV<
zUS=C!o_T!r+y`wPR|`9*M7-D)8T;V*N7+w5I#V(BtaIOWzf7#I{-ngU^MdP>O_A*#
zosEmTZNUK6KIs$5o_&+?<er^t?4XX^K@FxL5O;sO-Spe)>Rs#p9nkq*VDzCwHv8Kz
z+C3Rk_;g6;t?aIk-WuQZHw<OuivB12<)Sl>zC9;woB8p3oll1w_<es5NqzqCOnJwd
z;eA(Bc#mpvU;MlK+8dMCS-7@XxnAqDwy4jt!n)3~x_g%*9$yNNXl(tY?%C|Rva4rG
zuRfJ;UtJm${^(?c@SLHeaC>?8<MO+2T#wf=P{=F(Z1@jr&RkmabV76MxiccWsr&DB
z)fr5}eScnZ!4d~O^YQS@-xhYPdGb|u+sl7`E?uM2o)*?l9Q4vrVqRW8cf^CbUq1_c
z_SuWyry4Bw*9<bW3|d+~zU>Ka)4Ue<=5aSLG%_-^u;bgphMhCNxRaUk#oee0Sp4X^
z_PD?|BkCU)&e>tOf9`o`;WmRsbJy+Wi4Ge&=GzYH`f<>A!@KVer*i)Far@@%cF)^S
zEbC$-;|jZK3h$e^KI!^oRnrHkJBtm^o9}%VaR0MYb%zFZEtEu;{+DDaWE6i^eyH;M
z&@&~WPvwQbPbs`i&a<TO{<15FBYr)+EIj;jVabAZl?&*EseClD?sxCHB9kv?UwU>k
zu>6gs>2-ueT19`o|5CE^f?vMb*5_q)YS+K_*EBUvifCIExvBq8%T`~k>-xE_MLzYb
z>xtoCpc?<T$8Zpjp}ecMd}+&F)BUObLz-V6Yc46QJUabw_!p~w{<430`Rr9cf4Ak=
z+iRK|PXE@_^kxp%d(F>W*<`Kn&pa1vH|`E+oGY$?4qAi%)%yt#Rz9v8u|L(y&gV(m
z_g?!`!g?#+>3w6q+}!%0{56YxUCnzEz><CJtATAluNqYTTfcxi{ldTC6_X(Dy%s}!
zK=ZSJ)a@Oorq<_fUpJ!nuz!nZ`nd!lj1IeYJskJLnzJ|8EN?7*f8Z}4-oEqU>dO-c
zp6{(qlUKL&kK~Yp4${7bs(jro<j#7ww(D_uw?*F-o$X5_p4vt3IT`Wj<eeP>4|lw{
zIJHxXG?|dvTO_wH>w0#x^*N%cwz=~~>sy{nq{&A!#s}6t9a>lV^|@caZZXe(VqV+)
z@=^8!z|fH1(rQ=;I*dd-W4F$=A>u)K>YI7Nt828pP}C>#NuQ@T4o}$7zj52xFM9K(
zd%PriRm6i;ciLO5IsxPTlCKmOPq^Utma=Ogk0FYPiZv)bEqSgTd0rJ4O~&7MnA+It
zYG`ebt82F$XrI?B_6!3ScU3OFFmd41X-#KZ-^Ga{Qex`=;ohxKWWbTYeXDNWVjjpZ
z0l8l7JKwhd@PPUVl(UAYYx~At>I!)FS>TR7uI=K-j~_2-KHK(WWMJ!0omg3!ozDjk
zVyCW^U`6`W+eO?x9DZQt;<GzC_KjV&t<RXq?hnd`I-d@2k=Xg{rEvJBreQsK)n$0%
znf<%xna-<)%szcO);70A^t~AvIi6ZjzW@H;qUhCMyHlpU2%Kka7Vt77FroiXKmN$;
z8`(Z_wHv{ijoDqdvhTcD{q4y$Yi|FVb$d^rF@O@Rkn5#I`F95g+#MX=aWb+`z^@qr
zoBMoK+t3}=(RC%Ya|C^aIhs~H^kqHq@yt*TjGT7+?$FztL-w?HHyb8AZ)+pbxs)OW
zxHs?qsEg!JU84>z`>FNWzPcCt&ipj<?8v^qPYV3~yS3d9B8f<aOxpTjW!<{A7V;Q-
z<FN4F#aJskRe8lzyKYQfQWJKPvE<hq4wTQnG2dN1_xNf{=eUOVPcG~3T>X~(a^>v!
zdVh9g`=-JNTMFB^wBMWBEf{zt>3nX`rSLB*Tw3l7>OMH@OnCgOjQDB}xbXP8*0WVr
zRrlH=4Xa+@Q|~m5N*zvxquiPXbl(q*dhnp!&{^J&)#3cZSpyCrtrj=zU(<Bw!i2{c
zR$sIkSlk+v64;R+c>mG4rqI=$4TE~us%y&amJjP<L$l9rvvYl+B9+vs@9#4UpQY>_
zzh<ZZkiNgy_i^35Y5e0m78mxozC7gmma^Dw<$L<q4KH7$8a|1@%5K{g@o?82x4vI-
zN#Hzswx@Eys@kPv2@aob*jCf)L-had(b?ONTB|OdvnH{%DdLw+m%Rr5f}{X{>Xh|e
z0YD097#U!qB{lFt)3?q4boxn8Z$@^_pi}o%fq1s~+1=sY{4=*7ot<zYr?I2Zu;$-c
zJ3FT|wwg9~H#Mv3%1M@f*^Nlr_PRj+CBk1$b$=c5FQ=~R1ube^)6(q?jVX)okY7>z
zTei;p1gx`d3;Xu{*|#@1FSz!k{gUgpe<;V@?@a4mg|E9S&ffa^?3i_~CiNMCFXx9p
z+!gWu{+d8M@h1(g-9fd@xX3v27_XddyM1+g=jFa{D-Dy5^hWS!hKE4kh{U`F<$j^}
zPtT6*dN%HP?(mWye-yW^0r&bOpzEi=#6yQBo@-lEm@>z@7fk=Q3<k-kuOrQ{0!RYb
zdT?@eM8JbD19n}S@ccVMwy9BdYu_R0<{kVL6x-xaVf|WM_Z;QraOG<_?K(MTd7}k|
zV=h>;CZ#QWd)tA^ZK)lnQ}2XKUGp{@Dsb!fy;=UO?$;Yfr&Hu)ZEMThU`wSCP-&Rj
zeQ)a9?#7H|n5<+a^nTkAM$*~En+}jsx5KTbM!u|Qf0)|s@cO3zx*mlfPZ^#LgbRN>
z-0(EJ=wZd-PgXv*MugWaF5E|c9UlMN(Q(}^+aH|X_sQ~&qr%sZy7wZt?Dp+}WbrCz
zF20YvY>Y?<-?eJ>jPCsIU$%GaNd-Q0geF`Sho`m<Uwz(ce-Zuo7k_zm=*cI)W_J&u
z=Gg*83X5={S15gRPkDdXF3cy_hj%$WZVI>u=8g3Ehb!N3>~!OR+lDSz?exPwE%MeE
zdnb>(%ftV-*MAw<_T`JSbsgg)8W%(isHt5HlW*6W)4Li1=UxajJPUkE>f7VreiO&`
ze0556&qW8c^b3q96lVD87mX<|P?q269tvvR+%mBF%9TXB({;}KTP*0i>{-d~P{M9H
zEHCV7?l{*>_{U#YxHtP=E>=D%EdBE4>`Rl^UYxuP(AzyYyJbLj@tSiF*6?_pp{gfN
z!&{G^!BGamj~Jq4UE20xgKN#$a}8scKE0>vwo%<hZo0ox(`SDnPr56j^HSvAZ=26;
zdD}_d??>`fXBx(yvjSJEZB|YFieLEh>%#N<R^3+BwT-(c?t8xsBI1*EFI}kNFA|1d
zAtZQU+o?+}wV5Gz39&d;w|2sV-yb@kxjW>XWaiA7RPEZ<vNMgL=iVb!`n$G>=C&ub
zx9@r1P6A3$PwXO}+Kp?8omw9?ETH!Or2M?RiOMB~shw9+>+9?F4`61tEN-Ed){QA=
z1%@9z9mX||*na=smFbW&og;f<;p{>uD=iH+&4%vg-st|@JsKECI)^{SqB)KG#jWq%
zh?BR!8dCQ>tj;r->1bgR3Ceu+=T&vz*{!>7XT_t=eE;>CkG8L=Z3zD&`3jLuPikpA
z*$y?`fZ|Av`~6_w`(SvZUZfPh5bm!DJzE*Nyl`yOsr7~U%ALAj@k6!cvPi7BS7@BU
z{^sme;}<{sd~sRiM$~SE({zZ4fE^buOx*u8$?g@P6+R|6(0+V)2Y*<=nb(f+-wJwP
zw<m>{rxgBvbx9%Y?Y`ahef7!XPA-3Nt>r;v_k!ByAGb%ij2%1n%n^8><V?;@G;jyr
zA(zyAJ!8s=%J%Ko+r~G)*x#(W`6V%#Gp6in-@c;d?xb#L-OZP<#<L>3EML)%G{TZz
zm6X3;%50kA50*qvp77MSws|`Oy~lkZ;IIUm?Klkk?3*}2;YMlGuH?=cqa!+5Z8h*J
zE$g1dg;!k|SVCgl#e3XuAyXTUPF-gnX=sZi&N28RS*`q=0axj;-8v)k+0FW@+@M)=
zx@~IlA&q9-{#~n+cLnGBFT;huCGUIk$?zGTeeT(_-ZwvMS_SFQdVbb7C$7S!Slqfe
z7oPW!b9aX<Ekt6Z7|cNj>mz{Z&g56$-|;Mt(|DKNIwt$lsECG}%O74J93U9}%x`!Z
z(d^3$UArn=?+{TJ{%l61Ww-M<aNuBcAZCPbm_fJ<ah=~%xO=YpW#Ibn4SYPZaX*j>
zXY!$I#NJ28zTMyd-uvaJc0eeaz=b2{>uPL$f5ElAclrgk>>%cA#MIT_PjAm&a`z%<
zf9lc?9)7c}W8Z{zn@LFA5uUsA=#$Z->o<I|`l+<JeOvS8uBOuu1`=hGV9-Q@b6&vZ
ze@(dV_cYx|zS3J-{`QdRzdkEu?l25qlr`=LG!dc(cKtHB_1)$t+s=pxJYK3u?OrkP
zNagngot~bjA0{rM?ZwHjP=rH$QYTz^XBn0a&O?MiOYl-&*gCfG!l3RugNW?)**m&;
z=GmWSw(y6yBv7-KmyJAAd-d!%@-t=c_<7zLf4gCPa`^)isRTeAx7ip*mj3hAzKg4c
zb_hQJZnqJ+@icX?^9zy;5#Y;FrT6N7E$$n^CeL{I<?6fzr|U@OwdQOZZ=wCR>6=8_
zDT#pAxJP*LizC}#F8tz~hqe?k%UZ@3w$_{xEq-dd`1_$JYtMH@+_j6?yQcZ<E`vD%
z#qXX!f42}m%H-f)P5Q><>B@Gy9~p}l#lT<ogdV$3*5Xv%hpTFfvpc^ZzP#|*qwt?^
zt{We)yYwDmy{A$w*R0t!dR5c7^6-)@!cHTze_Hh2J9++Dr|O7(@f6<QrZb}CE2&-8
zsY~GiF=+d*KQMbWn`n>=T~G_3eEF*jjG@J)UE4k!ThcYKqpE+<f(O=!qr}y}PEY;5
z@Dd&h`-?Lz?sU<DIrYDhSh$4da~-D|_k>d6M2*nmu9Q{3ZEO?$D`NZFdp4_k?gro&
zKj;Oo+j(7i+uBj6!Tsmu`!l$_4-oTk@libRDfQWa*4mA8%DT`AO2{c&J{I+cUw#}N
z7DTo1X*8(Z_WKa`AFm`jc1PsbkFpD+2x`Gl>->Z~wca}VHv&fg^=06u?+p@?0aqUt
zc0V$CLO4FS^Qd}Y%#83a@;?t~`!aC5frHi@jEcxBm6h+MJ`YK~)<uk!U8ygUQyWi@
z@4U0UK4Q(9HC2tSewi;$j#+w_h1xQ_tYMHLyy=@q!~S{Qc93FpDYA1iT^iTbF`k$$
zeqy#4(v;NOi!w?mOgVG)+cWQM55H*BUN>*?;_dJBAGQRQoeKEvr+_%x{CYSwazFti
z{QiuH`2kJ$1GaUH?|L}3PyNeBi|g|P9_62^qeG$Nx09`ezMOHS2}G=w9o1e_*fn#1
z_wR>W4@bVV>zsMRfAxkL;gcZDhyAG<y*a_UvM0fD-qL^gQ^3d7GvCcTV@mOgzdc*?
zZA;1G&XU@7Z9ne?#Q}Z|jJ>MSw+A-BJ<X<Lneud4TeWGOHFRg~%9^mf6V@T{PjBq-
zuDD1fo5_;S_7QM&0-`#`LtK)877)k^*iGbABVBbLs;1r}Wv2b)qO2C8F-XPzTc!W&
zUn56G8|FvgVQ&FLsH=}6M2INT<q$JAORGowbas{-J}{)v+HdNbTNU94&~ig!Tv}E(
z@+MtkPp+#uxfILT;<_R1i^8sznz!hWSIjiq{Yl{uq#it(UH5DsbaHw9i_=Ju_G8U2
zeFhrZFSVRUE3S1=2-sib_R0Z-g?vA}>-z9q|E%yYE;!OLy|}w^aihc3)lPJ^jC$VI
z_bt5U)!n`vrGO38Sa;`}N5@R+Ar%`7FMxm|-vy*E{{W(rRL!c!$UOfcho`1CLOh(P
z96fH_y=!BerOvO!m}_}SiJ2kw!w)}fIS&T#jH+E;KK`|)`ZJ6@i+m5}-mqDxir~w%
z7Y6UKC69{y`p3Zky89j88;|$rnv?f`^N*CzO)+G@ErO`mZOmsMCtoqlcw0?ouwFll
zym_{U!1-?(i7@>`W$#D*Gknzhp#O%CA8B9rV87Z~IRK{~m8^Q*)B78UGTE;m@dHP1
zD?=TOzc*vWc&k6|=Yz};^#2Y0vqnNG{O$Cw{<=T*kE<BiF#4(CyV2X;5-cX%*WW0&
zaR$fi3_KZ-edTTPkMXBV{yM+ptFw)U|9SS6_uKC9t6_hv?>jgAgYx}<^lvb1t{i}g
zkGGD9to>uH1CErUMLs<=qtX*H&NtY}+p5B)*9m?7<a*W&V=u1(YZCo~zMf(UCJmUX
z&Z+ZKN~M@I@DF``w}1Wg7VRH?K=yV2L-}v+WzXmuH0ibR@K-zikK_HH)jsX9oebid
z&Q<!iL>F$vu%ySI>F%3XW{?)Fj*z}(m1jVzyjo~Okfv2mi&s+pTjvgcK9_Wrh!a|^
zanIV}XI}84JUAs}&%d%he~canlv_(*!;`+GIX8f?hAm-Dc5m++8r<ojoUyaeFri2_
zq#s?^s^eu{#A}Q{x%TSGd%oMh5<p>hhE}`t3*uSYFlkHLaZ9Z<U^m7|_IKX1qbqhN
z+!6b>MBIMYR8p=?h@^V+b2R+>&1cQAEFuz$bef(L8Lj!^i)Do|2Of>V_ypQnWS9Yg
zHqSOe&yojAII0ts_8CiDYdn}mvII!qSgBK@pE>@M86t6he`8e09?Wq4v}h83REsMm
z95IGex<<G<4AQ!P=K3AlR(*@cx7A*FBPJLY9Q^IKu-4`!KYw|Xv4m)`!eqMjW7tRR
znR76Cb`y`~P^Gy%YX^q7WHK4LTQRWc-5pG8s?3UH8G?cK&av#KQQlTOHzlr?B3CWq
zXiKG%-I*L!k{`7@GuD4dTV9+Lvm>BzP}wC*rIMU7Vk|s4n)>o+E$I5JXOWwv-J`zk
ze)))T>cRdsZ!WNgk58OE8`k~dv2UBkP)+ALzUUs6TXyyA?<r4m`V>lT26k9)YpyMw
z8<B9XChhBYuG<PIYnviU=BM`ZNVk+xe(J4Z3MPxm2x<LT#&f$xu^DEZnktpOUU}6_
zt}K?dS*ZsWm1w2=zk^xBW>tw8T1JaTCfXXWqlDLEsYzM}!)z==uVZM^i+uE4W|6gc
zD{qE%j<>SjD;<B~R+Y%^RtuuSSfV>#(kPa!(Y!{-R8?J>&oAIHqr!&e#j>xvYo(eX
zAr5xB)LQ(QCFfJ3tvu$|(+d7IrFqdT+bBlM$JbbL^T#ZXxX3!k%7J^{T3ke>d)s^1
zsTHOy>+33eM|U=hsR<HEue<ZDw=%dC(}HjPSjnf%6p}C<Wpdt!(sR%INEytnVH7UJ
zY^*OUS*6s*Nv}7);7Rs*D5#h|u1{lT4vdf=jb&~5F1oDD8-s4SWnEH+K3N;XEx6*s
zSF#G?FPb1PsIWy!j&zPtMTSDMMtVA&sElD#PKg-6N{$Va@_6I)Vba`L!^k)lW`Jra
zJljqV>7FW;KlmR?Vrs*1%i0*K=hKMsQ>jw_P~v~4h7I)KQw6!+O0^Kd&x@kJj%%g#
z$sQ8tqxlKR_;H+#J^+cl4Sl}%qBJ(Ke&$rxNGU_qlPN#=n~-pn{^&oEpK#d=Lxp1J
z+_*4FbVqfGjKYA6w~|r|YdjSEw!E^g-b;5%gl*$!L1y64{KZ6FLVMjkboKhwlb*#J
zOQRu=9?)BL3d({y)zS3ri_~kf#qDDT6>V{C^gi|C<&4avfn#}04yB?-C&m<!rN73~
zv1InTu$*{ikfUgr)p=P0C9n4ymdIr;-N5j=rDP>rI&hf`Ge;6@&TdSh1GQe~93Q<x
zqLV&Wnh(5et(qrOm<H)irH)Y4PGzQC#a9tE6vK>VUE~oJwlz0#np)1Tp+v)wYC0U8
z+R9V#A4)%UG!r@?i1f-aJp2F^B#qDF`Gy}@!RI6F+N>VBE5*oQjg4-f2g90M!k)90
zyNi><5F;}<{3?5<g<4}{O0AshWuL={l4@*}V>qT1JI9T=UV1&2tJdelX-kznkMlAG
zvW=tBFBzb!ij|f+zrU4ZN*}F+z0?(7KQNzf{`lhVm}qW+o3_}RA)++v<$Ryz$)`$X
z%ye}}`(>NJwW&de%_x|*W5-_FUA};-6199R^AN>)*|=r$4sc~vW+DYOZx5THHnCP!
ziIyfyF<0s}-BT^3R7kyKm4m6aasZ+LF^s=w2sX~ChslPCGfm#flb2SlySb`mLFDrV
zN*4Mfs2rsv`x0{Eq?BfPVQG5O`7VtOhpNHNkS`)gL|7UUYn21?KhF$d9!O%cIrwss
z3=_5l#`H)JGm&$=F3i)RsxgA+7MzfbhZ!pcl6zI?1X@N6TVtY5p)r%j$0}qKqTRt1
zr%~`J{HSKS=fV7qxCC+<9GCuY@)ZQ*x8Hud*EMn=$Omx^|NoSn&Z%FPCHHBu&2IBO
z(|+jo=5sYAa^(-1=_4<jO`n1Xj&u{}@qAB}Hac;%mA0NoM<?2E2pM3XaRIq<D%DwK
zm+>jdPjxzl>a#E`Eork<V<Ms#47sV#iuYOc+rlsf-%rHRIN`G$`90N&(p|h^D=|+%
z#9h`X1=9HB+To}KJe5*_B4IQ8H^*{YP7M+}UMI~7skYCUD^$Uo#WEDlv(5OFddy;J
z_vxZ{S~^gamG5PZj!ELbX;*cOJw-mH47Ez2NN#gtPn=GbvUc}DBvL6Wm}yEq%A|-a
zDh`IvNPoPgbm&*3J_Mi=`iVqg(xt97^JI&DqjKWHoP<2nu_*R}c`}_`y<SR589(?>
zjE;$x=BQFiIY+rXs>(Lc*K-oTAU6&{A6vSSl;4l~CgDQVi9VFXyzQ#SgX9Be0YBr(
zfys|s6SBkEsFSeN98=2?5z;v+Bv2A^yhBx4rdls6F_n2#9LtUm@#JWN)`v++XozAf
z6a1o4Ef)@T7>vs&<rBbno&*?JdQvnw1F5Evhx0HK7P5zGKb_j~$vI4~Bz36B&63a~
zu}+>BxmrLV4TXd*P{|xEz7JewXa!YQy69L#t;3Uqv5}BtDOajf{LHgP_68wYB#NLs
z5EB_-MIgC&`Bkq)Syi@lMXxf`p(-fBI*@W;0Bwn2E7!mLu)?JWaix;z$^pD6GSxjt
zmcqlx>(rZHmOfZcu8PbU5EYAgNW-UeAHS`3dEY;1@1OqEmAZipXBS?8Q0`NNZa|sA
zC9m2Ht=QD^t7qE36`N9F(IHM13zz7>z+)KZY=6-u?#8V-!UfSJ7m<4`62VoOm7c*9
z&81P|ee55XDa^^mfnQlWT=t?Q(GPYeSDAS^?7-B~!6E>PJ0EEuhL}zALj_q{NV48B
zJu&70(o+*;M;$~_R`RHMGS8zYD)lTa*Bm7g?XZ<ht}p7#4+yv&OFtknt;LgXOGL01
zJp5*0&1fqr>Qt=8a*{}S)m<s#)KKg>b|P+-J39#LawsVp!Ga^P<Ey8!P}CM>(O{1!
zZ&8A;+2<oks%&T4cruD)EB!pblUZ{~r3@>Ik&81!SW1vFkGm1b%O!<~6x@QR;Ch^w
z6_1n^?n(*JTVhHotyD}NdjiE}x`kS0eCjB=tRa|>LuQaWoQ{u57KTYaUHA##7XhrX
z;vwaV-Fau)hs?Sw-ad<ok>&5;WW=)f&n%FJA&gB>eX#%{>17w5q=HhiRTN?omqr~Q
z>>J%Ne-E2Zf`o-bW4R=1_&gF%Ce@kw?pgg1K<@nHD=;k(+*0Qk7*QKL;i-))zXpfI
zF_3m7G<(>FCNY@;Y$q}u5w%)GCjIFGTqa690Uxyxb%;++joV!M0ZJM!pGgRZlmTi%
z5{qUS33?r&(2#XB0iiBqc>LHS@;jj?6geUu1~<z)$&V0mg6Dk&yeeB@kCGx}MiI>9
z;x-Bx_8C-8Zf<d7qb>9UZkr4afSO92U!*qvHx6N+SN%Be#VRsSgYKHv;Gk(W%kJtv
zWB4{=(8=2Nk38IjbIwLD)h*Q^@2ELK2RuHBIWCS+Jz$)*AWeC2{zQJVB~P?}aGKgq
zR0OmY$9AYtyNdKa<jJ7uvXI|GN=&dY(*eK&j1^D_aCVePlH>giLv80L&SP+Wxge*~
z`05z8yml&zl4Z(O&BClXb_wi$TphC}-O7Oy$Hs^d9OoO4Pt*HIdA>OeJ6sJZ3gBNF
zZG5!GQs99F7A>*eTx9K#!>|AuA;m5^E=Cc|H|OrEc4t#6^|YAMje>M5p`2nL#3CzM
ziu6PcO=yGU)Vu*eXo>kszcid99{f*&JY-N3DR%~27sGzc5>66va4j6rnNTY#fvezy
zxtRKi7)&ANtWRi??D5E1IHkEZOyPDlmfz2$;I!8?&%rY%n(O39!8pFDG~i+W^HUGS
zQ>05@{vHDF-90mwy*D#o$<G>Wj@v{OB$voQev@q_F<dAYRzb*gzE~37$B#{@K?W<?
zOn#TavR0wAA(+4;Iwr9YI4rFc3h7AxvK1>X5~YU;mq$;hyFQzaM|jx_+ZBj#%G!Yx
zBw&qbMriWrNJ7dEyey*%KsErm1Xc+&6OI5qg*k8ntpsyH5PGr*;TX$Cr!}TNiXck|
zI6A5xA;ScD=$d84^QyoVNtiYC50eL_rIC!J14W8%)<_AH{_*!O#h*Pp9u|87<Q*g-
z@nuJE18b7DxT1q1qu#cK2F~MrS;{(@;a$>R#tw}qu2EqV?yW1_G9z+B-@{)EPnbR0
z@&4q6Lm9wpn)QgCtb&kU4wMa8fC6x#rFP$9Lwxz*`QZz#8lEXI1S_ESJW5$Fkzv`Q
z!_w;`k~uNcM4TWhU7=J@)ahANOsTt)k|?OEOyyu_4kt+AhS_(eR!M_kn$`_sUJ1qI
zN7+j3eNoJ~LxoiS=TJm)zRZJ(SgvN9uH^f2^*&f454T2LSUN>P{!7gHKp%#-LMhNW
zy7T!SZuS(Y46A@+svyX3ZNlZTN95yDp!16CnPZRUGa)`=OWhs%rCgPm`)T7wlpq)N
zs6!C+HS{Ohas<vw8-aCV^}_0yBa{a-id&FtrP5*@EFLQP2jzTrri^E<p~Qe@s(`~0
zJ|-F)pL)o`ExFdH<zU!2?6B!9_SRyx5OsFOSNmokJH3<>L;7lv=afVT@Z$liBzk2g
zlCvm@PtrMo(kqcYPTpA?I#f(ig~xd_Ac8;kALv66GA$n`<S@2cW_i<PpWqBM6GER&
zHa-p8Ma-B{UmY5S#@bywN`DdB3APO3wKg2OWI|dwY@o?Ai9Zx7@C59aA*>pJ1Ts+E
zg=GMm(onqvr4`SVXf=Yr<oDX_d{7c%b)?aS7KDVZR&#_v5L*-_DScCP#8WEdr3$14
z$8`(#^K=7Z#{$W5c)+uWkas-bhSBJDV*?g8$e@eW-qHX9f-ZiHwA&6_u*?YJzBc;)
zEb_X`CGD=~Wutz6vT(v9t8VS3agT@Qlr2jB;6vN2sIX&>pzBzj(s_%B+d=88^>TBK
zmAR&38P3UPAIYC+zSlM_VJKsc33F_&WlX7=85iX|{XmjuX0CVeM4mRsJC-Sj-{7!;
z9S^wzA`O8Pw&${jn&*R{!1j*AfU7k1ew8SS3i1y{nTdyr2&v9NJcj_EAG36p(^HCO
z1p}nu3Re!OqDJ=+RB0MDE$zDhh21ff5?+QMm#58j<FDlNPH5)YQi>Cm(^%6}JnR7O
zpp#*m>1h&E-iD*zB3_15e*6%YnN$i`rL6dVjES+EEoB}Osi%XQOPP5En?y-H1&=R=
zph8A7YP5_wb`R6@&8!^()7QbNG%@z<94ki|9@UZj3qDYz6}7|jmL^jZhxRjB33tlx
zBZRkEk<L8Jo6Qg@iLEEwHQyFXSS+JJp&;2PQVFPpqQ?6H4U(I+IoRH0Iciq<+6i_Q
zSQfC+g;|JepfVDI=N1ajAwC%-q3=8)7&A>&0hLL7(f*7i>Od0FET>W{lK37H#fsT|
zv|$vuz==v!G=xptRWFS*wgx`G73z?I`S?*!Fe~3hqAGZ<kg9>%urN!^QPJXzLogWB
z0kH+f410w*3-p-*v0**Xdc})&CU8pPF>rZ30)(9LhJQRBG&CfhJyTC~p$gvz8Z&ar
zK!K7JN<Ek+IU67v<(R}T;3AnriZ+OM)<{ySvE?fhx(iC80D^}CH?%D{-FABonet1%
zlI*-7{Klbylj_>48vh*0uiFCX@=OcPt6tFB4Dx1LM8-L0Yg+GaU+sO{@N<NAUsg))
z`e&XN6Kw?PiKQ$Nm;`peG1a4Va%c;cLqF9CnOG;?8f#Bg#fAx(te6!NQ})Gv{25j7
z_T~sFVLI`EAPIC*YOgyFo&m*IQ!sn%Hw^I_<I5UsE=#gk1BcaiY&j5~Ul40Q&(=fB
zAZaa*^_q?n8m7xBn~$pHtz^XNPX#JPrs60aA=eH-UXs~kV(qJ_5+9c6vR6@+h%?r~
z*TZhG`DRo)keZ<m8FTIYxMHk0j0cSg!i6F%*^G01q@F90P$p^%Ii4*?C!e*`XR8}r
zpd`O|N*7fs-KP}5Gy|-1MRSDW^aJ_vejh!Qrs<(eC2nJ4**Xt94}{r4X5;Y{b0LW}
z>!J5K@bB~##}RIwbl4O-Kdmy<k|OpDgW@A4)S^5d&x3)WyRM2oKc(<j@u>0bF){U}
z$)UT;zUt+zv24QlVSqs$0#i_dm~;dI&tTigJoF(FrH(@3%sH5JAfH8f$*czJiR!vI
zKS6)d1(h2#fp)`4y>}qg7KO$k<A*OlgvpAoDcyw*e6b^t0j3ASjMX7$gS_$eMA`u~
ziR6V)L`dWGs1pQpAp_^^u_d@oN&rL>K86LL2x$g`pyLo09lj6i4?>EFOG5Hs&^6g1
zY0k?)gXF;|EyaL0(0v3pK|7R(=rAWML^n7O$u2x3^6ZjHKtQu%uLaov2orMKAlGXc
z+P>f@iZu))TTlPA@AFUkkTe|rom8!PUfnrX6Bfo;vSdk7WS^QdRfhuCx2=BA98@{z
z(8#4Le$WzwCx)9G%av(~xerp|!Ax0TwUSA=1Dj%;_aVf&MdQvE3Zh29&d}=Rk{X><
z4pk}FvN<LznWCsLLDW8xo|MHjF5gTlJ~01K(q@()9VZ9oPc(ll&EuKlXFS}L>h)#L
z@59V-v`t%*taNa*hlde;f?>kkx({NC0R^TsN4YwpzU(rXxgc63i6N8~G(qqf2yV8X
z2(Yvz8z>V=o;ZrDH~|NQh2H@SmOzQLC9W#=K~nGRt!+&CbafoTGd1Bcb=(rQqq{jv
zZN;+=N&)3Ifej2!xD{Sgzp*HhDe&dNaf*E8P-!4C4ku&>?b*OH(0o*N&}ebIj}*4G
zm?Nk{X^COVgKeY&HyxE@$yc*PP^KcM#H$(|1-tk65km&PxZ9yV)p#rPmyY)V<=~Vw
z-|u_FKOqE6#FB?coNTMW115mYvZmvmjR>fQ;o(I*J19aO_#08(Vxn4U`asG6=^2pt
zB7jX4;LCH^&P|>$*@iRn=Bx{YI*SJZX^}F-mLn>GAY~7T5=^BKnLVUILSmG5>=Nko
zLF6Ii!@tN7AR39I#DMa%s=-Bo=%bkgX^sj2QAkOcv_qFQvgsx)WsnUf?KH!Q1_K}}
z8%A}HQ$ka9ZRx!TI-+|8Fzg@nIwaAUq#@1!(WBMYX400rIcwGkNx$X~fd12;Ub=2^
zN-3L=61fQ(OkrlKJv%rh<%_izgW3nWUR=9!?^2J-DRL(KF1~M3iA?0lN}!@h`6nh6
z=m;c+7m8|vo?=-$iqh*pfqx4xjA-CFc4|Qs1)PSzR%HtX#$cyYI_X{xAH=rp9T;4Y
zz3amS3O-YzFei?g>B{JXO2&cwSOn8VHUqMgA@lISmzh{_7i#l?d@PodE!ML+V)$)}
zC?pqo1XfymQ}`={yzq!)7YjjU&8?aSmy@HxH9(ReRP321E7RCOk5~a=fqPX1<6{9;
zY{#sT3V^TuyeSg%Yi2;s2$T#Fk9R`GP*D7Y82c()1p#_1Ux1R6aIm?VBV0l!A>i4@
z6m1LCpJ@V3BDex$cZ}RTX9SnOt6C|*EotF7=6Yv+NZ@RrM{yTQ7ypDtZ3THi{7{B1
z=%k&`sDL~9!{(+mT-uIZlw8`hGld$=8Z6W1h!v0y3T2GOT}&aMg+xo$B=M>AIN&mg
zItAr1tJ2@klM=Z>RceN9VM~Wy#lVyso&iDmG`i{&8Sa!wKoK-PrXFuQm^}VhUoxzC
z=l$|<GlG$^rRkNP$U<-#$QH;#iWtgaO$%TJ5r;+EG=tzcMzT!c0#XHtV|aI}ae65N
z4+NUnceun9{~@TW0AdpASTDl4iM2wiLC+OI&<gNZg2;diA`^RR5jr&335H;&nKlW2
zNX85SRASahIP_%38P+<kN!tB&7+y0#^7AciMqcOewsXx-!!)H+N4y(1=fiZX1qsRa
z%$gIjAD5*ic`CI!?ll(2MD1uzJY(YYARm)ULa21`>(*L8Siwet8opXe>BWs2OA|k?
zFC+~DT~_tOGUj>;Jv`E4f`d+hO1Yam+3EGbR@CLC8*oQyH#SS;X-VJrQ}EK`7%Her
zTNxXMM#uoH%=KG3L6RS*-(FiV`<)y<<fn)S?Fbi$0T=e*0XW}sr9fhy%welUVpD*U
z@03Zr(N;C;id#zM0n$c@i3Ww;y&xoOj_6Z(-KaMBup~`QLGhUH0^|s})U}JrCuA_g
zqNRGcZs-ug>lkgRCHUj{aA6kWNJS|H$43^aac5kfQb75q=yfdK20aYt%U*i)C^t&|
zWf~in>>6u%vVhQD(sw}a*XUSKtE|n@&QN7eLh!e_!m+DccGVoppNHZ3tlz=_#}zm1
z2cN2Q8R^N9FdeVK{3V%Uj>-tHHv=#NJvS^-=@3N>0|H^h&yZ)CQXDBy?3Bpni8GJJ
z553}&e8ogX2o_-yv_A)*8s0E@t;ouiD`{~R<oY~_*wEkzYK$V;!Nen8Hh}`@HoRd0
z;TI$X(a!%I(0YOJ1oXk{BLL8$mRPI<ND%}fpd^M3;fDf(e1*6J;HOo7KYAOXBP6;P
zWr5Hjb3@|*y`a`l<g_A$Q=$Xn!~5njNFSX7+at|NE5c6DVkd8nsBnRrAl?+={HiLr
zk-@L}f3t74ke%9ZRENi2PE{tC1*gK5#uy?oMLK63FY8m-w(98tVPKqBZh$$;o1YfI
z=n!L{<hK;Yu*lRyt=DnYX#)8P8PAuZh{-06_emG!&6yZ0nrXtRVT(B$X_PY9##1~K
zmkVHthgMiA!MY{npy!alr6hR_rYMa9|1y(1?3gA7Z&eiMSqqpjETl#1_-c>|b888U
zpTI>!!PfIr#2DqlAh)`ixOOnUnNn#~vDDg02=l|l+C&ZQfs^3w(Vb&>03A*TLYJb*
z?N`z8uVtBmC1~`z5eJKQgJZHG2(<gOq!HWT^;jyotkEKli|3n}6dcXJAQMMf^8L_s
zLp1R=#K_rFvfx_yS^A<Mjvr)erm@AE^=|A9?0z~5Gy}!jT}w%oU{Jmz+<EM2tSVxr
zDLp6;ebzyC&WIVX-J_*&Sb8j~gz$S)K0f{M;HDL`@81f|HpN-ao7Kz;j^V>0P>68$
z3>JSEiOlK*T5u^rps_ZZ#GxeWz)c9g^-T(qB5<7ISSSE29_hm76r1&Q4vGIjOUb4g
zp{8ok4VZXybL+8jqj42>B+%{~d=JDHxibQun0$!82x|k}A1a+DxdgEhcm<~e3F4lY
zfm6^18~~ei21zIbV}apxAs{~k+a6%iA}2lw(Sp7xK}1_>;4;zX2f=Paktos^B6Y(*
z6bFW@02V^(2R=(D6fhsNpDx}6kkL7L*s=fTpJz*30z>`_->8oi*POW>dUnwEbr)wc
z@BWe#PhYD~jzb3D+&?A98<p5&?jjq7C?{@2NMf=F6P+u@v{0z(bdj?|hJ<7CkR_6M
z*d=rLBDBRST>LyInZpJHQ?0W76if>2OA&12tP%!!9wh<+GgK*hCS_5Azrb`t8deV=
zG|?K>(q73LDonPN?seyTpsnC9bG&h#=ezI|hB^fVWv^<+nw;cJo>)ienNkT}!r>BU
z9V8OWvwdi0ZISHGn->a)#U9GFJZzB-cnvQ~qKCFAmt9i=(xdqsrojsSxu_&rZKC&~
zuDi3fr5Ev3c+i7r-NYQ&xvkW_z>MkWYfe0-iMP<8QK5n8B*aB)h~=E|sZ^{CHUTNx
zX|<AXPH7T-_Hv?EL?67b90R5k%}tP>*9xc;dt>a=tzd3)VUMgY>+-jy4l1(7TMHna
z00Ni2_Sy=(Dq^IX_1-t_`mQM*m_RmTkST{-H}pEo0$+B`ygeN%bqYH^85Mn4V)%hl
z<y|M$yeUqWcaH<^NDm~;$vcywm-E}UaEV(CcNpmoVaKIF#{rfS(&eS5(SlCn>}>@*
z0pjZ2BC<VZDMo(KkV9h&jv;Cfh1l=ub^vxsEiloe2oqGtln0^U1U_-VIQ%$lIY`Z9
zO!p843g?c*C2hjtf#Mz@O>g)!P}0aDGI0j-7Aiz`==?plC@wIxVHm>Xoo7p$ldljS
zpT{ZSb`z@wtwng(r1wHwlEnLgmjaCfg&&OZYmCAZiyE{#xA(Orf19N1>SNO$SR&i<
z-Fu7M{Zn;O_kB%3I`Py|ZLYc>Ava7~!Mkti!j5s((h=Ki@*fc&qNv^ls#cyEk8Wa;
zACI{nY-;(xL#@~nb4sKMvS4ecQHUG`1IIZ+A#@dLJ(F9&fP1hNi<1M^DnoGt8%0`E
zdsSCC7S#h1VsQId4YfWRFOG={%alcl()6%>9P})HgA2$E$sQ&OfsV`DFpbMYzs24+
z*8YUX<9x_g#xz!l30jK<?)Ev}!6qW~=8^r><8(sI?Wu*;j<y0MfitIHdXW}N2rA0d
zPc0M+qG0rrRzMicn{=xh!X&LTWqh8FNi9f&2a~@-i?&aN4xpyI<-tH<iBTwtUM^r1
ziDGwJatl;;S>AB0DXwH+6{R40?8jTIq8qjrB1q5_(wrCj%RtjOHEQnN2nFFc{$qgc
z_R*8iUKDp(V9P*CiqLEN1zFbMjQ6BR^0{Is0HP98EOc{`NvyHV_#&B1$&!H&Rk@47
zRI&!c*+i?FW}=9#J(c{F1y@|)l#u?L4L+i~3?AYFcMPHEF_%OY2F=I|p$OBU(1XEi
zhVV8qvVROl#(Y~?9K^gJN&-#^kdmJMfO<iL3EdUASUql=rvq`IQF8EC3U>=@k~}aN
zp@eCWxi+wtSKmN0hoCQm&M$go1E&TyW0{DdqD3wO^XCd{=tu^0CBvgM?Iw{y#*;{%
z^+Z1{2BZ?gX;I?S^Gh)Mf!+StI6}Odzq%g16#LnrnEJ@~Rc9({)=p^cW_?oZ!a2;C
zvtGi6tBVj4F%;&Gc(e?d^g1ObK8|L<8zy$E*EdmaY|Nc0hklqf5<x3PqnqE)!rH>4
z-b>EDT<M4sjwf%HUT==h($WD82s-|Tm}p2w+`YAc!E``>5qu(DG!qBR_|!t_poM86
zL9>LdCu$m=Up1f0Gu2K*%>S}zI}8d7SQb^WBh2GvU=v;@%medHl=gZiDuM_hMVc<Y
zA0@C&70OS^T7$Xq^H;9Ozl1Eqv{7;#jLAGPEBdInj=6wut}sRNV#$wsYvuZ6^d|``
z!HRB@3M4ZpvP}kmBs-z0a`(L~L)qx4cFgAmN$<Gu&~do}LyI`+SG>{$NK=g`CWREF
zCA|ZWE1@WJr)Q`ohEviU^Fh9<ZOMe&W`T&<x+sO0H2}l}Of_zZu@^bQ#hqqR`!r^v
z{}d2k(%(+bOoFulejx#XFfO|wt$<)K))3G{u8K7#?o86#5-B{myd;=66{t)AOoSao
zC8oM)KvmLC1gSPaN8F|V5Spcu$ip8bvE+Se{tfd38t0G3re$Kx5$6qPN<(PP4gcIS
z7jIlCsbDlIa09D`eH0r;Yd^QF9X(S<P+7$3Kvc&fHbb&{Y;DA71?&#0AOxUG@Eq<B
zl$BE=nKi*3k+D2HAShG-8a?Y78-uARc~(Ej7Zwk1#G;$<ke;A;C=Vqr-o(hJI~lZ7
zUW4I}E)8B;hV~5EACukt(u+UYAY{nBdp%SmL?^bOHM*U7yrr-Y_4ST;3_U)+2#--W
zLWFiT;1gYV-`rxE*)10_rp=;?H+ro<nB*Dkl+T%jnT$9onbeS@=T#LOwbRNYU09GS
zCOq1nwARdoFboo4)M<-1`k4<EUQ=qLG*)T_gIyzH=!fPK>VvTh6QRSj82f&hgTq7;
zgPJq3fIzRDjY*Rc6#F<zBQ;6y<LFUrvcr#o@L+^AxKPPf1)%?F+?7mVaI8JMNS{19
z@dN`}F6e@bx0)*<FPGbCSp!8`;NY7ZS2lmBP=v9K*bxs|90&W116(LiMev1<rMTT(
z?@&uFRYk!=nZ$=L8(nFu%Zb~U<Og6+T;QC)!h^x4gcf+{u(Cl`;xTO~LNhUFEBBgI
z0Q)^LnKXfh3QOQibFC#zVVXb(0?)YP0=5+^V1tC4MTITOQbRxDO?sk5N5^&MhI)>`
zT<E!Ghrtv*4q9>JvKKMPPV7{&g)oXSjFOOZ+6#0Q15TOnl`xc{^$MCu<}6hh+C$PR
z$k+rXVPLJ%T|*p-j0cL`bTM51ya6<G1_DW<L-wHR67GyKqR{!vms@GKzdW)XRvq0{
zhsM>y$2gjgW)|u8z%?S~G#M!(6jX#{rGHKiGKs4Jxgb82H^3C|&5)A|qQF_`R6{%A
zVi%k{(gN1AV(>}WG!=lx0tPV%$$(73Y7u%qpi}?@(upR3jav)Z1I<fF3f7rS>7ktt
zq=c!0g(D0-hK)_W{~ESyFE-nsYkoU35w{QWCN3nkxbv$)rW-@}D=~V;-%J%@><eh7
zfw6VjO95C4O$T!n#zIFT%NdRda^lzf<mARtCRyG$Zr$-Z<_JW%VCIM!jyZNA6}K>Y
z=N}5ns3pi#4JHh6Y^9d#qOa2S7#t@vdDe$3=hCoXN{KB*kezqEwq5~gP(V4sWPtXr
zcR>q88y8lD%mH7GiUYqc@MVdHInN7K3M{l&H0tSTeBT&9j_K~J=tu6G7YaT=bNiuo
zPKhfp45e4z(n3G@>X{5{f0>1n#YZ#!a;037Mgd&CZQy0ko8oV)(CQED+zcYGhAmwZ
za#2>z9}5#jj{8Rq7J<4G{x>~^dtS@BcF|f}>Tb_AO}5m?tIQ~60mrc*){pTc)TPDN
z3T@OhE>y?CA~Oc@@TXB`n6w)DA=bx44&O!}4OmiW7Xsx@pbDEy9UC+I49~q&mHVOp
z6zoCZF^jI`A+TdQR9v3dbO0cFS{e8sxU>!&8#P@HuM-1L>J%>wZ<o$TGmf^nsbtK5
zqL~#Y!2HuZ1UDHOfXfHyC#)Ba4}#?3H}BR|WhR}+s1Swy*u$riP$#||smU0=!>bbk
zxFfu+FuFPi+Z{j*P`Y9iJre+AtQ7<Yi=vYPR$n=Jq<wP;#s!lEH{R|SNJjEYNG}LZ
z2?#ors)Wg*JL4=e@JIZ7K97RpMES$=5^{*99eEin(Zp6b2L7vA?utbRwFx7CLY9!(
zHv~UnB`)44D&fpyVw!mHy+q{CyT!0OqK~9~kSCvC-tgU^7nPJnXvHlSa2Ax<U$#{R
z*C&O7fomq5<ffG#AE_|KOgI`STJE)UZ_;s?u|}U`CEcrX*ikC=EH>jZbwEt6$W+84
zU<W}g(CU@;MWW)-mXy7@bq)aa1pI$T5oZ#dYIh|=c}pqSKPjzpa~KN^oZ};<QAhzo
zaN#xHQU<4i$eURx1#%pYkQK}zvt-GZ3!;gok`vF`2)o6@uJ4WGVx{t6K9B2H?{&*%
zF1p5)U-53p*b6>RRvJfKzjj3$Tj5r~G07Tvd}NwHfEfpK^t#24)(u`3Kzmt85KO;=
zqO=3xc%(H{RiXuR_o;y5*c&StO$IBOn1w-3#_~;ruB&dP0|(8k2T;5Xr5DG|#Mv=X
zaztN^ki|Jw>Y$WT_p4_7koCo&P%<1??;~JrtQ_EB9W?P406d0FtBuLMb8qAjS%KZl
zb3v8mm~fi{jFfQTP$vzbXQ!1I!9pNX2wD7i@G@7RnJr`;21h}}m6=yuc;_3<F+&I9
z!Nve2Uxg<6c{A0Coy2F+#&Ur~VU+(AdNh@o!#(8*woz>9JnXagAA(W1Gr!fG8%k3i
z!XUt(Au&a!gsBjR+CxEdk!&oOZ;PM@?I3y5GjrK9<kxF1k|93Yer9N;gj&PFh60+4
z{OBRdEHa(_Sn7<@gWknN(yAxTb@Egz$ebSGB*+LNUg=>$dZ>iQ!}&<F37H8+1oVd^
zND&Ku=?7$oCd`{RzTfqK3>3?70rVa-2ilu!%GxrT3*NspZ$Kh{gS{znEtTRl)Of2&
zB2x^@3r(u5i)_;{98Ec*`MsHvi;s^KxLuVxb4;m_^=^Eh^>Nx5bAEE%QEws{9JO&=
z;1+QGM9BHw{zLwyLo_LGiK19q^dwP&EH$3kMUbMg)N0~F1~4w~Bt{ARgfx-zR+2rn
zdkEZ+4G7SL>Ls>!&1+7CFpH9v0zKB8N*C=@I(S4ekm{iDUN8d{3c#hBO7R;*_J)ul
ze~9}uG~}!S)tjl56S;91&BHn^wJmT<^R}v@PRQb`i$tcl4|6c*L?1oz0oTWozAE#&
z3Rnj-aGngVJEVd={6D@~x*S-;FjIM8h)owA!?cE^k4c;6X$o-<_HM#8S8DN=9ls#}
zA$am03iBKeyimDhU%DkmmEHLm23MG>*pSAtVNLyga}tGv#!+~OvYSLvJ6wTit^k4d
zkW>)NrFr>A7$TUn7z$8xBF#iDk2JMOQFn82LvW+G1G*2>Dr}xDA0bUQsA9Q@P)y$u
z1_1&~n+{;Kg!Ed`j$jz(pcvs@HzU{K3#2`HBp(ByG=G4<tudJvI+z&mBz6&^#2^IR
zK{%3B>9IaQmB|zXaq@_`ipK~HHg?8>6Oq9^GT};9HG+DQZaG9Dnd>Wp3rF~SG$yvl
z)et)!B?F|9@M~}yx)}+;CMg9OK|1h+k`qZwvI&XTFxqLGP1Z=_l)MeAK}D4O;iXf?
zJuk~il({7-Zq+W{<F43nBG)@sL9c<rEjZeetwEL0Sj#2ODikHSCs17Wp!*c&fZQ>)
zBHCAF#u<xwSU%4y45FTaIZ<mZIY>0xY&Qlxyhz1hze&|-EAC+IU}HcD>18nYJddhj
z`OUM%RIf@s%vl@9SRhfRxa%%^vDkVhCO1oMp?^K*g^rF3+sn~{>Lp|`v~Wbxr7;<7
z&b%JH$DIIp!sW_SUW6?2W{^;bVRLoLTUECEMkiL<>d_6s9;ihRbG(z7{A7+9#_eK&
zTFG&hwy<kZ7RV5U88%x{CdfdD<yg<5{V*c64;s=Inn@QuO>|)XT+&jP9GK7l$Ro;`
zCz*L@=VtgxdQ81Sm_aUM!rB_MUwXLv*bx(U+*<@2gee4<gTP|RJ<{WxuYhpp#0l_Z
zvb;T_D6voAx94T>N5IyyOi8Jg-*sYuc7PZIZ-LU_*BCKAz)i-mC+5fo<Nvhphhb}Y
zG$x3g!I%{>qdm3DF1xCcH28@n1IW~1TOQ~unN&fDG>zJ3gBT}GKD=s~(&YW?WBo<E
zEkglf3=kC2@6V>4DX@AmTzF&(;!{P2mXIQ3GB_En7f*WXt^m&7oRm@);+RN8io6dV
zi-V(J4w6iwf_dZAm`p<e!vn_ZtUdrhphu_XK#tp@(?GWA;ML&>A<`Lw$^@X393eB=
z$N{24@QBE?9kPl%QaX8PJ|$E^K)QJ29Tgu?HE-F9TWD2mU@Q2Bgp^}z2B)8Q!AK<t
z+}_N}Z96S7fC`#~bMem09r~G+SbNyPp0JjfSJ~@EU~>@}k@E>cXE(}{X~K&Vs41~7
zOtHc5BcJt_awtm)XKcJK%5SWWTaQr*Obc_k4=-Ai-8-h(a3Fika*I`jT9v?2X32P_
zhl?{YDSCV)jB$lMla;a3nr!m%7>&(ZCNe*4qp2>^it^AqF|&ZT|EW$6E(5EZ1(Kjr
zy0I<%^fF3;ZDf8Qd1#l|q9><Jv4#DCmXR3P9tMZU!+K#g_q@#7Q;;U`%wjX9fpIMQ
z?MObYjF`507`CCcOz;Jn8OXpy@pTM|B>6E2UQ0)K+YGhS*kcH`8a5`+ZH&q;W{6bd
z_`|J>c^+`yd1@O|Uu?7UP6s3@Fy=H#J@M#=7{x7R5pv}pDjJ4qy7kJ~&4SU1N4=5X
zE19^dWKEM)IMZfb9sccr9uo|sdPyMykV%$2TBC9(?sD?hky<X~kOEKffN`P<H9F-5
z4uk1wB@<YMmU18gh7zPs-pB<IZUuE>Cz6A1Pa+-2bOF%T(_w1^n*by&$nrmzM5A?&
zH~CF?kGR?})xe%f>zufSND-LMWQvZon86GZ`{3mjwIuF=E||X~$P0G^#t+QGT+B_8
zE)Qm($owE&#8x>W&xG~R!P(QKaV9$fh=xNp5|<JvO!`Blg+sg#0?ROOkPc7e#Baf?
z<!Rp?RYK)4_iR9ge-PSDz5h<YUyW>o8@oG2rMPQ)+_LEEnR~+NSGRg4at41?P+Ve-
zNlZP9O*!lauVt#ef+ae^ja!T#mYv@XUja<{ga#B@L3xEq1s+UF=ghz+m~<h4fLJpn
zK6<JsGbtLju?Ft4Zp3Ce4`n$qD~jPphW;ukYy?U=qC+DDyIQnzt~u-lYc7msQgKj3
z9Rb~tBx!=JBg|OHq{Aw^!5{HViB?48cnpJ^mQTjKgeq%FY)ar&rF57ToD)~!kv4xK
zniJ6HNs2KlA*+BPCSCrI&BTf*X^xwkf<I#ISRzA@+Go8^s$=(aR1-ZYmWqilo8@iK
zJj_$DO{_gXm6&IIs&G5n&w=P%50D!r2Lo&7=?CW9%(U6(k)||_axTV^FsK(Lo@tZD
zH6P}zi`H;9@=Yz!W1%c)%|BP@0GgB;a&b3G>rf#SLjH;yx5TE0uWePb*43H(Kzvga
z72<B#fEs&pq>KaD7vSyS2H%5Je!@6|QoIneWCJiPv$8H&6xa%EP6TW;n&)H^gAF^i
zR2j`CBO_I_KKEQw2+VcE{#YAl=tByzK-dI?+5!Ai6y#l#>-!uhRvy$CQjeGoRL>?W
zjE}ltT$b$Q5Q9x&EitQs6OgGSm>%eO6E~0ySkerJ9%t>@Lra(irg7+YksnHH!)UT0
zhn^h)4+p2h0bqKN1nYrhnii4?SkyFZfJh)P-2*2?xuQhSO-+;tINq;bkAQ!2;w|rF
zF)-NOLe<?#&#+sY`7nK?Shr7&MxfC1Q~#7A_0|f^_~63PKm--#$T60)#1>;AheI%^
z?*Wob<*&3x%AC-kmV&FX(T*`=B>*ugJ@c>|1FFKD0-{+dbmo4PWFM*Q(8sY%>l$kt
z7RD;w>~k!w505Y-`?N`{2+(AFs1z$0+7SoQhyZ2uO;cM$ui&Faa1@9KcNhamETO}~
zYU)VFg%BP3b~?vKCm}c4(n8?{iW4L_FB@#`Q$hZj2v{~zTtB>nqd+xEU@E4zsz6*v
zB!K=48AF9?7TGdj0y{gNiR9Vprr-}YFCf<fVUPJ$A&c$rLuUM70ju}8J7VaTGfBjX
znO5(DHs(VX&6IH}=X{>UW(ppN1Dg6VrSNG^l_q1`tqLY}@S!Agv#}%UU3jo|JOy|M
z*t_DMSVr()kO!L-KW`ZcD*_w%F~lE-l7$_KFvhXjg^XaLm|-g-6WhEIsl-7@I2Blc
z-C{AMyQnRj52YlxM-L8L3$D13QDop3g70pWRP06?I(tEFVT%zfEo)@SQYAcO92M4B
z<DI^dqkCsX$*2WrFlh_Yb96L<6H^W6LmH7W5r{lk8Dy^)!8J0my#>!2|K+)nwqX_C
zZ$nrCjszNklr4vwLjK(j6BUvDVC}dnL<`2Ki4jOPf5)(ks1>s}k+Bof#Uxz-j7ZXn
zKqj_vZm3n98{#f0nWh)yZI<ekw@iVo616WDOIxy+Hr}w|n1(s+a+rpVEIrdb5`FXv
zCvTesIoB7~gvJ{CJTb&H?Ess?W@#ukU>qn;y^A%fF6Edx-v-lfLxmt5a79h69d{3L
z5-Qj~-qN81TY_=oG;Djahj-@a9utF!5etmvB;Se&!%nFw3Wgc+H+<9TH5gtdGxP~)
z24VzIj=0!|Bo#X|c!YhL7Py_4+2_PjVhqKVh~x*jCCK!=DC`!;hABTb;Vod;jG(kn
z7adhQg2^96S08)E(Z9(On{JkyTac!|zYMKwkdtX5(}Vb^$9ZcDSS2N*D2(-i16SK>
zhJ|L$nW+3OBn`8b7RjokJ68BjnLMUg?}MAR(4s4^sB(|FDpeHUaF>&9Uekqi<WEmo
zm=z`RG@W=A3JzX6dYz$GynYN^r3u=j*vkerKmXAD3%gfb_ir$d4`Z78<gGhjg;8g;
zDPYrsC1`S1zgt4g4Ln|CvV;t>#DZd~5G`clUqH`@5(X?$AaX9su*U}hjU9~BJ*Ro1
zuScXJAsZ>MJjQJiSAc-K^J6g5MgDQ3XkZ`U7hPAx&5O0~7U3=IV5AtHp<wkzOPl)h
zNaq?914J2fCd6^T0|7vTo1@K*X<9G_GOI*WXndXiKH?I$W<o$$IW6>lL=V&MiAEqd
z8UG-Kk8F#9%EG@E5<v_*PX{9RNMoL;QIK%Vk<)fEER|R9H9+SFC5E2i!hl#}PkWwh
zSH}SQ+uq7z@cFcRi|TIO-S%rkt1?F>avrAd^bC%Mt%2>>*xR%tCYrJk<?tjZ8~iFT
z2C2aGup79{L|?{%`4>XAF16h(=U1g$S)|O|5PGbC%2-9r*(povW?xyv@gbzw9FtG>
z=@>??v5&6b4CrFoI`f!bW5@`}BnS}=-hgo4+F{8Q9obfZ-Bo0JPewi`O@sy@%w2&b
zEQe8a0DTU%JWa_U{TB+x_G1?8{1l8Rr;mVvAtMtq#|I;3A1mRp=t$IJV8aHQ1XZut
z2caThDhoDBipC`p7gXqEH3=`p@K2FPaZAz@9ZTO^^0VcJvM_G(?TnJ@HR`kPT~o5T
z@Komtr4+Uk#Ne$UB|i6<OmR9TT%h2j%e7%!$-5Ff>d{I$sGf^4EpA4ANuD*Do6<R6
z4*g&)<}u7nL4%`p`_Selju`x`<0Faqoz8|WtaRi1M(>QXHyz73#BKfm7<(JIsLOQ!
z|2xAl4hT7nn5@(~3?rgupth4K<$z#=qKSF76S*=zrw*0b7WN<mf`Q70U@GB5nwp;d
zYxqRDS%4Agim^vs1$CDeH{5o&jM!3EWd85#9^8lX*YiKG-~LWM0rUOd*L~fe>vMgs
z&;4nk;qXuC)S1kUC!0zZP7IUga9ZEmdF945#@@W42t2^Pf|JplmO~<jZk(1UnOjR;
zXUkaZt=aX0^x!mP*1bt<P$3h;00WE@%4lq^My3&+mW7@mq#x(GKl_n`FFlL<@xr%M
zN09nXfHFp*3JXYcCSw>{=nX<Y%fJ<X3=KiM&n_|(hHr&UBmWDM1`m@}RT8FS2@Irl
z$Q?~&d446I37$|k6VQs4QNfRkEcXl9<XWstN0wqXkGypoVQ=MV^)n)*YeAN3V^cA}
zDng&kqb5>-d<Ph*827qlnMKFK;PxC|POm&)Qt9>gFI*VCBD~4QU|>AMeCTC|YJ-A5
zPX@L=7h`0PH%t(~m8V;<-Q*k{mBoy;v#?Ok;9yKwDhiMNFy*uHKOR!`Vw$Psp%)Xf
zo8IZY`c%!vJ%BQZSzB`K(^=c+ed2Ioh`}sYVsLn3a-!xiW;nF%)1l8UKY&(h=k!gS
zIW}gZ<}L>LO_;c6N2p~RW%R=4r?d1y@6we*E9e^hc`{Qi%*dEYuyfcX3rZgf+o?YW
z8NF^5N}s^g{9s3{9=)|aH-ALbtO{w>=UM_Ilk}oO5k^A<rBUIrdNR`I27`mCnbP>F
ziys}sEb-wNJ)XON+`aJ^n=iwWg)ixv`{k@R?r*r_)n9baNxKlibI|IvBKCt#*)jP7
zDDpYli0MPCPIwOS|MK-Zc$5hq)U~TdFdfg-cUYi@8N_sL*4vZ&W)0veqJvWCxbtGQ
zq+~;rJKA70i?jm28hCJFpNnGEAHLS2WI;H|c%s|yvq<`)o}#;w#4ibYYTqG=`LTnJ
zKY-Ah`Z&gB3W{7bT%fK*fGKPc$H18kpj0`iTm##9<}7`3*TUgPwr0VDgKA*VNT#q2
zs`6xZRyrYz_PS>8|4+g-?F@yYg2xhE_VmS{N;sFXJwzw1c8l;D(}MfhLD<q@q&igU
zsK()H06~V!*yf;{w&hfR49*ClAu<*~OPfef)TLq!on0<|5Ubl<L+O9scQ<}lr<hKp
zri93@yGdaRRVd=)sp<oWRzBGP@TZ8BkG>l(0HL{Y9wFJ|2B8LT%y-a;JnQ^6Guh(H
zK#<t-ED);nTnudOCo9*Zuq(=H7{xcj6u>&M7Oq&^RHO@G^^%gJl9JNne{+D|;B0`f
z`^<sdQ(rBfoKHIrU>LRUqnWP6A#WZ^jf~QEXzUB?Q*##eWs1AO=&-n>r6ZyNm8lqX
zb|_sbsOt|cv_t$ZnD*h8LnqFeOR#i7NL^zL3V_m{Iu)9Hfi3XG=c{AiJn7j!T?EhZ
zyOKXGclQOn=r>K!N1>#e|B07Gb21r*@tC72!W6W$U{vjIcCFnr*_w-3i{SupL-HU>
z;Ih3s+rco)@V*dqbM_ri`+UaYWYr`~E*y0pFAYOt>~k@!hGl3Itw_wF*d6%>te_bx
zcDSTBv^#=wXX5nA6AqNP;dB!&&=;**sf(&yc6UX_*hOE*yEQ)Y+w=5p4Uu5ma%0G$
zg-Ky&r-}Rv>LA#8a>50T{_W(Gh9bx0v%l9^I+8a3liUycIlO$A(YXtx;wf9`*}^iM
zkq9Bkf!2Etd!71%k`L~aDhGv;8xdOi;;1uT+VJHfS{9YQIZ8}KWI(oUISpL~yHzKU
zSh+kJ^Enh5LkdI<HL|Sp)hS8{qKY+gKIqq<y=zDR0umeALv(tSez)edC=8%EbWE9v
zIP>yoV2&SOh@6lDhsu!73L%Izgbg7$hy5WNf&rQZ93X73=fC^o5M(W_50ztwaylab
zF;p&G>Y;Perlg7&rK&>W2%tnZ!c;txVkRjomfWNGM5UgRsRf$!JPJIy{!TYfRa<Iv
zbg5mh{C4CgQ?N*YCOV69kHL>4nXIh!zek=p$Luu4mh{Zf$jN!-We(SC-^Ijr2>o);
z*M+?f0JuEQtjN0X02??+FSZ#12-COE4k?6vBNb9plpgo&=xbi(G%YEB=pc)iLT)hC
zDl^wi5%7%xMre(pOmh>1OPqR8QX>8%z}f}2WK6=ClQA>8MLXZa@fUv>*1ROSh+!?-
zvyL+l*sym%a)-Xk9=6jAc+V?_R()sPFHk<^y)Ztk31l~ToAx%N58&&2lgNF|56xVw
zzi4HMOKW=MZqO%aJqZL_<J!J{B4ZOxsA6O4UATfd^^pr~H4z@paOis`Xtar<)EW>L
z7`3Bj29_5t1|!JtE)b}ZDP9O`Xe%J6?Kq>exJCu988Ly0x#65DH8|kpnW9B;N{<{z
z1i{qhGV8Zam^_+>+xZ352W@POZy+8^7ivQ2k=mR>;)&ignf@cXY}k2PNth}K^ESvz
zRf@2cNdxLhrdw{xfXwop;V4hgfY8EIg9W(e0VjxksVkv5NY6sri4TKHmAsgRdv#Kc
zvnIkU%ZxfCH8DnpC8|W0yl@f2CM@7I_X?^onHC^Y>9xsF0NrrPQL=KfGFAZBa~7oz
zDPYW=jw2;1sEt-9shKX|S|JU?bTto1&rH;+Y%_nW@|;ECe}1;~Dgj6STO|p0*<NDM
zkhNvt9Rpimn=>-C>rraDJnytIs2kvcDi&B!2*E3@pqw3Ce&XiDJvhvv(uB8m;6yjy
z7RWsLIVcl%fV<%)#9Mr+R%5kJ{IuNr+yH~i9bb}V%Q8dl=@+y<K=0}6<LAtJEx8Cx
ztDTOqIjuqV$`ecvBqneB5<v;Z80eG&ng<}{h<88TOl(U2Fou8+ofR?RxuNxkHpOeU
za2HLHdAz=)2(#YcWP33HyKCL5QDN4=u)q{|+65E*qpS8{(MfwrO-Zu}xvB$gEOVZR
zz=n~GR)%LlzDwJS6V5#+z{HGgEDmQ@L%!b3nO-!lW`d=8Kt26bP8-MMCij{V8Z!s^
z!Rf*EUKAdNqC+|ktpMw0DkKXT*=yq~P<)MA!d}fo^A($SD9o!{5$<XYPM`F87L-dk
zVgNH+<t~piVX8DdG-+}dnrX0zrcXGGtW6kuCAA({xX5LWl4%&BPNKm}OhzJqQWi^a
z%N#82Y2p|HG}q8h@Q-CSC)p(WbESatlW$BzhNjAukT->?Aj95Lf2u)nk&Xzhff|&C
zp7i`=RF^oM`xYBj6P=%8o*!Qvi0v4NCCFZ)rOh9Y-+;(7K`y`A7cG-EbS0&a(iiT|
zUqtG`eaMif3O<K!AoS;8jv*aGrfP&wBtr{LDIiABFL)cyET4}-2}(+kKfOr1N6Dq&
zx)T)@n4Ng1f-=sQ=X-!AOnUvol=*Ysnt(11N-Q*p0c@OO^zSYtp(eR<Z8cw{RhCoo
zhiXGmUz@-s+rxJ`7$QIh&FcwHD!BRZ9Q<#Ryj-k03KWQgQb}`-J96yWWM;?Qk#i98
z^Aam*{Fj&lhevKa3HAcbRjmvq7UjH+PL4&vS70e<SZO1tqM}ZW1z{kuuplLkL8-TM
zdbrNHj@nH$gCV2Y-NBTh#97}tyBxD?G-E)M7${UN%mP{j$1~+q(#)t0Xa+x<x`m8-
zGe0N=Zd3hA+!a8!^zVMb(Kvl%<ldibn(v!-xp|GfCSr8ciiVXOKo_jU{R>hWZJ!t5
z4D(Jk3>u2^W7<#?W)XPTgzLPpjNYj<&=8cMk}WZ`jf~2OaW#3x+9CLx{yTs3+buWV
z+)eqY%O640CS*t13k)P6PXUuI8L+TfV=32U?b?HWeMrGMnTlcH3+w<ECMh@A&!Dy@
zsbX2exD-9Hn50AN53PsK^AN%e?o6a9Efj)|?h;cclj0i_EoaWwfRvecq-MmtVj<ym
z>AiEoUPuXyhXJI}9Fiq_yh#hxpqI+@r)iI<F-G1u-&2JoS-CjtSNlGJ8QFc<5~cDg
zA{c$D@@!!95W4_q3NEYc1{?Bj&<mdxgiPX8R3o1h(uL1cN}|C1X!emAAZ4ryi0+eL
zhH*RqQTTfCP@ri;jEfLarFcQ6iV4@#_7Ph!YDY#Q)PN@2lC!6G^c}oqUk)>Oy=%7k
zw*B;%laj-KwQoG~V8s1nMi!g1-ZJ$QW;7-K@Y)78f5baDeijyL0S;HJ!I&aq+v#Lc
zYyPMsX(i>CmR`v(8@9=+tH1l&?>EDx{qkX@+x4Kn*X7naHlAdxHlre5YHp2&`SjDN
zW6CeMs#YSePCc}VKKm5no}ozq=&^<M3$4@5+rLcS^KcjhD#L_eQD6?Bh#HG!JTtoW
z0rFb&@pD?dacMzvvd$W=ojpx6(H>=BC_H93@)f`|SUwr**yW8)C+0~eVpW<dmZqeS
z#KMfRA+E$RVI{-&><kDRd*tdf$NxAIiI=tF$c<mDWrjf4aUVo=Q0k7ph9p`y-}Dcr
z1%@24YC_cnA<axQ;@0h+>j)X$w_#qAb;RMdbeluRE<BTudR;Xe8C=g|FK-+c5&>;m
zPba>9A!Rel_TQiuN70HYPa$p2n)(Ru!u#+|p@A;4RCEapG@_kA<W^)_G`wlXddRQx
z)O;~gsBJp{0!YGIL3m*Pn14t-$rLvw8oL1{;NuhDHp8P<PTm`6km(faKOt;rT<$n*
zK<y!-yXaB6h|j_<0zQQ2OBI_Wzj{f0_DGr16G`O#iIWa`Z?J#}S4HKJOem_px!*SK
z@@OSD?NM_8B><d$f<*+sLf{dTQj-cMfoZ9OSg%o|vCKzwc3fd<Ui3X9Px0&h{@N7O
zBNJpI-<ATFBN}-I<QtivMlc^m+8oeTBt6uJ)D2)PAX)dIQtb|I&2fg>oY7J31Hbv=
zPmg%!Smq=JYGV^^R1LPGshT@2)=dA!1S5=v5&oh!*yy>7n}WRNZCcS(_u%xQ))JX|
z`Q*R8Jv%t&!~T&kev$vX)y3~VJmSgWDHSjpR_Hxb2{L{WxYcbu$Gm7Bq6yidwzm%l
zMO6+-AK@N+ZCLuAopcR#&Z3E9j%1!(8E!?s1-yk!UOLK}Jf_y&5RkHm(;|LD3JPfU
z5UPLgq13^GUnL6#U}CA~g3+lORK=(v>8K>A_`SNQc&}?PEx&1Ro9-_o*m;lhZTn)=
zpT+_N%2ikNTg#U3@{4}AI`qENl{qI8zAq}C^|Pm&U6B{v`^+2WEq0d;$ChUr^ag_s
zfW^ZvVA5cwb0x!&^q1<K>kx`G?V5~RSxH{TP!v|-D0m?~F2!x8;YveC@Ik~HS-2>A
z_gXk)P{`Q}xi!c{_=ts}(3s}1+V4ywPmP`;Z9Mao030dMf<i6Ggo*cDDS7~EG-+bl
z#RE!Is$v9p=4_!kO!PRo^Xa^G^Rgy_Q&P3G$D_~8eXF6a?MdnR3{Z3m->YaEaGgh%
z((C-s`S9`|Cb*!#Cl2AltyxfJw9iwMg~qVq%;N1y#@thlvt|q<IcWWfG{CatE7gz}
zZ&cBb3POggKk<O$(0Z@7b|K)89ZHu}38xjJ<X^DusT!rwlE7XxoI^z}f~u{Jax}Gl
z`)wgNOl<!0d2x9a0#UdTev%r!<lGTnQNe8WAK60EGZn%W84ZFh-p2zpwxrEEGu-06
z14Y>1`|F(8sP?U`tvfG%(EZj1=g4V^Q~_Z#VqAk!&Qo9`m<Kb>i#A~mi6z-ZD>fRH
zV)o<>pAp4r6&om{=fz*9KX>u*+BKL=hZ=r%{>;d=p|Aq6u{hUMrIs?=`ppK4QKGDL
zN`6hu#6T<AKiRz7Aijh2tmR-DQyVieC2CDjpt0n*V^$5W8cfNcuMx4kvA}7g$c$nv
z#^E|{+iVK67#DqoaDzF<7i@x&aJ)3T-(C+0Iq>vDv(l>U;b~dh*V7<_xt^o_wGL(@
zV@ke$tk^DuM?~k3Facsp%HdCBG(TS-@XP4z`p5fT!9+EF!WTP|XTec^tv!vYEsi7<
z7jQ2bW7z^RNV;H(!*fTCFgs^^qI;(Rjj&gYjhISjD@j5jmUoY17!Ix!!=~PwQujVg
zFl22%d)LTXb8tKg1)EvV2ls@=Q(J2RE>paf(T*RTAN55E#;YKfZP0%ddb{?dPgI^U
z%sfhZrtw0qvD1-X%bZw7Z#g?*E5tBZRHs`8ooPyCq@9xToBmNw&AViP-iCP&yMR3@
zjdDg2Ane$Hq+UtiG6zp1kPs1jal81w$wUwJD-;HONPZD5W9dK+B%gwtiB{=PDgl%5
z8hE90iqvvuNFS&MHwb7c6xr+}Jq6<5UTb`S6+WJZ+0c%^3?)y~^p>8H(3{|<LK9Xv
zFSWeZUrJv!mq;@}jv%2=RF9NSd&V#k0@TV5LZz*GUN8?C(PyA>#N~laG&ct2Lgmc&
zmZhh<d&l2_9-Lw7{=`(|GbCAF`dvpK?QgGrTF%(DjCCdD>r+bjO#{-V67gE1&mNAH
zgd&1&TIE{ArqXUV!05_{(?RftVaJgr(r8{PxoJ*C#?Yj>4En+;nm0fX$^6)i7>@qY
zedoY{;e*GhEaRUjmzTu2U}4<RS`ibv*8I&TG<#0x{Ji8bOJbS_R3#=A#s+FS=EJH+
zJb`jz64YQxzG;(D!~m-Crb`i2V#~82Hgywc?)!TOu43pooIQ2YSa{>G11~8QDHHgH
z5Co;<Zx0<weT{QIeMQI47c`T`xRX9;NkJAW-IcVB@)^p+2S#QVN*wgyVZ7JHTCqrQ
zjV^{QSj7Ze&5Wp^04O0htz5?La;40~?6L|cm9@Z~qC9MaM4q&6+KDtJ5NEI?px1_A
zX2@u@n{=c;UKuSLunF0bY$}H8LOwG`*_&)BG{e-z__;hSqE=+rOs~tPKSMBClORzb
zG9U$|yW<sY)Y*(!OrmxjImWMPbc!5R{)%vrsc<>>sXJYJ-^8^14O%B6O@bo1R>t>6
z#!6u*U485{Q3VPN7UEj?Oj^r+oJ6cMpn&L24N`u4N$OjW1nr*RWL$=$v4g$<D${}+
zW5~@wEX*O;O++^t7?3T%TQrB#tCnMermG-wja|k34GLYM8l~AO-6Q^7pjq2;Iaj(C
zyR<vqRMNXP$6VxluC(NXzkc=p&4;SimNFMxIeAY%-6|_9F=f%78S?|^WMiNas%MHL
z+&MSq^Bp)i=`A2jHLKm^wu%8~dT`U+#SvuQ3xop7v_m>mztcddM3aocXi?H<bW%1>
zm_NSI^5(F7FKx+qH@ave6tTgg7guRW#oQweQa4qGI;wDTM`MwjTxGOm4ba6u5#etj
zQlg#2x<3yqR6dW`Z8fYkPy5ZTu*ed|6Y*~?7acAm_<HYTjtuC+)Cd`22}9a~0&CG%
zra-+jA90ijpLR}P^p#fG*K>N;Ss7m(-B(+hQj`=+lQa=_v;7`VWf)133?Itz>ZAi3
z=wVG`>iRXu?9kX|wm{2{;t_i%L#)qW8jW%Sjd;37;JYK^n}Fx+N(yI<Gbj?W;klR(
zuME>Zi5Gz$91p-Dh?Rx{B%IZS6(C*ay~w$;t}tmDxEy_eC1@m5ZskET#vVgb#gRnV
zsv<;1B2>+oMC~eCCcG;B0xDrMvSe_bx>4-e=ic+^$TIFUT?k<@aqpWM!)Ss^pOFY;
zfQd4fupy!>aw4colrINO2-hbyBzOu*p7axe_w%J8Abm;lzK|YZYd$<|$fY=ClSB0=
zsu#Maif$D0j&G@4pJbMS)s_B>FfM!pz8+btI6}!IC>0eAPXG6F%@z}E>1Pfu>R({6
z{*NigTfapa72s+e_m&Lfe)e$t`x`I3H7&rUou>084U@g;+x2vo5n5~Oc6;|1Z?;C^
zi6@gK=!*hC;YgIIX{0q`OhT~F>-82|H@j$c8!^JQWz~2KO(7BjxGK=%;B!(H;*AiG
zEgwmh18Gx9O~it{$+23z7(YdUVM)+QxH{#o52ccmLq?<q7wIDwuF^$m25YWp3z*gl
zwuf=jt<kXs9L$Ni_=F?sy?|RY`WL2oJagV&ch?X>Ncd(NcW5iJ;1}upo$!qAI|Tbx
z`gDVh2S9W7B;CsOeL2^4I#}skrUD?ZcNAll6T_Hg$<tEiBc#qs3XFtDPNGe7++%tg
z%WR}wXuwjo%~PGNkfsSvhB0Jhmz5rqXxlz@yG;waIGP0vr}usKG}HQc!iV)6QZr*c
zmmz%cTvfmqe|kDdvC~Q=N^cv9DpOB&D@Eyy5=w>#&g|N8*v?2JTOp0qR{#z`90gLf
z69e??67xVHFb}k~pRdm7tyz)_g;wzEtJB0f!)oKs79z2yJVVU03+Vuyg{_GDZ>o`g
zDFtAfG<Fmy*w1H}%O5ft0Fx=gB^ANq1tR64%np-47U2mgFhvxn9LK`)P<fusIFhNn
zHobgaWy2#v6u1x|j_{QnxzN@89lUvJYc94x(wvg?E?RCz#elld%R|&myl|C%?h#xi
zcWmqopE%@f#)-7M`t<31zeKyky+GVLRb6K9ekZlHbJ?FqE$@Hvg^!q!jRGc6cu;~O
zhqH4}3&|dfUm1QP>pRItrD&4%HB)vuqMT&fhGa%DQ<#PrY79ZR?X_-4ZA(QxNbfCC
zh3$^MV{460jZr}p){$>B@a@#{F~6rdRUX5@Vc!TwQ!etrE=d0ICNIqv3pc_Xo~})t
ze&8n<n6AqhL1|O$2^|{-Bf4?HNJdtY@XZ?m`^{;!O<y=|Oa_uAZgJ6Bwk45SchH3i
z)RJ9tK?aw$uoBZf0Y=fRypASiJVjFNln~7F?OHrMmu`hvXp)O+jQQaZDHu7KN%v8t
zt%72v!4{M{s(`{f;9S##K^S#Qad%p{H#eUP3Jgss+4_OV&27OcUdHw{Y`H4|1UsB2
z9X78rF2HabHnE@(>|G60=Da=c@^jU5e9VP%kDYiWWlR#*nmOA=DpI5&F0E;fVha+!
z<vWc^341!jMt`(Us20CyU%D7L*9sB<Bhy7zUX@~|qk24q8Y!3qoovUlin<yPnwLL9
z;(z%UV?X%*+*1PD30WXG_=1y7Xgukq!+F!5CI8Yawgp=SuZo=2@AgF93sWJvoqr&p
zTMSY~1HjiZg}eK3NweY)Ws3v@#g#=iYYRB-Gnd)cs{Pv#0?I}f?psoF%&7g?TFOt6
zQFPf#AZMv~We5{GUYJPfwDQG{L+AeVtGm411={_v{Z@MZAI_@FWfH74kjsUA52c;{
zxv0KrJ)st@ccV#NFnj#T31euXpqb!fyDmM(JwvBK=0Pa!I7JND0bdZ0M)-{d7(*Bg
zD;wkzmUPjKS0*AQb42B{C2W<o3wPl9MEmM=STI5+OcrE(tTbMeF0k0DzeBlW-ucth
zsmwUSWT6Q(1z0KLtl~~;&|qZ%-zKhP5u1z&f32HBBYk*3JJYrdnhzSv^(>JdjRMmY
zkE%)BRX3sWE)Oz=K-DK5N{e^tyrD@NW3%9bFs>K^_0whs$uaig$_;hVb+^_;Fe_%o
zq$f*H?<ELLO0GRAR|m$YwhCBbe)0M8P>YqmYq$)hX{I4qaaZZMmFA*pNjXAzU8;2!
zU^<NkKfF0oEK@&x1dB$TdEoR&t|1A}fBK=YFuI@5f3xMGu-Zk3x6^5)Q!d&N=CBQ#
zg^5rQgRCEBeJmpOG$tg_u7pWL0t+gO(fdtifIDL`HG?4Qv{92oMbI3&5eR&3G5SFn
zcd?Kz1zh`O7SeMOR3^Rck!4>#A5^o|*SVD>jA<_r3t%g(s0hOa(2_BPWK7-$6E3P&
z92<%oICteBfZV3#T_EFLd_ezKKoIipWvIMNlDn!YrS6nj-Rvo{hjQu7?jiW)$B5)a
zTJA8M=cL~RuArI}b_P#xJlpcg^{QJb)_{Hz5nv+yP%&MAF4`I1*71<`=%bHzy^?wd
z46Wt)M&xtj*|_f21Lq&Ukh1oL*HCo^AQcMJX^gSp?-&;G_;zc4c$0Z2<K4VSjEO3a
zqj?O+KFJ+m+pK{R+%-((p>?u+Zs+*d*3^o)haz%i7Ak&DnZxIJO!U?|4<m#i3nm5i
zgoS5xXfUQ?WLFtN#gkITbB3fllcLt>XiU2*PTJ{;<e9Og#4if-rb1IbrtxIx#i3yl
z=z&V|ZD!k30lJk9e+>RZT0Rzh@3Q?+UnHBj+ycJ`B(Uam=?yg{td>0ybh^kEZ(K2g
zAzkKLlEvhb8)xtt)*U|waWU$!kr9DZH%;R=&#BvNitSFu9~uraY|G=pqJ~nj;y>ZV
zgh9tG3ZEN<M-aiP%)|vz^G2<y#XKqvGgruSBW(O%#cjA!S7Kmjw>&krhW^0R=dNY-
z)^H7=kx0o<J|QpdjHF;>O455_?n`V$$WTRf^U#hU4&i*15T@wo9+E1ZE7H4g5p-S>
z1HOLO`cUvFxSVDlpBSG^GM^Zg0$RWT3wT=LlEp`7&a=<<@s8^(8<!{z?ukR-7F01R
zJhjZXTpNa5sdkDIK=I8eP1P8pV05%B#1=6Rqq%Sqx%%)=)z@pxwk%FjwH~e|Rr__c
zxOogd^UM+{{e}c$pe`2JVu^!VkNMxV`S@naID=|k3fM2Dgk@eGs{<L5;m3o>C0Q%L
z<5wKY{RzL?#|4XGW*v5i{-f^|gD=`tbY+sI&)?4bzU}MUes;nht^>l3PG`noAj1)k
zOrFOf6ED1n`hLlPchkd>=rK^}gkYXK2{!~_B|RIY+$PVcDFJBvfc~qr0I}<*|5*#6
zI6DOC<_kFQacB|p(3-r>cqDxY=^4pQEYeGfLCp~4eL+8!t6OC0zrX=aMkMDDs%t&M
zTfUH&Z{I#$3olrYl{B_J&_e0>I`NLLO&Sbl=j02hC+&pgZjRL>?njgKJjb00L25k4
z=0urBm5nXxX2!?`V%wtvKc9O~FENb7P9$9%G)E;)U6f*hJZ7Fi=6#SL0+k8oP;L{E
zNnO2$C1&d2Fg`>G$4lNBtaawbd}SCvpKB8In7nd+INh;3X@Ky#k&+qx;LK9bd@(Fg
z;DXZ`(a5DI#$wEZPwOEMP`hI3wa-UidXIkh^GA{y;CU-8T4(YIkwJQTD=na8AuWwv
z>y-VYG7%BmKH!Sda+K3~*Etub=3~LYKH#+Tn*KWjS<o?u!@H3FJdx=+{(!&U#2buc
z$^eM6@AYsScjc+gFa7?6+~&<?o-(+o6SX#Cs-4ng*MiXg@zykvIFT^LwolGet76zh
zlO){{t;EVyU<`t5e=kUF7Qe5VU6XN1=}<<d&ftC!0@_b&P(w<Rro}Eg0Dc5tv}i9N
zgNjnP7-@D>C&HyEaHGg^*&Y<es;v(C!Dmu~b8mN+UcYvSOE-P*g>}8(*AjQ2<@!g@
z)~x(E&L#I=S+)Ty0$gXO?GH6lw_R*9hrRH#$57!0l-4lu#`KiOvl}N>62Vs-q+v{B
zQ7FZ`(}v&61sO^Wgdd2+4P%dBU2Qy`8>P=Vpt5#o1}~CXn42jR_sorf-7^CqV>E%5
zJ2dNNEIlfSbqLL-dYA+&ZR_-jfhfH+W*7NkU)c{bVMA&2!r{R-k&GfxWeP^dgtM4K
z`6^lZ-WtfdMwoI<qIPlLDeQb+|IX<LFijCNkiu9m^?Pd?DO~%52PG4oqZhDfh%vwI
z433{WfWkLCHjjx5b|L8xnE}+i21F~S9<Et=E@l(TsU{6IC<0#+^!9bZ%$7+pyW-T@
zm=Y16r*dzf21+Yh#h6zps|Uh~V0Iu0C2z$5X3uNNHx3iCV<7sH8)qC(4}WOPm}I)+
zC3OeOV@1G{N|QXfFzs;}Eg%J6D?=O2puN9_<7$w)c_ec<6X{i|8#%;_1H(9ub-fcc
z_l=aobERZqfR6Q+WiN~>O%LiZA)aq?YCOHS{g+%(E@)b+G_ea3kW8E^G);<@ij%Cq
z&n(slTTUgL#Ou^ZF(padKdLALSJD*`hF(mY<x5E9)}mgk{1)|M*-dAXqlcX%;t@_g
z11(ZN$t6_;BVp?SD~Er|MiAwS60T7Bs#!8YG3*^~P@_c?#QkWUul^$IhaY|@smrn7
zUikFA@9x^1VNvbxSznC%-Kl{$KYc%{sFQMDu24xInuKM!p$Thwlp34an69Q6`b#NR
zy@qtOazx{NA>5e!Vm>>i1kIYpOzp&4uh_#RQT(CGcDo|y&>{@7#8S6$DVNv~Q_$k7
z;i7@KOQ_-+WA2FIk%cE2!sS94HQV`>Jv@0&tRBGbD8_fxbUFw#Y@K79Xz`@>CWoKi
z6}CW+A#nd-PjqsXfigeLMy2`*N7%(=25=xWHZC}zs}w&>OS&%JZN+E|!&g{15ft*8
zp$`cGG<aB`U&#M}H92ukGjo#%L<TBBL@|~oCUj82e?t2Pv-Z<+cR;FEILyFBc5I7i
zx#Vrp*T>WLnf0E&J4>c~vjCA4nn-B1qTs^y483CwE9wonR<>Vx(HSOj^if-W$e-+4
z^4xRBU;b!<#Z3>92_q2`k<{K4DK<=luzjj%v!NV;xfU~Dp)xQ&OC3U;fY-b7G@JX@
zjd_!{8>E0#5+ZJlqVN_{PRUNuRI7{0f@p>`wf*T&g?OQJ3-!A>e}7jd7X8(kU~<T3
zk&EJ@Eo6llIc@Y4a9kJ@Hwud;vZQ!D@mCPp=>QKQvi<l(TKHI1^67Cc^T(l#9#Abv
z;VD-|DPY9A!x>+uKrmvEE6LsjdGYx%WuO`*uoo(-L--VEe14wnQ6}2vi$N7PCMjzB
z4!xCu-Y=?)OS0GUV=WtQ{`I|AAGz`RwP~yNY=-f`_H%wIwetwM4Mg0>&JAcD;F1FY
zk`AH#=fn;z7al?SYc!T$;9u{ZJbH4)giR+NC~m5E&Y!))W~L7tiP3N}#vqZYm<`ys
zVM&wxn*+0OA0a=9)iET64#djkqrnU<8hJa6eC^go_tk-68NC=IMi29umVFB4p4CYu
ztt*)#3DP>UFC&IjbaIy+&3%m_nx~?%c?Av(xtAkS2a=20{#<#!-6{RM<C`i&js9U4
zE4Q4cXeDrwGMGTaP&`i&pQa+)u+b#sTx8f5NX&@r6q-wyA1E!iqVfY(a*B{&7$>(e
z)Qq$^W|sr7CQg{ihV-F`{hGBJP|@hf;gQnM@3>EnW{e~%YdQKyM(UHWKv~>(n)Wt}
zs)cMLAx3!DhuZ58e{gfi*s~c;7cWNBHsOSLiXs+lBkg`v*!E4>l;I~rdS-<cHkm{X
zB{`DpiOH*6#=-6ac$iU%(2YEE7LFPRO8#8DEaB_CN+(BHi8uszQMNE;5?MNS=eGyP
z-8jhg)k<9|SX#<6t29pt4u%>N@xPWJ7JxxJ8~j6nsyr-!L7ISUSEPxu?f4Y4g>K<{
zOHRc|heNVha;prPAuA;}z^VTl$Z3>bQaH$8C^E=y;JmoWk&W48T<c>&rb_MyQy~;r
zLk{9f%uy`%(}#b$L&UNgI2);LS;v(|OtNZo!ta!_(O~zEYPXfu1r%RimDznNPIEgR
z+=(BJ+(efjI?X(^$;@SSFjdn)UwJf~RupR<8G!+^SUr%=)+9_?^w@gfl+Hm-bKG(G
z2il2TizuVbqbMd%q~Wa*iW8W*b(OeWQ$MfFsuYpO2#s#|+PzV^oAbray@u7z$0g5$
zWl53gz~ua3ms=x}qze`BRoxVX%uKjwe@GLV^V(o{h;*AyGn7h+7Sgn9{V%4v1yigq
z3Uy)QgTjD!Iu(<^F<hgdF^Dtja8Yb7ucz`vnr$c)I@dKvQC-pfA5XjSq$i_d;|14{
zdubs!j1#|p`iyBMmzaICK;HS>m{r#8?utXgey2uE4d*c>jWPKk%xfOAMxY$VFh&+L
z9D{r*Ke&{cV_ZSeI!c!i9n6fi<@Ax5yf4~qn)Nm_53bt2-7i+m3Z=&9wv?${t#R?}
zJ|rOXNX0Ua@72kiuFzi$IMA9mgLDZa^v~)p0K!f+LddfoNN<@WOL!1Hl`BcEr3nEp
zaB<u@eA>jOPbTHr7i^`=ByVoG`1sl@)f;HWh}15bnar@-exP>h)F@gz;z0%#!=x3A
zwS*g;E<0^T*;M69ONxdZ-3la}G6VFRi*S<$o01Je)B<Y=Yy&Rld!<XLlp(Zp&JB>;
zsdZ{%9NO9sfp`kR-JBb^KHQT1DZ(2Y6yB^{FUIEMvO-cC7Z^m_MstZ$)v{+wufJit
zz0|L}CF=UKRtfBmj?Z%1Kj}JkdHFr&*IG)FcUuGNIf!UwoH!dJBTuwP+yfpJ%`>lP
z$GTutEPzSTZ`x_~Vj}%HWKVcO;jz)hq+ssd(xe_Ejmp4lDEyPIL~pMwGVL=*0LUpi
zcOzavw902iOynhsHkN?Q<gU52=%Tba4gGBRrn*Jthh`U|;sD?tW{XD;HPan&CDMvv
zs(2?p3FOF(DQx<aE6o<1X*5)c_FRb3ASb+vdsC4CB{tqPb7Q7ydX5{CzGL#b3t{P|
zeg_6Mxf05>r?Zk}^2ChVne7@K6y<rx6rMQb-or1XWsy^=YK<6!tkPC6D^Mcf+iCsp
zT}3bGlf2V0SuA-jCTbRXU7X;YI0a!eLT#ltaWR;i9h5Oe#t~AnuEH)btl(UXc=4pT
z8J`bLGPxo{^!8j>P~)1-A;a2tRJR!2Fc%jO&6jpKiDAb&$}30(@pTd2&*ff$Or-r1
ze~TzeSwtm?1F`T5YAP5=z-SmONpaSq;WWydVk(%sS@ITitYlMkbRa@>ry@)RO_L2t
z-LoqOUe6uq&dC`lXc#;o!{XBG5v(m};}mXY((|PhlE0GHx`+zZXgzyC=G5Unm;<2R
zlsR^IZ2y%>Y73(8R%T{?p;XnL!_(B%v2slXZ!0>4IXLpapG&w%<3=I@e*<Z^^D$9U
zNuDB(z-=^9Wlos$i;omtBzMVxxJQp3{Y9?WMRk1^c3aSLvpVV9%rr~f&{W!}jbGnb
z{?|`FxbboI&c6&>T`&TE*ah#-K@6#}N|a!bq_OKbnxO<s%T2Qa3c*dVyE6GKWu%z_
zuf*Z^QuKvcq}`6t;3OQMhR-Q5M04r12sx8rM2ZDQ?%#&Qasr;f8g3r6XSpfE%y79j
zo+G4kt=Nt&`Z{*!^W_X)1#rg=v;9bx;n$5&WnzolfZHP$JDSLdxiSw;MlBg<IzNhb
z%bF2p@(+Gy1L$K)kqpG*R&>xKL?P~!d>ivu$@&x>bf$YBr!EgUKYDu!W@>u$-)XU$
z@P5JCCWdv%iIl=l)0}*b1K6l-T=-Uvdj-&#?{|Twr|X#ajP*E^6*Y%89e?2Q3eBnK
zHE0$Z_*1>bp-k`v7>r|2toPz^0)aLaWo#{GCul}5pmx~ftNf(%#(d}!uEqV+ua5OY
zg1s~R!a8~1>YAnixP1*ETh0lF5F1{9KxwS>fN-_4pTU7L5?wUiZJbym<?asR7mVbH
zg~}+za+r}JX-tb}nTl<iKbJ>8|JCV1VDPKH?yH^K2L4^<7F2UaO=+nTQgFF=HqbJn
zen)>T=pVR|{WhtGvs2J9+kpdFkcc|wdM3yiECYYY9D_*OSSYCqXjagW<Rrk1O?s9j
zZW)`Q$3%?q(}z%QAVlIT<t`g2APER6O76;{oRpJ>AEAlbNzf1R%?(i>&0PA!U!O$D
zdi@RS?X|4FID@ai-oCxGZfRNF!JyQxn#W#^z0vF1w4wJoq&>l=XCC(_2sku^2dFMz
zgwHyNjGp_^xt~!kmg&owMXI+%KV+&w3+8?p4At`{54m?kYJT3dp)|jtmUnOm3?gL=
zlyXBU@@1e(eNd*g8N;H>V;vd!1Q!pi994^zS-{)GRR-fJQkvGU+fDOa!<DIdKzaQX
zvj87s#6?aS2GA>LTH@s34L9Y!{bha@bMNykj?u-4I%ucpG-DC1b7TGpJQ=KiwL=Fk
zd2+r!DY#|_28CR5K>U<XAVO?4nkem9rfDS$o%9q1@d|B2L!5gh8A4=EZmDg1YZ{Y1
zT$vE7!|2-?#jrXf$guB5#(J6Fh@`sEi`a20*0YTKah0k~oT5-kac_Dqs%83>m@h2q
z%TOB=NSti6nXL9%4J|jnx~sIQrR55DaNcMZN1Q0dlCiFi4bAoR+oiRrH7T7ndZMBv
z<RiR5sBC^E8CAFln?#=FU4T<!zBssxfI|eK;BGjzjKv`|lf;4=I8<3({f3>Jct75f
zhKbX9fw&?M0V+!eCt4;0gxYq}l@XxAP@~94WRi>;P-*W7>~9t@G^FfDq)Jbeo{aQn
z#9@;5cs=Hyaww{K1+@oAAJ}fPaDW0u+d#%BhFxwY<2;4B>GJDV<N{!~Y*LlKMI9v#
zLVeBtIiGE8yh0vmKDYpYlD*vCJ}}X8hrFHGb1hBJUA;%+OS98cTMPPHHr)H;pZ)QN
z54$(@&-q)$$gRV7r>uDg+bq1Af^j|j+|G56(=>#TT>P0%+k|SesYq_0tL$6AdyoZZ
zrjMk`n^kW<ja4i~qQsFmtAdN5laNV7x-n0ajx7yt{TeO-A94uzLt_WMN$ylHEm}?^
zq$)TwWmFWR<bVL+p9kmiZS-)52oI)lyTG-@I8!>kcx6Wwoea@)Ia!v*@Pii4Ey1+<
z@xu&^pg-;wsU?mRT!wDN<Oy$kavhg4G?N=R@4|G%h%p3_kyjU0gaN&ki<9IEQYt3E
zJ!K*11*DqLXyZxoZ=3O%@^@9%_oZO8$jweJj12<E?k}dJ&PUI1@G)$9`j%25YA@#H
zbH6FxD*Q{klRg^~P}93&12w1N&#pCd{%|4kJTn1*|M=a%jIkxp&#QH$D+qi>Ym(v-
zT@;N<b^B0hwl%d$m0#j13NmnPNTpApPQzk`<+1nE8Ko^l=N{D!{Sf(u;yq5`lW?q{
zce0`7dU4BfxekvWJCK8prLqBGE+>xieh3#Yo|_2N2PWy|q7H~_TH^#G<tj2&86e=!
z$Hlc%RO3|nGf4OG$1a6nfYM$bObQcBO2h|6TJb_I@-e8<L?t6(FI6w#D!>_BBQ>)o
zc~m$P8MWcvg3J&Yp|eV#`012IdohUO{#BUMme;P02nmq4aMay8F3(<7Riz0?`5)bO
z|8IQ<Z(W(*bAfMvoGXW>9*swG`(gH1_doN|<;SucqBFO4zFKyn$deRI$C+2|{op?T
z1ThvS_r}P4w%NUO9HQq#Og%a+!v~A`^cTzPX>}0lPW>A5s+#gkjT@)Ru3#!1nqm97
zyUgG&wg87Et1&`v=LT}RgP}}Jav%;?kH}>&NMPd`%^EC44_$QU1qzJ@Bloqe%*_~z
zWs^psg%NNG>^YlB#5Pnxi~_-Q0YF5E9Ydn01Hn#0_edY6h<nc^9!jSgqA1i;t^A(_
zVuCINEs)ZcpKo?~<@QGIv#~QWK-2)R@LQp)`I`gj@P!P}kj^rOYNmXdBOL)ojhZ-U
zlrB1u72^JbZD_5zQyS+8;mV|~t>dnRz->YtGt-HGpayVv?415$<Ef2t4L`IG`pfrk
zHG3E=-gP!f37hHpT8ljRg<6^jLWu|EgN+D#&UlPhWvCsnea1@Y5FNZMh>L}b*h&PN
za2SSM06T?}<VUy<beJSu;0Qh-TGyq<oA<PQ|Ff0?p(Xfo+LEjc4312M$yckuX2wM*
z54?I{x5f2|!C+AYuuOoJ%EVxmW~e4xm(ySona4DZwUlo$N1mH>A-Yq(k`r11Zm2(n
zaX1IcQ`K}j|9B)V1hH2YzMKgoP9MxR2yfXpdCi`BZUsC1)A}WU{P@N<bATh5E4x|?
z)?V*(u;=F8+h^~sDgU0m6LOMTQ*1^3Cs^W+f3x$$Wyc<0Ui|v+zgzWJPv-b>eW#QS
z;Rx~aX{LT59bGavw>9pZt}Ym##vH+@A{2sUg%d@z16rCA&D-L>QhqyDS>G~{z=$vK
zN-vXfVw%k*Tsx^G_-{!b2AMlBCF6QVu@n)hBUkBuxqO<&y}(lqZcztoz;2`5zNf9q
zBZ9CO7CXtbMPHLkoOE6^_Zntkkq`PAu?ZGyjks-VAy6~OdUZMnBez_}ijA#NA|GDB
zx@9s~y~9875hpT|Yd|=ghKAP<GF=tWG04qp1Sk5J)m#<Sk4^UC?7`b=7#&*k0o7P&
zq)qM(A2q@oy3vC=h9^cdh8I@8!4wY+1L+7o++<wC)g=efotwVdz?3ArDhfd-0?){>
z+TXp@FnY;>{Y@Dpri0CE_WebZdpr=-2O*i%-c85nOCeCH^Z2+yHfl4u?tmJCO>iUC
zc1CJYIx;G4vlsZaIH;*R2dK<wW{TRVq%J;W)7Y1OvGA?yE5=<9`1p(7ADiQ+ndO)j
z3?e28QZXXGQ|VQ#P{b&3y#Mh*5S(;OY{44J%$U@EawDdQR|t3F6Z%Wo5x;RglF~xW
zV8XUkLRB<-lFGnak^q9f*|3m9MLs6aBxanT9w|pj?x;|lF4-)64z-m$&pdPBqmL#h
z$A<)5``t?eKZ*bLk}a=)fxSDLoc_OE0GZx%1NBEAg~|=ojc?dzhL>i~l44XYtQ?*2
ztK$Q^JFh+eb$PF)Uw`%4>F;f;_NO@JtO(x`8L@-Up6Z315JxzULOVu!NQMTZ2KmZp
z5r67vD5s=6Mg#Mw6LKWEP=~l1kob1g7{{*FWA7Lq0p*SXB$TIym>=7Q#FIwHLUI)|
zJlq&a4`r?cDvmyfGAnPwCbBOtfX<nSpX$LRFWB;42+#};><_%$O@}a#?1?y<bK6Qq
zDWA=A=0H@w-9S7s&M23!GYNRi>$L<TEtx-FcoTlIq*cthrI|?+Wq!1c!-SI3z~yOt
zhssF7V;4D0rkZqLAqwXh;;2P<6SLhC#+<KCiu>@`;B6Xr=RzTZq{>4zkXkHb@XZ6n
z@P|T%QJWbtfnQ;=$KkfhshNUsp<_FLvG1bep=I;uR{bZ!z(3vCLLMat_638g;xaln
zRKh?TDW(bZ$;?1<WwNb;TQa7A5ygj-J9q#;9l=i&X0_)(C{~Zmc>bG94~;B?_a1k7
z)VL06P4<t(Bt@r?(V!DKQN@cMTV<IHP=0;rq%>(YVK#&7hcW>~N)G;DGr(hNh4M3*
z%Qrb`Ys2!92!$@!WS77tFdDR7oKN0dau2P1bXi0-h7mw6TOQ@G6b};g>Urr_3csky
zH{h;=YEIeLS`L2n(WzG-`OI<S#*Is_T>WTnOygvrZg#q>wPi8)=$X0l@wS%3-{;&t
z&r$K3!*^HDjn&^?qRtGn#FcP|Dj_Rv{EMI6v~9TSnJeofGuL-|R_`0N(-iH&O`+~!
za|~6vSU<*ab9ht9LtG50H!+|eVk+St7o^U}*pWhWhvP+WiS-PZ2lccGP^-|5G8!U=
zm_?L@xRlab2TjTiWr<j%1<Ot*{cAPGIfzjN(n{J|VJI)o7^~D_8ZyK@180QYKu}_z
z0)7@CGJ#!$7*0&2qNsKlSCa_`=kR{;0<<Xf0n;?3t<=ceu-MFnmn%uBOSxr|i3SvW
zgj9eH7Mj52<%)x^eanh)Vp;-C_~;RG^$LirAG#<H#(*R<+WPy8b)>)CEGKtEhPzb1
zLz8%Bb5N{UWXDjQ!rO$JIHxgF!*NaTtdbqLu&kMT^QcVn#%}$%w&?K__2=GNv0^;k
zi>t42$td2&O%o_ugFp;v0h}W88evcA!=oeAEM#QDh)>TxKKTFzCij(*C{$>Omw*I4
z%m)F!`!G@xQY4L?(Xae)pH_Y2!|Ia@UaemsgWckM&8eeYhKmHq0CrSt68J)B<2bUH
z*T)`^B9mjBmY)&gMo}UX$bUs%j@D~uc+EPCSMf7Kt8mq?&^2=Jv0!f%zS8m+P>tS^
z@pv`nV+YV9<}!vj<t|HL4|Y5o7ShX=8!Z*>xcAMkzs}-%G$G^V_>mhTql&J?aB#Jz
zL>1+{!C%||?+BbPB>B&bk7|DvefQeBpIz$;$oboqmQ(fhF%SOCcVOLszulWWB20I8
z6$(vRG(J-lW>4JSWgGfpG!`iRY`F4jtgD-8?<!DBjWHf}!N4#R2B<-{;3rH`+YMPz
zrE(;ZEM=C^8WicNRCZKI-=!mM6*$f~Up(?uqjL<%Lhq!tD2Qn1^cvp%TCPF$cNXVQ
zTm1Tn7wO||KOD5jnj0EM&&gm4%5b39#@^ro=3jT>$w^f<1p5cnR(ua=+kW`6htF6m
z^`n%9d~;EMFyn~nC%31=D+`9ogE10Wg29;2IKmJu0996u&78#futRjC6nk=+0msa>
zgNYWs$U}L0C}QqwvWhqq5iAIfZEK&kMvFwku78Rt3j*Dmq$`xm6_{VAKj>7FgR&dH
zTlN=Y$B~C#Ttqc!ANAyYck_`D3W$UfV+WP(93%_SxEvuh4mAp^J^i>PN)BFbxsf&q
z_RCAk@wXIRH9baQK;#xu&O|yW1jzj}kGhh-l^p)+R~wcOQ5Q}NCI%~W^oaah4po5?
zpb)Hh>uw6e0T7Y5FLr<_va3M$5n>`jlT$o!r0f)hE42Vz0I!7vAbhrr6-d#j2ocvY
ztTg0!lDjDVok@ni0sbNf-v#aOV0wXX1PF#8keXCVI66Pcl}C=8sINCxR8)uq8&7cj
zqierEiQN?^m|SbU;d*0L4;1-7Lh=#?SZed@s-JAD>$|1vsjg33y39Lk%Fn#<_Isli
z^}3n%!sbGKd0)glo4Jmc<p*vhNxUa{k9({&3~bjlS&4Iqq8h@shOWUhte#m;{+D+$
zgePehVF>C-xgEo{RHW@rKzE5)S)y`p)|M0;k&(WG>5F@rLfnY)Choy)bDHL5s>e;V
zUgIi-x26RHI^;bAV~ntb$rf&<0T_R^GMxK|1^ytINm9H9QN~0CKNw<M4YZ`fwDl}o
zG%*1?nA$WWCUKoULgS)y$cx4NbS806$o<s}?O5rC(uE^*t-{!nwk^yBi?cULFdhpE
z8i>Fe^yrBq-Vv}L6hSGysYFh4tMm}661~Nc_)|ROU(z>nHF}MCsH2Wt-4}Q!e8$q7
ztGI6H4}XXv--T~C!0jCv<RaYg#1`|8Vk*b<iEa#wamox*cG&1QVr^$QOEAjhMht32
zE;t5xz#0?K^h%KCai%~FJ_kf0jhED&&$)TN<F%G+uhBbG4NJebHebtWC*z3E6;y6J
zmnW<UoFK5D<ccs<IB2n87hVPVpNO!9=psh(nff4;_5id|9s%n|=;GK%Q;K9E&f8#1
zh{7FEDnjXq=vMAM<rhFI`Jz$S4{=;dKr6j>y+cH{XEP`j1%>b5pLqWJb(TZtgh~DV
zD_7?onekm7n7;9iy44u|{j>*$+}>5*_vF*BymGN??2Me7-)om%yY@TUJ#oQMDNyG>
z{5tO1{YRVL`F%bm=YX?gdeu0hxUHJVMG+(jS#t|aM)Y8hLdV(A5A|*URs-r!p$&(~
z*z&AMT|EsRc|okLhQ5hrk;peIhOG&uSr!^Wn}~KvvbT5y^Nc#QRS~!W2GJbUB2zfL
z_&{z?KoWiHgp$o(bK`o}T2xcxAraXh@QoXX@l!k)6Gx_ekyfJdw=lRik{*I6xF?3<
zHH^h}Xlp{FX7PDzj73-G0_JP##s5-@rW(IGlUPCyjhRrGx(Bj$9=9Z5RszI!uaF5p
zT|M9%;!t=Vx-|`4G39@JLqvdHTf^v%p^7g}=*47QUPJxoMfK5{uWs0Td6K=UsmZ-~
zF?PZAuro>ICj6iR1kKBEZplJy<TECz@(aN$Ts8MJ6`_-o9{GR&{9d^R?^8Y})Hb>q
zN;;v5OCwh1PTFw4jPzuGSGKj`rR7&%`tH!X4@>_{G_Sl70n*|;vFjXxg)9YI6Dkva
zfD=I?*h_}P;SyymO)vg|s(cU)nP78~ztUxqb_*g6;-1ui3<XX~kxk@y$<3s2?6HIc
zzcRn4HkA7WNcM0FoKM1FDb3?S!8o%j&=E3Fe`Ll1|CNu7(H}guv@Ac=J=1*gXsoB>
zy`SIw{(Qi56qL8OjlW&A`YbA1&+{~FO1@z~{J9=|xa%j&elt1l<j>D1tS|d)VBNX;
zpEO+gEOtb|8l)7++MLvyQj$w?h{s4x4C@N6Gv;q5pYc{WZFq@XhyE3k6npOE3ocv;
zL_C+3bj-1e`JJLeA`g=48q0))3M#xN7Tq5b<f8Zp!HC4o(u0$^jlf)LcFW)>KXUAm
zB$HF`bdD*C<%TH!(cBolS<DcEk-wP0<hjLMXh~ub5YB(i77AYecx`z;bDk(%e|+48
zLRB)hh|^>X(WL0B#c!+eX4SCOK-o*mi|uQUaE+*?NoYd86+OxtlkQlA2BLS*(bkw<
zG}zoD>3S~MZW7;Q=@ao`*rRA}<=XGdwQr36<F41gKK;GX{m52mt50X|=fIWEB1NBp
zi;;m509FEyE-lSGn&x?h?zaX&c=!cUFcUOl@>FVrTvNA~k_P4<&OlyRv*>V=h2pBK
zp|LAu+_k0S9+kbPcvT^*MP5R!Lof+f!?{j*z-*-mSIG6M3Sy4o0k`}?;~O0OOUn^{
z_$fTmSPMv3SJ9}6^zjf($P$Z?{i+)jIDR;ANJGz6H`E#9`9f}N0($_`?Xv=CMvFW|
z7C~So7BY*AXGJis`P)UGE;`(rDYmN#B`RvWCV8}u_m=$sh3)k275HgSviQVdMd~1`
zK%VcLYjy8--T&Cjf4<s&G{0_Xn8i0SskHzzsZ(_w(d{|EIMp$0-`~%h``FvJ{@M{&
znDx#36s50JUwftFr_X->Qze<)_m`#%7jUip&9#TYlhicWKL-On{X{Te2_m=1jM#=&
zv6K%BDxfhrapcxEgzsEQth^?;tCC}oY%%|yN0)bfmb2;V-}haejmAMp8S2*VrKY0(
zYfG*V{G_eCp<_<K#{O@Hx~Xa!Ps#s$cS}>Ma#@sNWB&>IJ9y>4{LKG2YG6b&;WpD;
zM~~avFG+eRty|5xHQCZQ$(1lLskJ51)iusGGk)oBeS=zCjyW1n;0UbV!NuyE7dv8}
z{VwKG_T^$(N)YegUVChBKkuir)&528C;}g897|!O_%b=BITlEL%iiYj|Iue*sUe@#
zy!_Fw!}ZS}Vanyhn?GFa{B7pV|5*OFM|0LO^{0yU54MIfR(8FQRkL@m2-1pt4>-J?
z?;p@LEG2iT{{=K_+}PFO<oK(8J*y{`ZU0sG-~Xcf0DFbo-y!F_@6bmdWp&@Xue$qX
zO&N@|$E~fyWvu_3^1gYsrP))GS~KlMR|eU)yl(IQo<8zwr{?PFCGp@}e`@In-)2vD
zip3XN7m(Vu;edRao1TtKGrPac+;aZqz2{r!W&SYlNM~DxWO}Lqq1=`5<VLe-%~j{J
zCy}eefOzLbVt)y<<5~Kbz3+e5Kc~Ha*Ed(Y??;lG^Xr=uw%I787&Y+K@_DLPWY27C
zIcAK<R(RPnSXxBZutME~<TstyFio3XkyDg4bNczroQE}>Odh-g#4f0M|NT?dpL~Bl
zvri2sKgD)h_qYl6wC9(~p|#I!!E~-M)s@g62P&uQsF^#mG7~R7)>^%hv54%CJ>A6(
zIfE*$eA3l8=*P^@uO%Y8CzAy_?yJHDqp7X)$RAclW}n#bYU+=>zkR*q?OqQTj#}{f
zbAN3bL9>beDi2OUAcJ>&aJjLQG$XZ;7#XB$|Ibf{;l^_1^UarmSYQ6AG28gq%csk(
ze^`BEtgN0;I}G3%HWI@*<4`}sB>4W|*>d7&d{4LpG!rBmZo12?7m?H<>ZHJp3+9cD
z<6mrOYD@XQWD)<Cq1`ox9mD@9-dNSf7)TWf8=+FW^XqzB?K2I$pB7g_NuBR$i*G_}
z%dgvxY|JUD>xk;UDgo5OrdgW}<;_^bDL&i255JNBZ(LsPi*<OHCGyb|#&NhTyQ?(&
zZBx6ab=>PE*<mKFC?~h%`h%9Zjmr}4TT~YOX0VPMhiiDIqgKu;T?k{oT7Z?ClR1CX
z<sfuF_>c@fw58Z`Pjw8+J#~jm=oU}y%yhLLDTGbvRSE~P&+O(*XVJS>+a*JGMA^Fo
z>4;F%wr_PFjkoyTX*z0dD_EO-e{1F^JfQC(^c>gw#B8ak%ZVk)OYeu~gr!m3M3Amk
z$|k8^X|T>T7cD?#&^Y(UF8z>fYoxuq%%9-;^N9U(HT8^zr$&|cD%B`Q-0C6afwU?f
zTn0lxsPf$f;z~-bS~f-BAistN@pN?Yym4#TM7O`nNqf_$m0sV#-0<4E)e}`z_fm<r
ztVA<trlOpmq$b2gwI|ry^Md>@T$U{7t-9V(-9PbcS-otQeaq_WEt81;oO`6h1tC_0
zg%@Xi#e$KtMaf!#Dt;3;ln3=$Wccmc!DYGj?qUj8r>m>CY+pV@`ISdo%V`>7QyS#t
zUTL0*w{%muB)Y2joB!)7%1>%a=*3S=iLSXV`}y<VR`-3=mm;A_MEVym!CR6Y#qm}m
zTAL2;gC&yqeNI4om#b^5yW`c3{gYYrUv8<$wifwD%Fho-rKg6kM(^1jX>Eb~m&J5+
zH6@fSTP_>QT3Si+Et7?QNp_iDXKhbn@nq3nGB>`#qTNWPrRSg^Q)@^0t31$*@z)OO
z8akqbB7sQ~kN&JEQ7Vg9ovg3mEmiSyXWjk?>u!1HyQ}u1oFe;7bL!Ej<#Cp>cnO1}
z+V3mP{zHCU07Hg0mZl{8e(vew91ns5>0Vvr8`G8oGgjEYK(h9OaBN+J!+ejl<;o|M
zU_Y=dX6ZN<iY1B(u(qd3Zn##K9iwvxY`l@0P)2`*OSlN=gtE@_Vf;-PCsF?-mXY`P
zBlU$kqEF-BM@VF9u)ktVBEkuxwc^U7`lomu|9oI^_hH37Gwp=%9d_f`sh!UbnmPSe
z-enav^`NuVF~H$;#Q(T`qS~(lP`mGyCCQx7^;A<r|BgHob$i_YWsfxEgc1zhD++s+
zUXP2x;g~jGn|#<U;C4$RX>-d74M!i=>&R9p0=2|!OgVh{>+Z|yNj29|xWU$(@SY&`
zCmNLVWE%f^8smkJ>WI!A{{LBBdDxDtP(_rrcX(Rgd+D8z!C@v#yOlJ#^j{v<lhpbU
z_T@oESFCavs~wd0!PdGQJxBKS$L4j|;^PWIZ$3-KmDwbgE91Kw3H{b_g`8nC=Q`r@
znNV@fm>+5GGna5q8FXuXdoqjvw|(r4>0W9CUgg|FMBB`kxO`wo%*+ScGAHTHnhIx1
zC0S3EeT+^NTdZlQdrO6(O5TIos>>X@w!pq_PS86%>Jv93(>tGy?%u1G(MsN_3n-++
z%pvk)r%N^~!OPO-1oAQB%<M2D7dv&IUz;7~4`7IerD1VvPW5(ocaW+%jrkTtVgDqK
zGVGK)JVtJnl68!gi0nv{Pb#@q8L!DceujnJQgN!9(=640lD8y+Y{nK{na>N#v~i$t
zKxzOB*7VkaLMP0He_7+?o>1O0nTVFGCvpXM$5ljDN1xL-+%}kf&$7IOSeyPu_AO=E
zQ+ObOGLEQry{V`d&_cY2*vt~^abu#$CvpnN8f)!&uC6!ccIY>fD328OujiEESAk~V
zQi<r7gl5T!0CuR?h|^+Qd5E`eRFFpQZG1zPi&OGJb=VN!J%16mhHo6j%jINNFsADy
zdC4CK)U&7={cEeXZ)ISFOo%#pY+hVbf|sSvJ$3M3GFX?WpL2Q#d2Z`b@ps?qU*~|c
zon23*CiLQI``CHd>|Fbn6!Lq~g1(kMR+Y2DNTRn+hCE5dF|952tl><p{g`a&F4@v~
zO-Hr1aa#mjZ5G`5erfh26uHYdKh#6Y#@)gbaFAHM8ku@^k_z5sR)2b<S{lsht>S6|
z_*P&w7ANGrTL)0VS{3D#VLY}r!5`$LvC6=WS7LgCK(_k9pm?7w{_St(dRe!->p_{h
z>RD=3A@bmyY1bG`No{Rb*_x$~)03Iy$w@ILITXvXpOFHrx`65n96_iTlC@dp-q!9L
zyg6C($*tpx`9lt6NnE#{IialQ#OZ-Vx8lF;NNR%j`Wu6JQhq>hdE|a|y%+G!{c)oC
z-&6<F(2+HSJ%FW2FEC2>bWhMj&J*l91L@tv!YN$U5eEm+J^W7ZpgVK>cUxfq-&C2D
z2;hFS7&($bi)!gP$hK@K$<_fF8I<HRv7Xgd&Z#S(`J)^p_E}qCysur#(W_Q+T22Tj
z+>ej<Byc&8bS3JTl4IxJR=u^{;N>XxWeW~XBz;R|d#&vHgZ?bIoD|^C{Ot0^H~a~V
zr)P(=xKJ8AeD0~<FysU}?;~L~IXsUgfAJ1m{E3GLs#~jQUa^%~VX)Of|1-<uvg!we
zWUKpF?->e8&SVSP_(&i8IWtv2XU{{kwMP|lLT|PG+v2K#u9V|h!QD%b>CG&>9FG*$
z9a>u^cC}KNBn;$%10`(^VIy2>B!|hPvT0>?6CM<1Q}*)On!8C3QgZQoP{*yU9dr@g
zEeNb~S(r((-JJq_`R=ZPRynZ(&Hfer$0KrZ^yF~%vnrHGV=awcPY6!#+`sJpwsBht
z@+TfHlK_mYk!MloOLojG!5iAGBo<lI^%N(<_4lGk0xDPLNK&jW@&n`iQ=@*=gEk~N
zEtjVW^5`b?B<P-}Bl`U-n8{;Rzix1l^X`zPuTJfJEUNo860v`)HpU1}Uz>e*YC?r1
zYfu*8W0Rsv1V!rDPB|k5M)nyD+NJheP{t$r?ia*yMsn7(Fw_6~ggt<eYgTTpXUDiV
zw36&c{6&+A+H#^la(|?eux=f?oVfx2%s%YShJN}G%@qFxD>TWg({ySHc>&66S7Nj`
zmCo&tA|DUQCX+U6`#tuV9KeEm1)me5l8zf~@}RZ<gp>ZymtzGG`4a1@*VlE->v(pq
zLK+DVf;sl-RYf<2AimL@;Kk=t^8-kYOe(p^zr+HtSa25g8dd?E^N;ZQI%MYuwl25C
zt@9_eH1^}QGWkkLxsq;lw^mTUhHV<1dupDAUJ!*G327wRD2{rd<xzDw-JvE}`p$RN
zYXHrxWnIVMEt3-}O0w^k->^Z`6yzYfX7Fj2hOuw%;?saRI>A<h+n?pjc*HFOZ{;1|
zaQW-I<gZ^k2)tZcMitBcOJSusbIGL~IzZunM6&t~u%h}G{(zx~lwg)4KIbQVS3#UT
zySe9ydv+*NYZ8$GC9ZpE`K@G3u|3IqgmwgA8Zg_`*8IP6Ug_zb10RJ#n;GB!-XN~B
zQfn)H$H^)ql6wD9Gf-7)mN=UqEc;&eSGBoP?JWnGC6q|%a8NMEgY1s>%n7ZXl<w->
z?IoG0dyr*Ab8E0a&8X**<(^md!7-{ta&f2|C@nREWa3WpQ{(FtOpk#&{JVXgKu8Id
zo`kFC%_^E%GE`fz&ZzOAlt?E@OgaM?NMGSgzSBm2Z)#_s!CS_)Z|4N&4n-a}A*Z!j
zg?D32&$B<NAeg_5$QiU`9EGmrmRx}ry}}w#wRLhX5D`4&{cW9+x^g`;wT`RN#6nIl
z*$WdOCDhB2b4bOu6ufIxjB5%$`U9E7EKyA^RWMXhY1F{}7a=?0dYu1XsNf0l{_A1n
z-`+ewye5y1=~C6QnYZ>n=Tg_Z1j0=79kExzuXEzr+^sE>>8r^vp5!#T^?xJ|+3IAr
zdq``<|7sT~#4G_GESS4*p>H&Bm=l=_@qU33{g;gM7a730YZQVUr+|@a?+05?NrF;~
zscI|oTc#~{_&!dbe{KlK3@H}|`k@#<pr1;6Tl#?XW&8O|q&BVR1*k%b$meZzIQjE6
z|JVsj3pDCG`77BQ9j}t#8)ItjTwFczk!g3=8#aJ9oSvsOlL$ztU=uL+gW9B1GTy(!
zP$~En8WTJcNom6KWk2JHgOviOLP`0<0mcKu=Mi~NiUEBis-3h){S-jK%t0-9lDAN>
z_JfAI|1AqHv+@^IA+so1d1%P8f4qR|G8mDZ(4vzbGP*j(Zk^KPIgYLka+FyiIsL!%
zIrQN6J0$uiZa%v0yKxkTf<k2v@Y*@bC=W^aiE2x$&CeNLEE%4UQtf1~W+qZE`2L$D
zMeX#eDmzR)g{2^`O!v&u?Z;eQkpe{_;tK1k-=Y*#i%J>*qm6uO#w>r<r@;0ver2G>
zx$f?*#rL5(G+e7;?vG?c?_W+nq1B3EDrP1h1K0uBg)8{C+T$NVFPR@q>XiUE=HU3_
zZGcekz;pTf?e2Ons(Vi10-S~U0YrXhso*e4{R)l6348OZR9o`sDONCX^@{6P=gf@Y
zJvAi^R58zcm;pUQvCzE~iBkJ}6pwW|!4f5uL#ndi$-f!QlkMZ|s=50KX+u2a&wo;w
zu$=OZBq}=IizXdN^1m|P-((=vx+(zZ@|VX1eG4(9%8g;5ZDAn&NiRkRU&BA5yk4sg
zJ{G8L+)Ca=(CtmNZ&oLMIc{BccU|=cD(swlNpS?gBV@rVkEv>rDvSg`rLP#VTkGHA
zgh%zA0zIo$y)tX{6?N9zI0`z+e!L;(B#M0L_AQ^@-8f$@xc2YQTCmoC^0S2rRY(%4
z-FW)7sYgvcJ6=3hIQbukmsmZlp*OA2gbGzy-a6c)RFpT`)qi|`blPz&NFmbxypr3N
zUERL7zZ>Xck;zL$W&jIM4p(7K-irf&E0%$$Uky_3FKZ9fRvFKK@;xEth`-!g8s=#H
zlvmN1A|+?bV+rFV<E!0HEG%m}Y64`n-&dtcdfL#e*Zy(pQ$zSHf?Fs-0RsW4Zh1so
z`@m$J00o{Ok+VNg3UDe9Ni5IEH)!ZRSYjEAbQRV!{_PF$B96M%KjCvU9i7TX`1x(g
z-Rk^b`y%+5GwpKN^An^lcn?)OIY9P%FSBoCPX(gcXCg>}Xka-x(ON#Ckl(VpC%@fQ
zl|4l;02udF^;<$jaN-$TkEC{0P^hYRG?}fQP@ztFe~RV}P$lOS-AdU!x?0|x1l}}E
z$CdFMFNG@S@uBpo37J*d4wc*muL^PI&-Z?e$Ezae_e8)y|HFIvUv_-+?yjwaNk%Hm
zEf?;<Dg1)a_CgoR2M{7JQ;JD{q<`sY?<yzBKk3ohJ?yP)_2il3TdND@y$ljSbP^B|
zYTa^*z?tVD`EVY!1`B^FYs`^F0Q+N|v+9z)5`5wtt;#Tka$rl<iPH5U(H>wT2l9`J
zECu5mIxKF@Nfsf)r&5)*l^ZtZga*;fscF0I^wBT7hXLxOn#FK#OCPF_gn_I#xlJbr
z7K|*7+*{Sjzhrdw>+3v2nVe!PhX3=womZp&ZBHA`8aaohl}&BnY5(z@M_sbKy-GQg
z_zD1<*759M2_j)INTF+cDxwHUcv9c+fMjz&Zc+c~e2J$T$G5y~=>CVVc6V2tm9m$&
z-^t#ntIo@Is0EzKy)RVFg3lXY2d4Fw^-B?!Gw0r-EAD_om7^By*Wr5AvzA92a_*DT
zEYgozeM=;TkBsD1lT0*emdHBEsibl?jHP^DHY*$-yVA?kZRgmKR)G{LGn4(Wl{~RY
zxO%=3uZQ*SQk;Pm2mTs$E(OKI7L-YyG77pN9n5z73xIu3Pw#%BZ(|GuihmVX`=6@7
z+&D?n4)8cTN=`+CB%Q}Ny18$!aXwYdNg`#&EIw~zZCiO=$AbTPAg^v{J5sn{R2;j9
zSoO!FP?QO>eCmPY2I$(BkxSo@aApf0Rgpvcm&PGVaWW=jaLuZStX|!NvP|*5hYTBU
zn|Am8{n-g${#VX}M7gAp*ZmPFpP#+H+R3i*Eu#n4ktREZoT+{$*!(U>V@lWJ)UL5=
ziPVCZV>i4EeIZdQ%X7tF=iTk@e#fOAptC;@qO~&0B%Ly-?$3l$Ax0We1{gG{3*_MK
zS(uI_{`FP9M|Bws#c}|cZd(;Up_|^lVQu!u{#vy0_3Zx^W&_>`%CW1b1JKo5-cmIH
zhLzRg<@NTl*6{fgG98WMTgR11x(JYTA*WggAx2UQ1+C?P(kwtgc0GmBQ{K*NVQv7%
zNzY8MS9x7;yS(+r*RO8?jvghoK(Tgg9q;WtPl5XokNqCCJh61!=Jn6MZ}EPSGor{B
z&UcWrUKu@gMal_7J!7!=u7cWW6gXRThC%?g%bLp{CK}|GKVe}T>5F_XSSW&_HWXD%
zjWBK#V^Ey)tLi!i!6|i}ho!pSKb5Y4#Wx1P?0dO2CA#~S!koxEOt(iGp19e|0*}?d
z_=7)p3MT^DFr&_wCg;a6!B8z}T~`OgUNIYz%QnCMp0$0etLvo_98S0q=MIlLF!zi9
z@;zYjrOFX92q%;e{(MAMh)}w}HD`>nO-Y%1r{r=zY{vJ#b+B!;43fJVqxSuMYs1mq
z9^B)M6*+-Rf4llvSEGAoxZ{8Q;SS%5@?UmWkMupEx=e!O)0?|qKiJu4R>!N&UA@@x
zG_@RYmWp2SaT`0&k09@?u7@V^>DyZBZ+m8c?=#l=W;=WZ4b=@@=i@a8RLFn$rZ{|w
z4ZgV!pRw&ov%4en7}ZA3u!{c2sKh%eJD(Uyg_<(IBdPi5aZk5`ss*F^%w2J+W8Ml%
zF<$~-b#$tOU9qgGYuLssjko>LKmTpc$UNUXIFyQ<+#_30^`6%e7vDI)J8R9U)pc!|
zCyqYdaMQEz@BPdDox_fZc=-|4rMiwwp32V0W~~4!(TN#Vt{NxQ$EJ>>4b@wh&GJ+V
zHFB_4%7uuE{%iS@nWg{~2$i+QNZ}L`MT_8X^ncp+q!iZUHgvu}>JINd%>Y^0`38I0
zEnnOnBH&c>bO*LAcRca102IYe{D_a&@vOUs(-d8PZCgtnKMXu$Z0J2l8o8qyxB4|A
zr&c#mkDo#SvF21j1ovhz5E5YIS-S)4+d5?lY;!tZjnH^2x{kab#Y->Sm)uq`s_|q(
zT*om=wA<s)eSdFsewp)=0C<qr%##Q`XFC%fjI`f>Fp-moG(V?zQUBw{qMWs%mc~!L
zm5HsL@m3FMGQ^~DN_MwMm7O_Ts*TrAtxjtl2h&4|u^Pm^jC0W8o6?ptj|YK6jbR1k
z4aVi8-OyNUP5RUvS)(*7*daTYZ+pM7u6pIIpOoqD9uCvw*Ns60S1fbzEoR16T$y#J
z4RaAW1Zvd<Bds&1JJ@Fd@EyAL?IQpY`wQv<BFyR!kMWqF$g>mxT-9S_st+PKGV^3x
zOGBH$@%Y9V5vcGB-$-Cq%SkG|4p|iW<efxr0JxFhMcGwH4PCuir_EYX*D=f41U0Z`
zIH#a7Umitk0#}Wbkn4p8YW1&)oh_fX6&&Evj}ma5eP-Xb3H7T#kJG*Bi{ho|LJD)@
zSc}y<9rDO|{^tr70qt<LPUZ5$G#08?d=*XD0C~LG@+n^Bc{fliz{P-4>wHg2c@XRQ
zF(-hCKw2gUMOJd1jTz(FvZ5}>+;MdtE2$o`b3bK3Gr7VF`#Gs+8MX|BF7ho2@eZeD
zwOUtMP`7jhKQb&rgY+I~%!lXn#W?zawa`*T^emaDt+}B?_Wm*{J!i?oKY9DU+pqpy
zt$)+^B{Me5{un*5_VD?cpY3`4-KO9D?n`twfBbyx)ju-T?A5hj@<&SVIsUgX&{((n
z^Cnu(JTik-{_r_M;@&t+J`v4i$E=R~EWSa%+IM+Z#WQ+$gz=lB9aFlao1wd%+(Ufn
z*$5-PT%@c1Z_>i*zPz!2T2n$F;Nh|<$J&;;x;98|P#f}ydL_IC|MEi(RfHbCd*6|^
z0U}GAfAB|Ww)(vEyPpsK<!=YX`<C&h{CnuiY!7wo$SM%V`h9<4!f>vmeu-e<IBA5U
zXX3>GTQOIB;b*UhzIb5fd;7U9z5lNz<{;?Ej|=XUX)@PPJ{f5rmt^No**xac4?q6P
zhwb&xcExx+o^QLlKF#cUsO4{yTaNF2|M$UKgqa+oHhCNY6jC_sUt=hiAUh%ZLKk9E
z@#YWcZx*bUinFbm5(@rvNn68@K5iZMu|<n~<m)q!6bw%ILr~W%|8IM59@g}gz7Ky8
z1ubIS(V}3hmRgsfjGz*Tooa3Cv`oioX<a}?rL7<!DnuYbt)fLmr4|tdt7C2JSCKjj
z$PyHgB1>#-1qBIvRFotH2qD{hKPNi1-xvM;-s^h*oVlhh2+7I$ob#;reLu{%MC&sp
zw(-UNVna-=A+1RgT@tRW1=7IN<kF8v4og;)j7D7#9}R|fBs(n38lxDuj&2mTw5GLn
zbcl9KNXZVTPH0V_BUE$DE6Q1_@st+I%|<zzt4Jr!{Q~R|Ppu9@rp8?#jp9r{>y>ug
zpt|<Qb*YQI9)8FfjB>M=P(4CeX?>?r=LWO^PVX%2azXB|Q}c$0biN(3*FG-Jmbf{C
zRw7sOfD2^!OlslH(rm9b#6Rz(E_|~^8fy>usSUKvRB^)X{N9uN#?A+BxvqTeM!qal
z+?J^!Xr!T$Z|Wy2MR0D776U@41CdVdh_=X7;7t6@rl>U0MOV)=4Q<!nlN(pmZmwDp
zYXwV!P7$?|tS$^dl^-&sI67A7pg4LzD)c_~`0;d3jNOhW5%LC6vI4C^+~7HbE@wvc
zRQ-hG3PWR6E-iv@Fq5;3M+B3O4Zj@OP%b@8rOy%=E$SjOr}iN%^0uI??z`(nnGsPQ
z`^S4;x4r{`*Y)SKzln&9i&z;I6))^PB}DHw$?MT7UehRl^(Y8g?{U^=IJf9BiV^j5
zwEZwb9J4|z;W!RjT_{F`upXC&*?fjrskjLLz?@-fF`%$mrKCTqb*8oCB);u?zkAK7
z3KQmR$qHPq=!&Z7>A1Ioo0#31tw@cUv-#o3D!-`dq)Fi2IMMsi89~bw!Gm{wifr~c
zT%)aT-03!fD}a$m9*mBUYf6Rau&?N&c5Rc;6d*{U?Y16+-F9FfL9v>nL)C9gY*Ngf
zq?YE=L{6aI;{&@Y*#?{@!>F`%y^Q57L@7j9h4Owma98kwJ1ZowBcg_zqM-VCxnv{-
zRnLSQsiprhrgiG^@;w11`@@8eAD^8}ILXcjx5^cE=ZA(Eu7|w0zBJ8HnueUTB*D39
zW`bxil(yB|ll6BvxDz;hZ1M~`^}LlhMd=h;+=FF@c_%Yc09XvF1J(dTA<iLZYcaho
zANhCvo?J0ctnrYHNC{+(&HbW=zB3Fn^(5BL7x1kc<%Kqbyc<S%AKbTZfHo&m-OnG8
z*-B@#+8GQBLGvrThKa(CQv?;A0@2H+MDGWQB7m-)3jk<ffds`9JK>(P%9(eDA`s3u
z#VYV2*m+c${@8lf*suzSN3m}heCufbkKu|+O@p&(6_`VFBHG8%re~6~UPx^$z!-5`
z526-=)ERLj05Rxf_wd%D6buKA!*4n1@V(U1KnR5$RdhaB!c`M*LcLhp8DA^bKVI|N
ziYoQe^sc+P*VpI1rj080jb3PK_AwoSbuGX~%i=O{6M?ayTbY4AloSKO3~fgw(`mac
zP`QiAfr!|wE{H~>I4GhDe71b`OhuQ!xofUK(3oKENr-fRUhuLIrQcP44^R8;N{Y%(
zYQlhAZ!o}9h$P!0b{7~Q_$U%_-FtS0^t|oVaUiariV(SRLPG;iyHCTN^3@roZFzNV
z>Yo>R9|BMpW96Ww(F9wZt}7H8-dc)8cdd7t=IxM95R4iFCEbCMH+MLdV*|=m!};pQ
zYL$mX<6(f+noKSX2kUAZw4cHX?LAcU)73Ahm!5L!`i%RgY%<MTx<2aqXo4xHYv!dF
z?(?YoS>04}2ZSp4>PE7DS(-{uXfYi2h}=<i1}ZQKQME!<=NaKX6h3r^{de9v;}b5G
z_nwnC4oirf;~|fB)98-ry;^4`tQsdjrZ={Rm|lY>XLV!ty~rl}-14&AX`Egk#lY3F
z$F!x%6|I~BpUgV5u6L8ueOw>1>$9}_TSDWAZmm|7oFp3Ct}T%m7EMc9#MOotK6x1j
zz8@ZJbAqTmz^O1^+Ot?iTW04lLzOAfdl>NA_EAwu=n#cR7EN@zx<0>k{l<Hnt6tgT
z;`QKNfk~avL~3t%zPy#3lX~|e)sN}DUo6L-5xXoWr;LR2L(JVFVah!1>hL?!-ij_i
zWfum9Njs)W%jfJD+$_WA+1RwtqaPhX4M5`xv^?t`Rn%bz=wS}>i4^dU0lxX<R3pT+
zDw6I8L>vZtJLPa25Hoy8e?Wj%t6as4nga<iW2cXKq_#Gkr*+(Q&|iPaKVbd(_$2Iu
zRegD~+w!Q#o59TYDqrX3*SgkkS4v3!P5^P!4L8!S87ou0%9f<{j%=^mJf7e64}LL)
zUwcNla9N=Z{Q_mFEp(2??iz+BzlgZ37>hE&$=p+7-TEyrW(-gC^IO%mwawi%Ax%H{
z#Jo)B2O#ol?yuXA9}mcVRF*$2u=3a{@3e4i$;O&sS^eieQ7<F8aaVu8$m^?R8?twf
zaQOgsnW8;|P9ta!O9+V2zAAhC3Qsh!YI(RlhnIB7l#4y9Rz!@)X|X#LS=;1PVlp{#
zF>=kXeB&%)Hb6=vT-~@ZRlPS*_1hWmoq=uuYij~ha4jof5j8=r{v9b&og>adSMKl2
z@<ut#SYH3G&(>G*&vReo?iaR5h9V{^hWQd5uM&-Sx{sGh=>e_6k((5@(<;L+T}LN2
zzj<-~UVYx}^?B|-q8m%VsV@<<W<>wu5Hk~uT0tgmSY|ziv+z7kS&`~jwKdh%^>2AM
zzm+Bb<(FaPPVKmXvA$84d<)(E5xxCPN6or5BOxZtyE{O*U(tO##OPkDq^nKb%Pcuj
zJJhL4T^)end4-<26NM^kVL^i7XWm4Lp$qj=v+d2zUK~9{nCXdg=FNjlJ|d)FqJMRX
z0eUz~nIEOQ<gfq8TjM57*<HWQuVIwmLEp%ozRhArW5B`?l`WHY)u?*Y%{CaUTm;*n
zh6$+$vmU`cMpwth%+c!4$$O{gcdwW3vfa9`D)Rk0jh8%8Z$uCVMxNS)&rz$qT$6eg
zPTMN7y3nZ-3)5Sxnq7oDlOp#d)$fBGS9Y3xy8cRf2}rAHszGVQZ77B!u2Su!EUn3Z
zT%(>((G{;C-Q1gQWkJAB@@{YPPW6>^Rn_Z6iU_eoz9K3=F0J>6G_L-z--E+F1w6xq
z_6YssOf{J|!A)Cnz3oQWw0@!8k79DodZ{z7bN3>_c3w{`uURbb4wl~-k*bO`J!Y8@
z!6uLbeoD^O6-_gsFx{xQU`gk~mrZlOAacUjIg^TKj-|WSAWjf>p32tNMMa+W-8#z8
z+~uEO`^MzRTOKh>+O=4yFWGCG`d<>n(?CiJDTVTpOtv0pMh&L;ErG7oha7uu>-zlB
zXFfP?Gk<#(jvOR1CWhUa=%gO#r`_zIKyhCSkxh{CX|VdQBDS81`0nd#MyKAJaq2hH
zJAMQ=bp;gg>^469?en^Z@paqQr|0cgC^q{kHuunzV(Yctn&A)?=GWfh=M;-+2-0T!
zOYj^~$4G8v`<1p2U_|GL4Ri45oPWN3`!(&w1~6n=KADj~6iSq$?@%FeHTWVdHBaT!
zH15kfa@F2AgS#Un+6aYXeuHBcf;2Q|<|a#$Vbh+I?`97(B&<f2|Aeo&#kWCBGna~d
z40HJ96l`?BU7a!9Ni$BtX_pq$8R8fth2OKCza~69(V=;l<A!Ft{Q7usN1F%eb|>__
z1Gq`_qY|-z7gb$|(9krSZJl;&x)z|-pL6nRa@07_z15+L;}Pl=P|B)R!c0aN*hX_J
z3pTBgEfO~`g5XL`^zXhgq};W;Uf#qvHS)7C8qgss!@+uQa8M+S;aHSzb|r})Bw2k4
z^&Ay5M(lzT>je=9m3C|#oecH1%=uQY+);56uA<{Xn(0AM&@?VwN~b~*Ebo3C`6kYb
zJXRN7Y1i?lbLT6$cqlgf-IMC{dGZw8cMq<f&OYF7e!Zvtcj@nhR?M!V)4WmY7I?nl
zx?{*Syd5p-Q>XjzaXzek^~W!!!-J`M1d4aCrLx8T39;joZ-JJqJ-z{HtvhraT)|kg
zaYS_r`2iK1F!#&$r>pJ}wPBvT&Tm3=A0L~y`DNFY?Gdo*9eHwn9%X=@a+STj03R(4
z@<&DS58vc%byaqLpu`Cp&HuTwatQsU9KWwDs20Q_Jn&fKo?=aVLhk!jzPW=RXYZbL
zeBS1-GGl5oPkqgmhv%4j9kW`#u~i$eZ))(X+R2&aPPnus_o`#=D|F#RZ~Api_Wvr;
z#m5Ru{o-+CNkp{E<;(6U5?-7(+A$Y~c_jF79>DA1!vF@2N`yPQ6aRz~6D3~LlBU*a
zW8{$Wm~PS>0c^R?UY1#chR?8J$L5Cb(qo#cPq91yZ|gb`tCQ?62U%<d#S_(ab**BF
zNg=6J8tarleNrwu<*_xu60{wN6MQMt9g`uPZWw`P$CdLN;nLKQvfA+oGi%m`bhonf
zl!Js;RaBlwJ^bk#<WJ=t)8*w*wu~er*REY6>`FvhJUaH&sfnB)JjF4X{Dfxl+26lP
z>)GS1nBpUv<smmrpgd#SxpToBOB{2Q`6-f~IH^K`<wf2}ikVC7H>cRDn0r-C6rc7W
z#vD=i_+H&U$B^8EdSg$5c@9Firi1n5XSm3!h!_u4Xt*8(SxZdaA?98B$4X^@X56G1
z`ZlR)D%87g4~eDA&`M7->l%yPc$*A8VRQl1hycgOLhdcVN%L9I3<}lUK&3{Sv=T^!
zvzPj*$f+4R_~zlK`zyOQC@bwfY6lkJmx9IctsMyFN;u-)NB6`@CSf|2#OMnFM}t*L
ziev7Bl>E6AD*#4L^#hrsRP7ipZRyyZrb|w1NR4W5MW{ImB*>8W7I3On&fN{igp&Pa
z_Zks!^`m%@i=?12A2GM1E63OW#4ihv!Y+N<p4GIaT|0}fnN_PCE6buO&`FZ%=x?EE
zAOACwI@4mxv4{nR3caOjNoBD1h?4P{w=h_Kl&eQw<V5H0RnC<ZW~KHNxe)#QFopvJ
z6egw_CZ*OSrgmcH!8f%V%PMk<7Uxa^7g(%Ik|gVo(_{9CF7)^pX4j;eI?rf&N`(8D
zdQ!6R70mkR*nFkPSS7I*ceqHlPc0v11C`oUpJ?#Jmeq#K@&uHz|L*trcdG;Squ|_i
z8lgEH;#SA&9;`Sb3#?V5u4d4sna4KG={UsK9TMDslh-;x)Z!~%yWd%O)mWJ(ETO{7
zMX9tTKCe1nQ*SHm|1OuSc9c%>iM%!<((gN5($kBR$j)a)h9%{+Uy1h+C3>{LCUXV5
zy0#WO8-H;QQ#TI48HiKSHlk2Z*%F~>kuIeu%Ao54HYQ0jpn~PubCYLuC8HM?qWdOf
z)tK90QKgvIJm*qId~a~bc(YOds5+zR>*2LZ3NBIiN5}Udkn;N`F&}*Ej4V`2qX?Uj
z)vV93-|Y_z+K8>N6YWWg9K`MrMQguMgs;e6krjH7XIAk7vjzR?VfAG?9QGk7^Vv|$
z9~V#vAEbjr8oME@!KO}kT)tC}yKV$I`PW45m9RVOkw-$1=ESAzXQFSosJ}iV7!WHo
zYlI3PbEi+w-E`wTsGNR%?QH(TvmJOJEk|XI*+^^rWw_*4Jr{WTfk8xDzRf<*8^X@F
zgagMoirW?9A+cl_*9HVw$D;ZcW-!Ri<4|Q-Th{UwdB-NAv07Oi(}4-E(jTUz)|BNx
zD(hgkkHUsCxA*IfSp6XLQv6L)=@5NYfdNEkyt{sgMxbJMh>N`cmUAUNHtW{YIA}*I
z*3~Mj#E*S-s4dzAS*s8ZE{i4uf*Utod+{nX4C;{09o3H?KVH2jtw&8sHD^GyIvRyQ
zNh#?(K}ssOYngO9`vU44&YB}70-M-4ln}-V#e1Qc!%-}PAa^6;Ji{ZIX)x#Lm?C)i
zVM3!=g2R1Hnt(gz!~j1nL8&~dE&`#1B0N<O*?;bXCqj)xUgjy)<hZ8EtX`iSiE47`
zL}%SQ+>GT}1-NAkOnBwJG|1id3e8%@f8eT95DFoA9U}9IPWOxUjKD>lUaM@+QMQ7#
zngb11u~I8eN-$O@G~r*l+GtG$tM%K<jrZgg<0ERf_4kQ+xCD7n{b~Q+wHXcN$?KWq
z6{5Jtqw6a}rF1XIBdof#)Jg@PpOo9=nLmQO7c~#;htsw1uXQZhM&GnHL^+(JhjVpV
z-tWs;io=cb+_D$89C4YIHEKgJhLUp1-!S69DiYbOb*z0`*H<C>%OOpV?&vQxq?;b5
zBfQr~!v9S4gBmtO!Y@{^GQ~R6=D`JC+S)>`#H`ie<ksb)!0JZ#d=ca+0FS-=92|gT
zz;^RWD#B>Nq;K3t#dL~}zxQkT$nUUzdeWk3xL#YNf1m*8;{)!q-3n7ODk!x?hK&#1
zv}rd+nU|98Zm87O>;Bc)44uOm1TFNKj8vN1!RmK6kw#x-X|y!X>rq4X@+}X3o#C&U
z?O$P}`sA6IyJsNJxoS+$jdTOVkt5xobn8%7(oqGVJwj9A5&rPEDM742TTw9`mjK>q
z^$vT!@mGEsO#vf1augbFLlEs~1Y!h>d!cn#1Ec9B==#B@LCo8Fb2_$GwZr+E@#C|j
z<j85>`Yz+@u6y?u8-DXKPLh>!g5F;eRs{ye>5bR;20`Y%EuMI>6jJYN!S?gB<>a_#
zrODW$Qs2+*Tr3@ok!&nlQFO27cQ<ZYkzfzA%g2ZVy%Dj*AiTg13c#NJVz#mQBW%O^
zAoB3czy9a@pp#}9r-RnuU{rV!2?ijBLobYCIT*xXVAJd`TcPAzZBu?Lwfiqfsq**H
zrLPtwAad%!R=z==wSS0ubjZ64ROy$H*V2l_IEM%2h6;JJ3+^GtVLA+}-P(4pR*9Pc
z?ONzX1&Z$8O1*(wFa*yMFVSO*@1gk6@qAwQJg58Q*CCovz4EPfEComH!pi!(J1Zqo
zP_3f8oFe}INi!Z}reJj|l0_@Tq93GrgUEE*k7t0<gcPtVw`|!mG&fLLp%N)&aS*L8
zplW1BW@d@qYRG&*iXF-$q}^}_Wo7u4aG-!yMK0dkC=_Td_Ip$ud9NzQ3-C~R@$>rU
z(Wrk0f&>Q95NM8V-?1ac={^GN{)54MK@(+F;q0pAWkwTH2*~9@`vBC`5}`@GJU8+n
ziWwY5=G^txxwTtrf|sM#e>FQ?!C9Ydn|I#zGSIoam8g_n<%tJsqbP;QM``FQ#g@jR
zciXi$<Ge=>3bJmb>!RD~-y@>R&^T_WR!_<T8*(1I6ZUfe*tw$DP-yPKh@>Un5JUY^
zpNBHpUua7!$=q+0vVv8|!G!*lZ4QnvKGw3al<q*NRB9-bV%Q<)irz%_HNj1Ka7S$C
zMYIcelAehi#yE47vBcp!5e%)BND>s?6f;KOv{jD_niJDInAd45QP~2VB!T)v5xpwR
zJ0AE~H6hX+Wa%6?WLa4<V$=gYM2`ZT3!}Yl>l=&h_BIt^@7|JY$>7alHqNr%cn5w5
z3If2rEOiGu<W0bA%O&oJ4$Z^RJg%j{3IRO(FO%#y5&>mnk9q`oh~@^Kq(2p+k}I|X
zDD4|v>`RFul~hh&x*q=!6L(msCqCno*3jZ_8kGgXiER3>`)=EP{eG0f5OO1$E<n|m
zgyY?<FXTk+vHkH9*Lrt-dU5Md2&qt18pWaAP70S8ZL+bkC@i&x?0=XPlN9_KC;M%0
zJD-!<mM%@D-%&5;{ri(?7qZJ+Kcy%N;~Zhf9$%{Jn2*pRp%B&>v$az@zCNS+3DG7b
z0honGK!oBvMMbSU@sxEAN6dfg`;;2Z3tA)s>&9PCFD4yPPIV#9Yp(*`CAYCdJ??E9
zv7#z0GV*80#v+|QHYe;D#ggABN_JfgR5B+9w|i`Ax%GG_Csok((Pw{ui4FvspJ?ur
z22-|RbySpXEXh8g?dNv{c`1eBu*`$T#3~Jy%KF*<noBI*A=lSKhZS-BMSR|cltfZn
z1NqBKl!03!67l0I@p0By5legGg|gM^A>>FgyqUTOsonoR6Nb9zMyb$vOV}cBRH=r7
z82ahCkEsjD)o!}=ey#G+or?mYqH;z3+_9+TD^>IHE-l%2U<f{S`Ycc}Ce)Tfh4Px*
zikf~b8Rw_~IZmsmuonu`@5?(YIF|ds?3lJ&YBp5p+8#{3-=bCk6=#=A@C>MJO<gk3
z=ZOdp6&L;Ec2+y~VR_PfQv{vg@><XgI~>`0${9)dqhi0ku%~NvxRY*Zb5OU7_ik=&
zS>CvG-O=<?YW8I=g&DMgd}h-e_;6&pluY7vuek$YoJv=1gv)*mKdn_#>Kvl72`PBr
z<KEsPyS0w4zDM--g(R;K(c3vTwPN{|O$W)^p)gK331;w++=4=f^02$cfPN9)K~~Hn
zsB?7>&*{i8i<>;e$0gHi3^mDpqT`4MDP6E`WA~%EC{-@ysHOxVJn9aEgn(*z{{E(t
z1Z!qbdB&T(Re4UIOmpXsRJ7vs9?H5_t_W}U7(5Y16GqBic9nWQvNEpvq%sQq$t*dJ
zBeGP<y9*k&`JqT12jxts`!I#BbWBh+O-17p6Ez75E32YH0-fq{u}NEhNNTOl7!Ng)
zMHuyf<0Gx79irZWC0DDgoC#TKe7(mmXvRhI>VUP4gT|3!O==o$w!4Ri6@*IwM6fzi
zu{AYq)fmx<J3;&NYytMKP`EjLHqMqap@#ltrYI$IKs|h$pyw*Dp#?!{mOKsd@~r(6
zLwdgpu_-9at1VO8NkgsCcO0+PQ_^e-bT!vdMV>?#n2DmkKI-&Vk(8Suld41~0O4e#
z2OdC{|N4C{LR~49`&ua}i;T~V1TDF6hqK}Dw1%$(-KZy>nTdaBrf-056}P(_7>J9Q
zkid#bC*2@1EN}=&fy|O|-Nn?YKpDC1Io}p3W`-y;DkpOhW)U?OufV(dIdy%%2yA2l
zz=rk&PtdmMQws|x76|@c)n#d5!B4WD;nS))>U$12hpf~BCtyn@cuGTXG=w$i`S+cT
zo%Q41Fz*aH(Bp7t0+5sMs1`{&<8T*q?Ya2k?bJ<f##a`hv%zXI)QuC93$QBKX{VTr
zawCVJYX?b;Am?B`3+1()8XRxXFGL?)w*fmG4gq}==bW4z*spQ1tlm)~ezZsgV$fgj
zq0d7#ya}>%U*9N+sV&j`;%q#KSoA!A<OqFu6WX;1V$S52<>WeY5c|u$SCi+3gr{*t
zT0vc%6Z&G3>lWidHu=$`N1;-bOeFR7E7Ke*5e_WxMjCY-Hj$$a+!$BcW57z9ffQ@N
zR0+Y&3J-ZXbOFo4a~^z`B07P#5~s>4@!Ai4B&hbV!w^HBm2-W61j>Gr_t!!1-Yumf
zOMN{h5;t>1dnSS|L__P(_u}z_b_3UEK!ctzIm{O2w0yHH^5?gl`W4{4u7wzHhhU)m
z0ee=fr*2*-0$*$TMV%gozLol=bk$1)azQd+Iz-U{)j}}z(N8_fe-9$?H$mtE3P^@*
zz<NyV<HzG$H3Q08hVKcSGI>r|Bha*WuDkz3^<7Bsy4VX>KS))5>C!<htJ<)V@i>Z=
z$L1CyyLz1@$CiTt4jyECwqk?R{iEy8w=@>V3o_B_gSHr2*DNf1Vy39wKLcM7oxt^{
z^dkYWNkmLl#LU6#O_zd96@Ax<LC&w2el7ath++*#xk93C?+IS-N=h43ZGW;a2y$;a
z<^AxK=maG)w)Lojy`+sI+kDE|_*rTNm-~xj-c0y;y%*y9Vt2sr(pNjCC@y?bo*^3I
zBkoAdl2a*u#4t$IRoKSdwAG+6G9Vfb<qcN6F@A9_8d+CAjc#0QISYof<kbB{slrwj
zgs|K8sLTP$1Rqsa0SbgIsIAm0D-gkDGYhh+u*umRIfTcvniJmoGV8Rkn12cd^cCT(
z44b;co`v$7V~F~xx!JBIw@xKz+X5=@BAXkLnk4GIm3G}auVq>OWZAjfH&E?L36+xS
z?D8yb{<;o|)}FpIZAQk@>0@_oqXI#Ln8N!~Bb^6Ggwjj?Q6UBj(L9cQp@y{NtSng-
z)rDE@*OEP4cZaXpfr(bFI`Sw{?U@-F^;BWXxQaohOhs85HqHvKHJ9{2k%rWuXlF0D
zN!ha+eprLU^BAM-3s46fgMb*4qweM}E@xCwMrwSuXlmZCQ?2m!84ZZlC&RM{GU0ME
zJ_!nyqH!i{B{wEQ6QXFNsQ-~g!rosDWhlm5w~EOwKyu%&>m&ceiY<noL8M)UITin}
z!w1eQ%L>pMqinlybw)i(2A(KDH9?!~B=id^;`^5DVKbIN<{T+OwY!jV5R4$*E`u&#
z<7R(t7e*s!QP$W+{=NnNX{a`e7CIuWr@sZWW7~_&ag$T$30oBY(PgWLe5x_ae_aQJ
z>T)2#v@OW=5u~$tok#H!zb(D6uVSrFbmNF@Ib6d^bPBz{KHp~b{iP1~5Y6RW7>WVZ
zudO(nclT`At@k|wcGxRBW+-o<RrHPp;1Z3RtqVeRsmxf1i8n`lx1RQG&9*N*s?P(C
z>s3@vSvw%Wkv;X4Kuh-QyS{~$ux*aqe$9k>>~{U{OL2rv51f%)!swL(fQpWe!%lmj
zsJpi!PbBEG5-6X+xu?S5uypiUN;F8MwbbI<qtBxlOsPv%?wrKIzQAUu6#?FtC8q`_
zXyBCi&O`;+68aURkHnIAwhY`pOa4oVE$d%cS+d}#87~shKc8U$q(}YfE0)X{M-x9z
zO${1q3HeHZ97%DLH8-x}v;#atT@FcUlaqE%P{590H17Qpr~&s~+Z);xnIg9|C3g^&
za<wR>>!HT#iV<+q-Sv~<aw8E;T(?Fbf%E=uE;^w@kV_R(h+#7Zh@A|bFVIRkq7zjp
z^&wMeoSZF(0WYF5wG}PQz0<fC=0hR4S?FvUNTE@R?L+-ox*W9Tn(B2&->y9FS;Crp
zsA6|~_fEf+;o<Sr`-2SNI&?P3%+iN}+s<7{*7bu{@jq0R2-OMx5N*~<oJm#=X7AMu
z(JOree|+<X{?oK%%uw@K<dFGaQjWE1{d&9DfRZgedu2U?S;O^WploAr=M;C3%*Yd`
zPQB%=)OaUZiWd}@6{O@pNU;iq%A<xlib#RoaEGaGFStpqhEQtK3jyG?TLZn$<yoPr
zP$~|(ZQb~OUGw|YU?=J90;;f5K|qYy{HSlt@4ijI8obU?0sjUa_i*&>RH#LNS-kqH
zH4KY!;7S&NQ;bnBCc`PdA159fOCeh`fRM#=w>+A|IqMEO7sGyx$fovtj=nt#iJ&8^
zci!Nc>UrT9tz^}@#JeSNF2F_{(wK_1ETN#!q^4w}3H9Z9S`>KnZhlR({Ss}jJic5*
zweOzHpJ4G&s;=Q+6$~>IB!(s`%h?q?xE0ug>%0`n`xZo@lt1&!QBJK=VO^)u)as`i
zqEzjtn==!gV?J^>hKIR_o$EpG+#6FCC|?RZ`q~%g1UD%b#YMpq6xnx5>2DqWh0u{Q
zBt1bg6H3GqF-X4wm?g>pFE*DNGQ9Z<R9DjVTXPAb0QAEIx4EK@Nq|1hr($A}HOk(p
zwp(*DqoT-Ge2vn*5EvU3%Gb%ZTgx(|r?OU4US15@uP~H2RJC<xqcE0swSn6E7sui{
z5#3=E5>L9@YIvEKx!;!Jp+wr&)!WyhW(VIl_z<KJ5zNvEbxXhKw;z^J;f;E0R1pRz
zSBseAJHS;;=tAv=Vy>e5th9G(ZcR>}C*n19Wj|tFP*e>zR?H5BNi>l4v;g3k{AVDd
zf6aV?6qHfpLQPFG!tynXk{$LTP&X}nPLb0*d%O8tU@9xt5^SOny)#m#6rI?&&z?Sb
zMs{|w_4sk)R0I4~J8MOX<AR%XK08nm(PKOZs~19?QDz+@(?&Z;Rd!O~|5p)M-=+rT
zTEi?fn2{w>H-W&zn20b$2U*um?Ri?i_RNbH3*i<&867`>*Lhs78&3~!0N^9hwIwnA
z{y}jg(3k#K=j^Xu7ZH&Z0z_E7*wfQ98g-ayhqB}-2=mn#I1MCe3I6k0(6CSqU{fZg
z4fkbcgN%dSqejRo7hWeK;S%!maPNvWR4!zO9sC1~YVhw|=#NpFitMzJ)Dj|iE6F;d
z`Wz|Vkk|FGH$-UTR*lJ$cXyMen~2nkvU5FIiA_U>42e8}kdBHY9rMvLru4zXy_(W=
z*29`lts}aFe;9Er<B6T772%K1h9zXPbsiUqj`7Er|8N5Zv5eyZBaR<L2`3E&REl4y
z*okn3ilF$76SoG6kIGGt<*nP^n?gqo{WCzav*dI3qkU=^NX{$+FOp4-0X%X9G>+(Z
zA`YH}C%|f+*i%$7&y7!rZayVKYhys=v22@I6oisc`8uwD{OA$-4jKCZB`?5Ry34B4
zjd#=4s2m-(orm;>I+TYv0y>G^t6lexpnRj!I4P`bdZy~D^q#K>PieLC(ozi-=4(UT
zQ^Foq4?$!kZQkP({VKXH(m}EI&~I%e5EBL;(<`w<|EGhGQU&Q}UR-*v=dizS6y2aP
zHP9Lb=9>TI^9uV`S0yuv`vRvy){{USv21p4gm$>^5!)L<49!eVoOOm&wX+iGJT<w9
z8%qFiY|f_Y60^1hvdOwuePQ{GPt&Ue`~Z!BCJDecFpM}uC_T=UUv=FZYX!j83~dfj
zW@+7@r`@2A)4@BD8-SilM3-DQP2A`r9_PwXL8uuP8p)&|I3qNEF1YDzYH(IjTe?<B
zEiX||q4PF-cWMW};tz;n<&xBnk+@mec(&ulkMB4MyfT$N>$kD|+V(Dbjp+Nn%IiEM
z>2(ogo;pP!4}}8xvT61VzuJ~<v}Of5ZmiN_`%@y`_CYinaP9>2N6!l`xfP30>d;U6
z8}gzO4R(a$)5crgkC)8Fd~8dZ-k^3i&$PS^qwTPo#(c`xuAzAMG^DZofnsGkxX;{#
zKcXI7Ts!nHsGk47qjSb|qVm5h{|#36r+U8_m4|&4YSmL}>fwmVaF=T~G?6D`*frb}
z#GQyg^BC+iC&wWpQ4hNY6T_Nlba_{&*e;!s&;ztqR6df2edKMR=b8nDXBuQKwzbtG
zSGwAoJqEi`Uq3LVY*r#Y#Rf9|P^MggdbmF-gY^_hM1EjXPTdz3wbcHn%9{6={Ub8#
zwoawSN-=dt)hN;*L@<B}zFG2y1}pP$M}SGi@pNU^jkztjiQ$cO=5(-$A`TWh80cHd
zMp7K0NQ^2Sbo6!vb7Dj~3DmDBa5ry3s;P6h(>I@N)ZMx|j2`l+4Yg*1yU<Zm_`Cz+
zFv;Cbcz4r^lDC{XhN28Mk739t<iLnoh%?yDN~y?JUw2HFDLP|h#qkaVcrE=KSo*O{
z3K0S&7-B@E*sLIQhfoc6iamc8@cw&f5Da@FnMyK5l3#(+gYNo@gh{EL|8haSwm^FQ
z!L2jdtw+}<e+P}i7_HYMrGKOFPz5vt&7tn*ms;h8z|Av83W*8xcY|+pfUx@L;b8Xp
zP)dT}w<f!hi~ESo*XD<lQ0V~NAr*lep6FK?dcC)4Ad#RUa5J<Y)b<mRrn{xdvSIY@
z;JGe@l0F)jt5HxbYZ*qRpL4UFUdKogOfv>^3#Ev*E2;RAix)3e;L~SQG`ueuVJgbM
z^b{cT@P{+Dd=aX-3rQBL#N9j`(vts|BF88=a|8q=jZ>0;MWhR9T5K{zt{}AyT_B4v
zA#`CN4FzdYw(}&`ff5vBd6P;G6RA7J6t30+H4b%OovUwNC{dyauYqcoC0w#wZDFC9
zG^CJ9uK?6P>HaXH7XipoGq6S~Od7yDGw4@FYoG`n|B~Wx7%E4MGo`uqpBWK-9zD#x
zI&A)EFnG@s2oHY|y=1UKaJ{K^uLWv>X0zaC?ZiK!S}Y~p5;OtEI6{8|Y%Aj3Bg(?b
z*DPnGYoPo=_>~AW&c#IiV9Kd!cOd#8O#)i+iAXU$6(Zh&bum3aLj?7iD2Rd0g}4!f
zR}>I6M6L&=*&9Vzd|W6p(le#cOgS|DB-6e{7siEYGp9Ht2m86A5#P6Z7x9#BQ3&?G
z3fi_cAe)dgu&|Xz6P^~L-R@7RYs1Dm;`V?DU`<aAA6Jk_Pmah8q;RYbS!wbl&Q=J)
z{)JzGLt>H=|4_JtAemS!y9Yx-?_ngj8X_m70SBo5A0KiCV^5&052hvieyUelK46N&
z^*_$8MRl65Ie9?@-})T#|4aWgCE}?m*UUGR%!EQRRmh2B0#X$rg)MwMd^*X10QyM8
zD}mA@HULM4M|uGMlw8<N0JYleN)7b{FvaO;LZ*jDTu~|eWLVbIPsY^q(+X)vpbb%o
zVlL4@pmNAKLTH)wRJp<YLn0gcc&I)D9G>gS1hml|upCf?(GJH+YrJn-xfj%kTR>7`
zPY3jwgI4Mwo1%+jhsxH0Xab@YF-~w)h;oA8Fy00rC=wkYx}XCp_OMPnGjz^mpuh<Q
zv3D9Vg3S|&d^MbwgJn@glThs7&ggtW)E<*!OZr;H_&lIFp$4rXaV1dkPT{cPl2PY{
z*pqhbce-=g6x^U8s5$u)iKh42#yH>W3q8l{5Rybc4CGJQy7}PxfNuj0IXZi2OJJ~A
zY6Tvd6+N<eTs7%707{7bL*Q0)JBs4bGN(J?yaz2v=*eh_xCx$Q^pUfEn}GX8TuEZ&
zmYYHAW7uHxKs*b46mMK8(ksK0C#hJvwF8EdxG^DCN-T5~*h2LE5Sl$XhV+0ASJ+X8
z{=8?z9hSIY@PmILC`l7R&#8=!yvhs-UgGJogS>enqp5&}#Xb@rhFL^C6+9u-UWe_G
zcxlpze}%^sKGQevGsX<1f-|wfcH*Mb$00_ZsckHmLORX7rzV5x?+|ed@?mg3sm?Tw
z1ngeYv9}PGgHuz2O`FT@)|n>v-ML)RRr|fclLm5Js4x!zt2N%9j+W(&$*#IHqeL{D
zL|Q*neGyGafl3ObbBAi=S83r%IA3Q|6N$7rkvcCQV)g7{(CW#2nZw6ET{y>XK7!w#
zs+s&ZsJ92xhG>{w5^A3PF`VILNS0Fx5F?VI?%yZF+nDxti+l<Ol)N_uXm~S5=Fs|O
zFy3~naLO3lm=T4ZaAdvr+C$T2$J0{<dh`U~RH(uI)*aG^Jw!K!PlzVVBO!n}N^8*g
zcye8&X(*SI`KKpA5+)jFXlbxV<bcT%*zITk57Bd6u-tbrA?8Dj40G!{;5Yx}4f6-*
zW`A++>wh3LHh%`&{C9j1P;4z%p1+qK$$Wu}b>rNzM2};P%R+KP!acy%h7UvdqJ-8`
ziaCQ0Psm!R{+egNry8Q@Nq`ym8XUuuM==UA15iQ$nU!o|AqNg}qkjpw$l!35F~>^e
zEOIoI>90$X*h8L}$mQuDzh?y)U7z;KeC9)4#L@5e+zER7++l=`=J7T~*62HpBaSeP
z74fg3EDoasAI@J5ya&WT-*1!*Aj+W!c{zy-{qYp7mxfft-@vJXoiYSM2nh!q;gP|1
zCd8N*LiNgy7=5r~ALF6mpo^IWB3e5PQ96|Due<YK)}(*5e!$A3ul0#??-lO5A-&}~
z7zLkSwO(;?ae|bd^nm%;1W2-D*>H{Fvn<rUCxkOn4S+ooehGWd?}q^o&>-Qzs*#eK
zuK9PeNC4o&X_OHMeb>`dGZC&@ngB6zsGSdmIsGg7&uPrX(EgUVV*(6$J~}hbHF$fn
zvhmk2mn24R?Ye*B^UwU}V{AC^oXv??trB*XF~HeQ#}S#&ZWY`DE~|MhF;LCKe>C4=
zt0W$xa61+#nF=q!Vy;ElZ^S7uGG6R{vlA}dgHLLnj7_!lyokQ@6x>Hg0`BZX$Y*}x
zo??Yjy3b$e50|dH4n|}i?HvfT9W4602At*GP}<=Mew%PM_!b%;vG*VslJ!uUOqcL8
zI=+FhluzQQ!?a|3dg^1brjrn!*Eq}IfJqUO|0R|TyCSi-_*qyDRG<Jj!kW=v$69qV
z_cYnTBG<wHzMa*lst(;jD^Th%KlPJopPc*H;E!04ZK^l%`UldLb2x}<2E_|M!q7mt
z5{ETbCtE`sdWcrXqt%V3f4PXuM83s57mkOthxi1qr6o#_lQAK~MjMMYT6&4nZ-Png
zB01P}4&^2eZTUW3sY!OK!+9m<P@yyx?R}<g9$*y0ub`A;2n6m{7z=wxPafNxz6N&;
znmE|cozTV6IG4gu151H(aL^KGvx|mZOd~Z5#403z52=iaFlznb9}(C%VERZdbfSlo
zEm;Fw#%Zom&Ox4@l84b4IY7?>>bM_OZAKl9IEl|W35!~U^Ve<Mw5h1I^)(c5fZ6FV
zlNf{@xf(vI@~{gLg!8as6NHY^5g1JG>V{xMmq7aSavI?yg^@L#wKy3fox)0N#vVfp
zktuNCFqr!RWM-zAfcAM68DO@}(w*31oDYoaQlf4+r~u@q<kG&anc_noZzD!MVE`j~
z<*1&y4mQZwVx=MQEb$15X;TIfF{vMud1QJ8Ze+V;kd1%#IKV{d(uq-zqseTn#2o@5
zl+55jP`oI438#kkpKg?8wQ|f%+KcHkmvvgS-lvVW<Itykj_VlkhWX8<>mMnV$o~pa
z|5M1)nxM1e4ZR$Mff!~H-y<V}dp{E0$lZ;kfvm!76dU>ug_RVNhr?y#t%MK**)MD;
zJHlu2H@3Ym(@vhlb52`CB5ZpRg+bE_Cq#;N2=j|{ma)llnCz$PMmBG=QX)ya{c_*u
zK{~%hcoX;&a82`-Xa|f*nz4dO{OmTTKxe}-T)2$HB-fUk|4B<@H|@zGU<<^i(vcvC
zWqz3k)sUCq!NM{<F$9lnYv(@Ma~M@SSOQ)R;&zx0U4$pzaYYr#f^+B0sqdR$;_<z~
zHfPg=;l!8B_ymO*cnK1s=Rt%8GF9dgWO!k?rz0c<)PgP+s4S(1MP!+jtDY|IBkWBG
zl5L_VgMrVrK3OGW<?9@FBluIoP*8XWTrf+2{Z}LK#MXMDL2;+Lx?mR&3w?Vr3F!D2
zFee(tTbB=xK^(xb1_d^C+9If5qjZu=11=~ja+4)YH_e6?7<DE5DPECGB3tG3bm!dZ
zZ%gqvXcky-+!8*0X)fYEY$lWV+@_P^9J7^8#>xDN{1merQ2>EnxOmaJ;Pm1gFx~pT
zQ6RDVpbEKXAYq0<Iyy8*AYjvga$%z&!o-g2$zc$PqG%eLNB)H{?HB@sn~aQ1$*$E=
z>`ERslz`^uAX+X(HuN{*fUtN#r-Wb-M+OiMoBbi}I++bze#DqqHbp`1?96C^5ML7*
zXd9cC=k;8}C4H+!SPDx)oT7lJD9nOG7bo|7(kjCgi0s|wFNT{JB_mNVi!9da$sMB2
zlu-?X-Fv!OC=gM=qLU-!Vnf1UMhppvR_Ixu!eknZLa@gP7!PbY+8bPVcQ^K^x$o1N
z^u57lo<K0kZ7zTzFj4tRaJ~cc{4~yQS%lO`rV?6zkjy)f^-wa5c8B~XJ8N_lDXfz2
z3I@XC$@xSyU|2*t6d~{crsJ5B0h3xnLE|@A-$YBvh%FF}AOL6{Tp1Dzki+vgj?KoB
z{B*vJuq!L7tS&4)htIQS+@e&BnL=%-)*^_G;W|)`dpgSi3Xv$HobPomXYLAXih62?
zEN&k|kg%NTPgafm4rc@N2@)Z-X8!w=2Q2wZ4FVgSixkOOjG4nz&iI5wkb)=o{PX!O
z;4d2gH6Ut}7=#ot?8fXhmzG)vhtWhcj8ehy4Xm0E-Cxph{}O%|_}?GR+bHM`q?46|
zwav!boXMwRL>87|Ijs`ACm%(E!kA<~zKw+l%rMj#mce(z?Gy1HB(88co<1*;uN50a
z=kUg9T(?5_CU6K`2V)f6UuMs8#7IkPBm|a$FEkkh+{%~OG$!b0vXLMknRk$fPlp->
zgp4fSNO+Xp3zlj!Yd@OpVTBoIM<T#C`Qn_!-ymPFOTzr(zfRe?bZU$oFe%LGgI7Yg
z;a|^534Faqu$r#@tJ~2R2I=t9$AAN4Xpn*?sXrO9M6#|lKJWvCMn6JkiLw{UcInnE
zvY41ZZ6nXIV0jlG0hRd&>?|<j=27@vIdiZzLZ+6D@2=a}ca2CkAUGr>#k}tH$lm-w
z3?1A&9z$?n8N{}UO3iFZrnQ#&F)mgU!hV;ykx6%?(^uw>nCU+W6g^jF$;sdOuIPdo
znJyjk;`WtKa{K(;%=bq$&6zdW`rPb3P4<<CJLjVS{2avIGe0t+?=bZlYY;f`zu(eV
zko^DCzMSeXe>n-4GDd!D^Y}|2W5)d1^S$O9?w6Cl+Y>ep2(FfmdxD>NU|0T}R`g2j
z*oiB=ay|g)cNp|ZBzc$@dU@`=d4N+NfZP7_Pdxhq=J9OEV!}McDPUPp-P-JKYiqmw
z$|j~&_{=eQW(!RI-*!m;UbUIP<oQZ^dDCNz2)wUPg`q~K(DzT#XD~YqG$lOHQy<}$
z){8<mslQx%%sb|&<#nF(In7`oy#@LN5CaSP(@#l`?XJgP(5>m)fZ<y{GAo7|oHv4p
z`s#LCyU=ezDE{)CcfgW+g$ecM-7w0(SXL%UwM2}42A1>&z9<T*B=f5_2L%Vyo*NZ4
zckdG4<Jlel(_Zun<Lk|_6&3H(x0vT4Kk2hmz;u(*F1TvmcnGL`3LJaWFJ@$HoAjcW
z-cv8h#&A#eJ?43bKAAT9MK3-aFCHVOO1H5Jz~E<|?*DoZlMle*%d0lCv(bfz@TX7o
zr;ln*1X&sYF1B9F?|=IDKi-6Wrwcn`($p7!svFpZ9@zzq*98W9s*1D^sD;1ObH<7*
zMQ*9;P1HmqMr8z6XbwE|0%K*K#7?^d^wJ!43EhCnzDIO&f`>XZ6U&$SwCJ2_=#_jU
z>O?LtdiFbLCZ~BdVZ+P^iN$}QDso?yO+DmH43Fie*_m?FV8m7s*=i%ITXBH19?Y*2
zBqIduSu|zmZbBGGwP&a7*kO%LH}CLN<|h8JNB{dzCfS>0(Ipu~)Hc6PAizRsWO#Ba
zkfh@XWimW@pJI!qB2$&G)NfnRUncW6{_d{=%FvT|&p1TVN2IFvf(ID>{qoJ9f~Esl
z(iDz(<1zx5bkx2#CHJ?*d4owp4OD7S`T!GgxKIK7J%!oC1yX}Z{3}u9=0F5OQuzF9
zNn2`u^`GZY-o7z4zwzvajEqu<x)4hFT6m7G)m9Ci0r%zM6|*_?O}C+?>#qPQFkN(F
z*#^;25}IR5H9!G){&Kens6Cz`5M!eQp3@R|dj8DZKTXal6^v>>i?og2muoo#SV05M
z&2Epth*JV89U)3+zm<7@YSIugK;PwMnJhTdYX@<X>mk=LUIg6wpt{!Jx@~}d>_fg}
zn)usN5viXrVgqPE`#}Z!Y3aGhhfC6~5gx%wn^mHQG@gSX6a1)cz~w|V>)c3&hQ_1<
z;n5EaLPzwM7eyB>Qm1zT@KgqcJ)io8UHg?iA3$ZO%dnU@XNRaa-y(kqN_&4o#M#VW
z*96pso{}=N6Un22mq>+3BIzG>XeR1=O^s))sJ6+p?e{MRFg|_wqv|j&)zIv+QRWq)
zQHFt;MD!c0(6)0v3d_NN?vsn(eZ#!O#V57VtF9>qnjw>To4|DsmqNYDw;q7!=~GT0
zNG27wdV*Jg`d1s0@yUVY|EXHvUbVCdxT8fxzM8xF;a}3bzeq17aGFZF8Smcld0O`a
z0{#nbBG%-qhx1DpgDA%Et_I>*La9T(Czw4ZzqU($@sd5k)bCFt9B(Ut4(~Kx!q<DM
z4%HK_pZ_Bv4qHIR?MV_C8hA}4OQOppLmD9LZlX4OmYlfvVu0~?N)o_v0#^JJ?snTK
z0{B+gZPZlo8n3jSw_OPs4DdlqxGek({hSpcgkp1aT9QlwjW@vR{+0bC&C>Y%J9XA?
zL4PwZI5=3n&AI25V*=43us2B4<ENacVSvVE$y4&~Ec?fM4N&-L@yu^p*7L1%uNdhL
zcj;q7xo`97`O>E)z`Jz>S&@YcLZ!D~1_VYrsDPmVLx&lnh))&W;2<7G+!XU6kEn|t
z3XqydKmp~_Bph}1%S`y^^hndx1^wv(3Txtks$pP0VcH9#gCEUr|I?Iqun6P`&kLUf
zUC4~s1F%ne6PR^4(Z2QBhyT$7Z1)o4s2|0k5>jLtFITUa1K4GuD}F+?LD}sGUU;wp
zaHN4in^+N1)RQhyYVqnFq+o(u&>;WoaE7(NecN5DCn5w9bH6_0_4q;gI<JJ7M*$+3
z6dzLD<d~EgqmvORM6>}422e8k9Y?LYzPBx1L4a(${TPn$X^djS0APSw@td;q+H&$8
zfkLq6fWVbj68By`AGnF8g_}E?--Ys|683Z%fgyCC0s)g5S?Ccxk+Gc3Kfv&q4nf<B
z1Nv|L^BpTflZkJbWq2gharP3>#sFbT8;*LU9n=(LM)(X7;4PlSY5EEB3fgE{L@4QF
zO_z5B!}>%{*^sXr?cEySy$u2(@|Fm(BJ<O9-$##E5bY7VCWd8sBoUJUrLt@}Fy;%q
zp)rt9-v5c!Dgk26jj0X1H-#hTHVmu)NoDx@b875-oFJ22Tw|HkFm)~<nH))A=paio
zh17u#D7r_7sJ~e*@k%1HL<^}Q=rZTw`?O_$W5}Y<kM<;hB%i4w_^-j|vJ}xz7qsPc
zpz-vljfE#ArXh~<+Hs2jliPK^ZOpE1(DUms{I+y1K(MHCeS7;xd;1Imn1H(ezn$DO
z!N=AaID8_=@~!2FxUd}*(?o}ba83ZR&mxxG-~zYQu&G3KKz7P8-$T#!MpSNz9`wc8
zxp&Xzy+&;L8}vzD9bon&!*d<H?#V<eU%0NLmWV4%R};!BRkrnnDx*RN3C1l9LwZbH
zn+~$W8~~A-D*pyRB5Rdkw4w<p`5NeNu#ie_Y27$*#TPA#!|ndc{4S%}q-?kX{Rcy#
zyy^C`v`XU#se)qgOxoyD%un72Sej4)?{k<04yO@KwJ4mt6Ts$kVYCG|zqr&4IA8>E
z`Ckyw{Ahck!(9HBb8jfeqM(ymy4GbqxN9R3r-6q#ivvHlkbMEtM&ejpsn4rR!FiIa
z?EMR&?l-0m@>i+4=&Lz-HBlR-d3lQs%RtTiA!+O9?OM2^v&4JNod6XvVL9-7m0w(1
zjivzTN>yMzBqbYs0c`$@wg!kq-23B^Brb*XyY9Qso5K>K#sSYLkum7<gI_0`X4ffV
z>XINrm#mKgu-J`ogV#$F&-A2CI;kR^pAPW7uRswqb=d;O*VQF~|5+grYINHHwykOg
zGVjc1=lT|Ow|Fhtf);Z!!fOt=S|`7eWCOA`eV#<30<Acc1L~Vgm*nD6I}@a_j7VGT
z{)L8e1-MF)`S;_!6G(TZ0T9ZMrksZ08U46~Dm6$7v{BdHQm@*Dn+zhdc;86kj~^e;
zB&PIUO=C0F{t$q`=^$-BMr=Gm@nG|8K*qr?6fN^^a`WCtqJt+1$vm3^jstol)HUW2
z<GPTc&C@2ongt;)(VJlRN%lb%u4;|9KX)LR1(d*vd!(e)AlS;CmXfk8_w^w|x^;L+
zcBFj>de{wshygqZ3JNWo&TD<(BYETb;p>X7zu|TrDvEDRFx}_%P$1-V9{~VKUrixF
z((7k)Z=6*RN>lwnDqMqbV5J3MGaGOdheK9PQVi&G+)N0ok~JgD=GT&Q2z?mx*ORxY
zxASu{WPS(0d3<*qfYb9&k0g%HKK=C3cBG)f_6_^juBCI1g9I}plezxS1N~SnZhBh}
zAePJ7mMu=2p}vNI@KW^8anS>{Igc*~st{iX8v+4HgRA$b7yh+sGv$zaBTU&a^4L~$
zfW^dq@hEb8zp5+OHMtabIUP2bS3prQ*$4cH4M-0AUv#2)^KqhJzrcMMyWz@%bwG#~
zppHBQRUijc?W|PLn5)Xg=DZ5dU3wAt1lo>&xp)n$!Nu{4hTC#c>hqmh?4^ML){{z`
zVg05RE!$Ak5}hF3qy|z06us#U0`y_h697MRGa<hP{Bk0t;5)<zC1)XVqHXGJ3#lIf
znCUn|I`#+2;Ed=*nm#+Ng|wH6YeFU#rde4yRoZcu3#H(SBu<&K3jducJBf}J5D+jT
z7BL72^GR-lt<5R0S}zUd0Q&Qh^n%y}3IOR7Iq9n%6g%feb$iqCIsrQn2SptY@%q*0
zhKL{edSP;VAo%SrVc0OD4s55x-5@3jv66(edOWz}J(olD>$XJjJ5Kh3H1Q!xO?<=C
z9Z0B$B%2q}fs62ABdk?>0|m!P?}h@~7E)ND=&PrSK&aa`<f>n5&)07-U0m}TL8MCw
zJbf_Puna=b35}!-!2cQA!No?}zCBF5t)2|AkMTF3Fey1Ckhoi-@zztAT3jU53d%@-
zLA9Oe29D%kv*aYZ6IwDpLgoMMrR(Q1z4tNIxiyG27KU{+PifE0%!~_8twBG+uo%xX
za>Lo*5535vVdSn*1D;-BF4P}hrT|j(+bO3)vOSy_bc`>F1>fo=*Tm@VCzv9M9p90j
z0Z2E_^&nD5O2Z>i&4;pvq?lq>iX!?+0Us@n&k@`NX}pMF{$Wzs`5z4M=tGI~OCO?X
z=jZ3t$eET2ZW7QI)Ro9z6I0m^NvnSO<&Z<`{rfORxZE$1GrDGXDA|BCVzgy%NH*23
z<NhMy(ah+w%vLc1Inq#wJQJ}sus!18Z;-G6VXOms1KXw0S8O7jc8~VxcL!N$JU|5H
z4eQbI_I@LgYx%yXGW>QIgU>6%FFptE#A+*fNZ8Wo^br^B7)5*vP$O25=%x)>_aM#Q
zz}g!Q;s%8ZJe#}3zH;J-TRh+niPQw8rX#a<r0cCozqH&b3^-o84ps!Ye~;aV<Us`_
ziNYiZq)E}GNsUa9Zxsqy#L()Ib;2s1CMmfIXMZ0aySpBOv+z<s;R4XlAwri0Us}3R
zx^Lh67;CE7V(jvmutz^$DBd0cL7c_`qU@w75#y<rH?ti{Yc}Y>4Xw@?fieK8!X~>_
zg`xn%K5rkt(6Aw4XSh&%E4Mm6Z_dR#$B3?^2usjMQGh%q7Ks3k{#8PxYi1}roX9hb
zBbI_L!&(0dkuI#j3eHsF-`cTq^~nqNs8$)4F?c#Drtu081H4`bsP#66;LhH>qJ(5O
zJA_x!ilRp3VxqBo#N5h!BBe!IU7`)7-%@JC6<(cUekZxq{1*gF6D|(>5ZMr=(2Y0@
zvTQj%9<jBaGm(d7=DobPTg=}!mH0pk)@t`aG8l&z2^v2%;GqjhHOi`BYhG(qzQQxB
zVV5JxeR|YE^Ed$>Vni(R>4Ok^EAeVqLTtqUn4}cIYFlEF^<?%SEBL4mR&qPYcm<xh
zg`O<qMJ*(%+6E2G6oiBc&BV#m$(xZvQk;Vn^b!*}8^q{e#M_1L6;f{-B2SIhMj4u%
zc?Bd=U)MOj?vNg_p>Z_hEs#u$-w~F0Aq3!Pe}{qX(xfA4Vbht?zip5j-N7S@<5ajs
z-;mpb?Lx_v^o9rQeu2rbY!Kxg%dh;q%*Rla&_OvBT4NA*sM}A>!Up&iTU_a!j0#dv
z!k2ti;8&X{2jM_cHB4e@Edqu0>gtmGIp#yG%u!F|Eom`?Pr&5Ty+Z1(jyU8XQwK1`
zL1^mMkU)Gk$ma+8#|BSQON*i5q}0HAZvnkamn+lvqZ%Bl9BT+K&rGt%{)xm=vn~MD
zlkxi6wQz@fsFb9DSg>NJ=#p>LW>Cnj3&@A5u&SvBpDwCk;e?XY;1C_WM*l(CVfX7V
z%(NzKH<wuK02Nr&c&#!HM(7X^6!9i#Jmvw_z^;z7HY}}(xbt8Y_-iKncj&0}GZ!+o
zC)v4z8wlf=p^=<r+JUH6xI~^H1yz!jX(m?hAr6@goVl_=l1SINks@5)CX|lY9Y;}a
zkN(`pi}UO4yc0;z${_h=X%o^nkL<^nm!XVrd-q=6&n)!#KVA7vp%-imP+EI$3R-To
z<sGOR`R3k9$(xLPEgk~Yg0HA3aJp?C={#WmL;i7i#w6Q$sIBnJ)lDv>+Q|D?JsE~9
z3YU~>YoW?W(i4rrNWMi>jttKMe?bSP=nzm$%W%b_G~4NnN&dAsX^T$#**P^aE{JbD
zm$IOW>(^i7{o5~{$#qaLqGl}L75EA3#{k*LgP}KY>bIq!NTi?<VCPUtGS`8KM#*4i
zhX;N-BZ;0xf9<k!-{gM3YgONH2+LLQ<DMzhRvjvGiTU*m;8Hy}sBfa6CRK<JWs%rI
zO=gTOZV_d$VI)p{Fu7Jq^3)Xdl|jrJA0j(VKb9j^kCvD^h4Bua0lCNyc)F!%hR#?%
zM+Tqffu1okTd*5LQ4#xa{VMkq60Sy7EE5*40?8E0K}`?^I(2CesF2{oJ^1(S9`ko?
z^H?cksV9f~JOeqjB%y2T`>2&i+_NVa|I&&oYZb~*RR)~K>E^>Eo%T$I`?NUu<o@>x
zZCNX)7&qx{({$ov?)Amsf~H?juOJbY?YCd%jU2XMB(f_pPy$U<kR(O-?UR<S|4-%B
zni%%0N!rbkx2e7M(|r8taADzFcw7IrwSKKF;HUcSwM9>VCG-TRWXXXzf`F|6b1@9Q
zS8ya=P!BSXd&BHwgs~e9K}UWWWD99}1RvC|{J7gMqew7oMC?CaqSU;cDh$7F9?y{t
zucT_%M$lZ0loC+TR6^q79oU#m<k9FrEHl7RPNo_rXon4ABsYSauK%NhMyeOWsuv}|
zW{$P0`CBN|4e5ex!ZD<D+5xNzj|gTS<LnzzzlJ1FKceVY0KCMZwr@*zsu=PE71o<q
z$Y6k6K!(wQojaG<Vq<Dxc_d#F$A-k{f<lxRKA8s5KnQ;kBO3wo0>lZ@LRj3sp<T?Y
zn-wH>p^;XTVuZ8=6#duh9vrVbe7=oCeUzGP1H&L$(3@{tkN69usWgh6lo^Rk^?M8R
z=X$+98ih(2E3}-=Rrf$XeZEobk_>@xbd0+>9;`%_GOXd6h|0k>HB?6?JjLb9fGM2(
zx?k*ZLjf<^8RC`Dq@52sFjd{z`*9SsU8md_4@PnUMXMJ?D9?UA31kW=c}4tX13F^|
z{KS5UsocC<L=ud+wvu|4Dt4(Sld^#f-f)N;j*BJL`c_H-aqi6g|1THB?Kt91_}ok?
zb&ur#jEDuqTVWX$U69h5(}<`0!mVPkfq2r7c?UI7@V;DG#zLkXMTA+2RLY_XJ?m(E
zaS26UlQ5%#(u)6!Edd?aX90zG#;O~CBX|Fziyw#H-RDQ?pqtv>rz_D%IA}RhF2f9b
zI9d9OB=5z&-AUWcEfzc5o9^)(=q!65W7-0hw02{55ku}v#@B#3{G!#O(>Rv^V65p`
zg+4O|9Y1fuXp$~aNeBbUmVDe|ik?$0xAaHD#yvsH^`bT!S}<q-iyk7Hq{D#eTRp~x
zR%{j&x`v|I^rF@8t2ZA&pL!N+wF&*!(FBJVY&dn1Ap-@xqYH!8o0`_VhQ9=kTlAtg
zK`Z$PXzvgdz=G%yK*p;8f`Eu2o*(U*{26A${5`Uk3^Y8ks;&@1>5$a!3!3<&n78D$
zUD=Og3-;duIzV05?jWh#js1RcM?T_aclTwTWd3l5?s{-#|I(?4=mm_DwT?9~&vW)8
z3VC`q`rap_lwq*?{>Nty#+xt7cGwA$z5U;B>FX-}cVGGrn*X~m|J|4W7?}SahW{Rh
p{~m__gBSkqC3(&zxi0MI*L>1zWB41VIQ;M3g&!<9|JRk<{~t66&b$Bs

literal 0
HcmV?d00001

diff --git a/docs/screenshots/compact-picker/compact-panel-light-wide.png b/docs/screenshots/compact-picker/compact-panel-light-wide.png
new file mode 100644
index 0000000000000000000000000000000000000000..7a978423ed9d9d332ad1efb04e1ffad654d8e3f0
GIT binary patch
literal 108940
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
N;Rg$@%v-zn{{duWhARL7

literal 0
HcmV?d00001

diff --git a/docs/screenshots/compact-picker/switch-states.png b/docs/screenshots/compact-picker/switch-states.png
new file mode 100644
index 0000000000000000000000000000000000000000..aeff59e84db06898a76dab790dbff25f6d5fb84a
GIT binary patch
literal 165934
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
KWa_2N!~P%Xy{O0l

literal 0
HcmV?d00001


From b42fc2b8fbf247dd92796c2917f277535cea91ac Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Thu, 1 Oct 2026 03:06:41 -0700
Subject: [PATCH 21/74] Bump version to v0.2.101

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 Cargo.lock | 34 +++++++++++++++++-----------------
 Cargo.toml |  2 +-
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e67ec7e690..e02ae30400 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12101,7 +12101,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "clap",
@@ -12123,7 +12123,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "async-trait",
  "chrono",
@@ -12147,7 +12147,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "chrono",
  "loro",
@@ -12161,7 +12161,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12201,7 +12201,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12228,14 +12228,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12253,7 +12253,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "serde",
  "serde_json",
@@ -12270,7 +12270,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12298,7 +12298,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -12309,7 +12309,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12328,7 +12328,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -12351,7 +12351,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -12385,7 +12385,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -12402,7 +12402,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "clap",
@@ -12417,7 +12417,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -12484,7 +12484,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.100"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "futures",
diff --git a/Cargo.toml b/Cargo.toml
index ad21a07a80..e0ba7ab3c9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.100"
+version = "0.2.101"
 edition = "2024"
 license = "MIT"
 publish = false

From 5d5d935991d3a659a5bba25f004874d41a74e7ae Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Thu, 1 Oct 2026 12:07:48 -0700
Subject: [PATCH 22/74] CI: cover cursor paths in ui-tests, verify nextest
 after cache restore, nightly release-profile run

- ui-tests.yml also triggers on scripts/*cursor-sdk* and cursor-*.yml, so the
  Rust half that moved out of cursor-compatibility still runs for those PRs.
- linux-ci installs nextest after rust-cache restores ~/.cargo/bin, so the
  checksum-verified binary is the one used.
- release-profile-tests.yml runs the Linux core and UI suites daily with
  --release (no cache save), backstopping the dev-profile switch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/actions/linux-ci/action.yml         | 10 +++--
 .github/workflows/release-profile-tests.yml | 47 +++++++++++++++++++++
 .github/workflows/ui-tests.yml              |  4 ++
 scripts/ci/test-core.sh                     |  3 +-
 4 files changed, 59 insertions(+), 5 deletions(-)
 create mode 100644 .github/workflows/release-profile-tests.yml

diff --git a/.github/actions/linux-ci/action.yml b/.github/actions/linux-ci/action.yml
index 59d0b9f7ed..0e306e4eb1 100644
--- a/.github/actions/linux-ci/action.yml
+++ b/.github/actions/linux-ci/action.yml
@@ -58,10 +58,6 @@ runs:
         path: ~/apt-debs/*.deb
         key: apt-debs-v1-${{ inputs.apt-cache }}-${{ hashFiles('scripts/ci/apt-install.sh') }}
 
-    - name: Install cargo-nextest
-      shell: bash
-      run: bash scripts/ci/install-nextest.sh
-
     # Exported for the rest of the job. Tests and the browser fixture are built in
     # the dev profile without debug info (smaller, faster to link). CARGO_* variables
     # are part of the rust-cache key, so every job sharing a cache must set the same.
@@ -76,3 +72,9 @@ runs:
         add-job-id-key: false
         save-if: ${{ inputs.save-rust-cache == 'true' && github.ref == 'refs/heads/main' }}
         cache-on-failure: true
+
+    # After the cache restore, so the checksum-verified binary is the one that
+    # runs (rust-cache restores ~/.cargo/bin).
+    - name: Install cargo-nextest
+      shell: bash
+      run: bash scripts/ci/install-nextest.sh
diff --git a/.github/workflows/release-profile-tests.yml b/.github/workflows/release-profile-tests.yml
new file mode 100644
index 0000000000..56d1af48b0
--- /dev/null
+++ b/.github/workflows/release-profile-tests.yml
@@ -0,0 +1,47 @@
+name: Release-profile tests
+
+# Pull-request and main CI test the dev profile (fast rebuilds). This runs the
+# same Linux suites once a day against the optimized release profile that
+# ships, so optimization-only failures still surface. It does not save a Rust
+# cache, so it cannot evict the main-seeded caches pull requests depend on.
+
+on:
+  schedule:
+    - cron: '17 7 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-profile-tests
+  cancel-in-progress: false
+
+jobs:
+  core-tests:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/linux-ci
+        with:
+          rust-cache: release-profile-core
+      - name: Harness, engine, sync, update, doc and preview tests (release)
+        run: scripts/ci/test-core.sh --release
+
+  ui-tests:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/linux-ci
+        with:
+          rust-cache: release-profile-ui
+          apt-cache: gpui
+          apt-packages: >-
+            libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev
+            libx11-dev libxcb1-dev libx11-xcb-dev
+            libfontconfig1-dev libfreetype-dev libasound2-dev
+            libvulkan-dev pkg-config cmake libwebkit2gtk-4.1-dev libjson-glib-dev
+      - name: UI and headless layout regressions (release)
+        run: cargo nextest run --config-file scripts/ci/nextest.toml --locked --no-fail-fast --release -p zeron-ui --lib
diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 29b9e30006..32194852e4 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -9,6 +9,8 @@ on:
       - 'crates/**'
       - '.github/actions/linux-ci/**'
       - 'scripts/ci/**'
+      - 'scripts/*cursor-sdk*'
+      - '.github/workflows/cursor-*.yml'
       - 'scripts/test-linux-browser.sh'
       - 'scripts/run-macos-browser-fixture.sh'
       - 'dist/macos/Info.plist'
@@ -23,6 +25,8 @@ on:
       - 'crates/**'
       - '.github/actions/linux-ci/**'
       - 'scripts/ci/**'
+      - 'scripts/*cursor-sdk*'
+      - '.github/workflows/cursor-*.yml'
       - 'scripts/test-linux-browser.sh'
       - 'scripts/run-macos-browser-fixture.sh'
       - 'dist/macos/Info.plist'
diff --git a/scripts/ci/test-core.sh b/scripts/ci/test-core.sh
index 539b1a09ab..5a25c8686c 100755
--- a/scripts/ci/test-core.sh
+++ b/scripts/ci/test-core.sh
@@ -16,6 +16,7 @@
 #                  they are listed instead of globbed to avoid compiling them.
 # nextest does not run doctests; these crates have none (their doc comments
 # contain no Rust code blocks).
+# Extra arguments are passed to nextest (the nightly job adds `--release`).
 set -euo pipefail
 cd "$(dirname "$0")/../.."
 
@@ -30,4 +31,4 @@ done
 exec cargo nextest run --config-file scripts/ci/nextest.toml --locked --no-fail-fast \
   -p zeron-harness -p zeron-engine -p zeron-sync -p zeron-update -p zeron-doc -p zeron-preview \
   --features zeron-harness/native-fixture \
-  --lib --bins "${tests[@]}"
+  --lib --bins "${tests[@]}" "$@"

From 7aed43b472ef3fbed1cb9d8e74c5fe6c5bc0cd15 Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Thu, 1 Oct 2026 12:09:05 -0700
Subject: [PATCH 23/74] CI(macos): run CoreText tests on macOS, drop /etc/hosts
 patch, harden nextest download

- zeron-text's coretext tests are #![cfg(target_os = "macos")]; moving the
  mobile core tests to Linux silently dropped them. macos-native now runs
  binary_id(zeron-text::coretext).
- run-macos-fixture.sh no longer writes /etc/hosts: preview hostnames are meant
  to resolve through WebKit's per-domain proxy, so a DNS fallback could let the
  fixture pass with that path broken. Retries and warnings stay.
- nextest download: https-only, TLS 1.2+, retries, extract only cargo-nextest.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/macos.yml     | 15 ++++++++-------
 scripts/ci/run-macos-fixture.sh | 23 +++++------------------
 2 files changed, 13 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 16c74e478f..fd5b513090 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -97,14 +97,14 @@ jobs:
           # Pinned release, verified against a checksum.
           version=0.9.146
           sha256=39785160b3c2f6ed9a765049cf4fa79f3b39aa02eb7598a5a0e2a1a0b9ffb9a8
-          curl -fsSL -o "$RUNNER_TEMP/nextest.tar.gz" \
+          curl --proto '=https' --tlsv1.2 -fsSL --retry 5 -o "$RUNNER_TEMP/nextest.tar.gz" \
             "https://github.com/nextest-rs/nextest/releases/download/cargo-nextest-$version/cargo-nextest-$version-universal-apple-darwin.tar.gz"
           echo "$sha256  $RUNNER_TEMP/nextest.tar.gz" | shasum -a 256 -c -
-          tar -xzf "$RUNNER_TEMP/nextest.tar.gz" -C "$HOME/.cargo/bin"
+          tar -xzf "$RUNNER_TEMP/nextest.tar.gz" -C "$HOME/.cargo/bin" cargo-nextest
       - name: Build tests and fixtures
         run: |
           cargo nextest run --no-run --locked \
-            -p zeron-update -p zeron-preview -p zeron-ui \
+            -p zeron-update -p zeron-preview -p zeron-ui -p zeron-text \
             --features zeron-ui/browser-fixture --lib --tests
           cargo build --locked -p zeron-update -p zeron-preview -p zeron-ui \
             --features zeron-ui/browser-fixture --example browser-fixture --example preview-fixture
@@ -113,12 +113,14 @@ jobs:
           # Match the old `cargo check --release`: no debug assertions.
           CARGO_PROFILE_DEV_DEBUG_ASSERTIONS: false
         run: cargo check --locked -p zeron
-      - name: Updater, preview and native UI regressions
+      - name: Updater, preview, CoreText and native UI regressions
         run: |
+          # zeron-text's coretext tests are macOS-only (#![cfg(target_os = "macos")]); its other
+          # tests run on Linux in ios-core.
           cargo nextest run --no-fail-fast --locked \
-            -p zeron-update -p zeron-preview -p zeron-ui \
+            -p zeron-update -p zeron-preview -p zeron-ui -p zeron-text \
             --features zeron-ui/browser-fixture --lib --tests \
-            -E 'package(zeron-update) | package(zeron-preview) | (binary_id(zeron-ui) & (test(native_diff_font_geometry) | test(/notify::tests::/)))'
+            -E 'package(zeron-update) | package(zeron-preview) | binary_id(zeron-text::coretext) | (binary_id(zeron-ui) & (test(native_diff_font_geometry) | test(/notify::tests::/)))'
       - name: Native browser regression and screenshots
         timeout-minutes: 7
         env:
@@ -143,7 +145,6 @@ jobs:
         timeout-minutes: 5
         env:
           ZERON_PREVIEW_AUTO_OPEN: 1
-          PREVIEW_HOSTS: 1
         run: |
           VITE_BINARY="$GITHUB_WORKSPACE/edge/node_modules/vite/bin/vite.js" scripts/ci/run-macos-fixture.sh target/debug/examples/preview-fixture "$RUNNER_TEMP/preview-captures"
           test -f "$RUNNER_TEMP/preview-captures/result.txt"
diff --git a/scripts/ci/run-macos-fixture.sh b/scripts/ci/run-macos-fixture.sh
index 52b1ed2863..ce5c407449 100755
--- a/scripts/ci/run-macos-fixture.sh
+++ b/scripts/ci/run-macos-fixture.sh
@@ -4,10 +4,9 @@
 # untouched; only the wrapper changes:
 #  * bounded retries: each attempt has its own timeout (instead of one long hang) and a failed attempt
 #    is reported with a ::warning:: so flakes stay visible. A real regression fails every attempt.
-#  * PREVIEW_HOSTS=1 (preview fixture only): WebKit sometimes fails to resolve *.localhost
-#    (NSURLErrorDomain -1003) although the preview proxy is listening; map the fixture hostnames to
-#    loopback in /etc/hosts so DNS can never be the reason. The fixture still goes through the same
-#    per-domain proxy path; this only removes the DNS race.
+# The preview fixture deliberately gets no /etc/hosts entries: the app routes *.localhost preview
+# hostnames through WebKit's per-domain proxy, and an NSURLErrorDomain -1003 means that path failed,
+# which is what the fixture exists to catch.
 # usage: run-macos-fixture.sh <fixture-binary> <capture-dir>
 set -uo pipefail
 ROOT="${ZERON_ROOT:-$(cd "$(dirname "$0")/../.." && pwd)}"
@@ -16,16 +15,6 @@ OUT="$2"
 ATTEMPTS="${FIXTURE_ATTEMPTS:-3}"
 ATTEMPT_TIMEOUT="${FIXTURE_ATTEMPT_TIMEOUT:-70}"
 
-if [ -n "${PREVIEW_HOSTS:-}" ]; then
-  # Same slug() as crates/preview/src/catalog.rs: device label = slug(hostname).
-  label=$(hostname | python3 -c 'import re,sys; s=re.sub(r"[^a-z0-9]+","-",sys.stdin.read().strip().lower()).strip("-")[:48].strip("-"); print(s or "project")')
-  for svc in fieldnotes fieldnotes-vite fieldnotes-api fieldnotes-node fieldnotes-web fieldnotes-server; do
-    echo "127.0.0.1 $label.$svc.localhost"
-    echo "::1 $label.$svc.localhost"
-  done | sudo tee -a /etc/hosts >/dev/null
-  echo "hosts entries added for device label '$label'"
-fi
-
 # macOS has no coreutils `timeout`; do it in bash.
 run_with_timeout() {
   local secs=$1; shift
@@ -47,10 +36,8 @@ for attempt in $(seq 1 "$ATTEMPTS"); do
     exit 0
   fi
   echo "::warning::$(basename "$BINARY") attempt $attempt failed"
-  if [ -n "${PREVIEW_HOSTS:-}" ]; then
-    dscacheutil -q host -a name "$label.fieldnotes.localhost" || true
-    lsof -nP -iTCP:7331 -sTCP:LISTEN || true
-  fi
+  # Is the preview proxy listening? (Nothing for the browser fixture.)
+  lsof -nP -iTCP:7331 -sTCP:LISTEN || true
   mkdir -p "$OUT.failed-$attempt"
   cp -R "$OUT"/. "$OUT.failed-$attempt"/ 2>/dev/null || true
   pkill -f 'vite/bin/vite.js' 2>/dev/null || true

From a5c00e0b507a7f520bc40be4dd8e15dcedd2141e Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Thu, 1 Oct 2026 13:00:33 -0700
Subject: [PATCH 24/74] CI(macos): run the macOS jobs on macos-latest, as
 before

macos-14 is two releases behind what macos-latest provides (macOS 26), and
zeron-text's CoreText tokenizer check fails there (136/20000 differ, limit 20)
while passing on macos-latest in main's runs. Keep the native, frame-source
and iOS jobs on the image the old jobs used.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/macos.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index fd5b513090..23a0898b18 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -80,7 +80,7 @@ jobs:
   # Updater and preview tests, native UI regressions and the two native WebKit fixtures. Everything is
   # compiled once (one cargo invocation, so dependencies are built once) and then run.
   macos-native:
-    runs-on: macos-14
+    runs-on: macos-latest
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
@@ -158,7 +158,7 @@ jobs:
 
   # gpui_macos lives in the pinned GPUI checkout, a separate workspace with its own cache.
   macos-frame-source:
-    runs-on: macos-14
+    runs-on: macos-latest
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
@@ -225,7 +225,7 @@ jobs:
   ios-tests:
     needs: [changes, ios-core, macos-frame-source]
     if: needs.changes.outputs.ios == 'true'
-    runs-on: macos-15
+    runs-on: macos-latest
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4

From 27480d99b9b75d31d01832248bec3f898bd64dcc Mon Sep 17 00:00:00 2001
From: Wing <44917547+wingleeio@users.noreply.github.com>
Date: Thu, 1 Oct 2026 13:29:41 -0700
Subject: [PATCH 25/74] OpenCode 2.x: fix instant "Run failed" (cold version
 probe), show start failures (#686)

* OpenCode: show start failures and stop failing runs on an unknown version

A run whose harness fails before streaming only reached the live journal,
so the chat showed "Run failed" with no assistant entry and no reason.
The engine now writes the error as an assistant entry.

OpenCode runs (not discovery) probe `opencode --version` to pick the MCP
config shape, and that probe's failure is cached per binary. One slow or
unparseable probe made every later run fail at startup until restart.
An unknown version now starts the server without the Zeron MCP block
and logs a warning.

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

* OpenCode: retry a cold version probe; own both password variables

Root cause of the instant "Run failed" on OpenCode 2.x: runs probe
`opencode --version` (2s cap) to pick the MCP config shape, and the
shared probe caches a timeout for the binary's lifetime. A freshly
upgraded binary's first exec waits on the OS malware scan (1.1s on an
M-series Mac, more on slower machines or under Defender), so one slow
probe failed every later run in ~100ms until restart. Reproduced
against real 2.0.20 with a cold first probe.

The OpenCode path now retries past the cached failure with a 30s budget
and clears the stale cache entry on success, so the Zeron MCP server
stays injected. Only if that also fails does it start without MCP.

2.x also reads OPENCODE_PASSWORD before OPENCODE_SERVER_PASSWORD, so a
user's own value locked Zeron out of its server with a 401; both now
carry ours. Start failures are logged.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/sessions.rs      |  19 +++
 crates/engine/tests/e2e.rs         |  64 ++++++++++
 crates/harness/src/executable.rs   |   2 +-
 crates/harness/src/opencode/mod.rs | 192 +++++++++++++++++++++++++----
 4 files changed, 252 insertions(+), 25 deletions(-)

diff --git a/crates/engine/src/sessions.rs b/crates/engine/src/sessions.rs
index eaaf6dd8d4..9504e005b3 100644
--- a/crates/engine/src/sessions.rs
+++ b/crates/engine/src/sessions.rs
@@ -1892,6 +1892,25 @@ async fn drive_run(
         Ok(stream) => stream,
         Err(err) => {
             let message = err.to_string();
+            tracing::warn!(chat = %chat_id, harness = ?harness_id, error = %message, "run failed to start");
+            // The journal alone is live-only: without an entry the transcript
+            // shows "Run failed" with no reason (an OpenCode server that never
+            // booted looked exactly like that).
+            let parts = [MessagePart::Error {
+                id: "e0".into(),
+                message: message.clone(),
+            }];
+            if let Err(err) = finish_segment(
+                &doc,
+                None,
+                &new_id(),
+                &device_id,
+                now_ms(),
+                &parts,
+                MessageStatus::Complete,
+            ) {
+                tracing::warn!(chat = %chat_id, error = %err, "start failure entry failed");
+            }
             inner.publish(
                 &chat_id,
                 &AgentEvent::Error {
diff --git a/crates/engine/tests/e2e.rs b/crates/engine/tests/e2e.rs
index 693f58fbc1..18ffb0c5cc 100644
--- a/crates/engine/tests/e2e.rs
+++ b/crates/engine/tests/e2e.rs
@@ -3223,3 +3223,67 @@ async fn real_image_generation_profile_smoke() {
     );
     core.sessions.shutdown().await;
 }
+
+/// A harness that fails before streaming (an OpenCode server that never
+/// booted) must leave its reason in the transcript, not only a bare
+/// "Run failed" status.
+#[tokio::test(flavor = "multi_thread")]
+async fn start_failure_lands_in_the_transcript() {
+    struct FailsToStart;
+    #[async_trait]
+    impl Harness for FailsToStart {
+        fn id(&self) -> HarnessId {
+            HarnessId::Mock
+        }
+        fn display_name(&self) -> &str {
+            "FailsToStart"
+        }
+        fn supports_steering(&self) -> bool {
+            false
+        }
+        fn steering_mode(&self) -> SteeringMode {
+            SteeringMode::TurnBoundary
+        }
+        fn reasoning_levels(&self) -> &[ReasoningLevel] {
+            &[]
+        }
+        async fn models(&self) -> Result<Vec<Model>, HarnessError> {
+            Ok(vec![])
+        }
+        async fn run(
+            &self,
+            _request: RunRequest,
+            _controls: RunControls,
+        ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
+            Err(HarnessError::Protocol("server never booted".into()))
+        }
+    }
+
+    let dir = tempfile::tempdir().unwrap();
+    let core = assemble(dir.path(), Arc::new(FailsToStart));
+    let handle = core.doc_host.open(CHAT).unwrap();
+    queue_as_viewer(
+        handle.doc(),
+        "cmd-run-fails",
+        SessionCommandPayload::Run {
+            request: run_request("hello"),
+            message_id: "m-1".into(),
+        },
+    );
+    wait_for(
+        || core.sessions.session_status(CHAT).map(|s| s.status) == Some(SessionStatus::Errored),
+        "errored",
+    )
+    .await;
+    let entries = entries_now(&core);
+    let assistant = entries
+        .iter()
+        .find(|e| e.role == MessageRole::Assistant)
+        .expect("assistant entry for the failed start");
+    assert_eq!(assistant.status, Some(MessageStatus::Complete));
+    assert!(matches!(
+        assistant.parts.as_slice(),
+        [MessagePart::Error { message, .. }] if message.contains("server never booted")
+    ));
+    core.sessions.shutdown().await;
+}
diff --git a/crates/harness/src/executable.rs b/crates/harness/src/executable.rs
index 4971f05541..a4c672d8ad 100644
--- a/crates/harness/src/executable.rs
+++ b/crates/harness/src/executable.rs
@@ -276,7 +276,7 @@ pub fn binary_version(path: &Path) -> Option<semver::Version> {
     version
 }
 
-fn parse_version(bytes: &[u8]) -> Option<semver::Version> {
+pub(crate) fn parse_version(bytes: &[u8]) -> Option<semver::Version> {
     String::from_utf8_lossy(bytes)
         .split_whitespace()
         .find_map(|word| {
diff --git a/crates/harness/src/opencode/mod.rs b/crates/harness/src/opencode/mod.rs
index 252f6da516..a288cbe664 100644
--- a/crates/harness/src/opencode/mod.rs
+++ b/crates/harness/src/opencode/mod.rs
@@ -605,33 +605,35 @@ impl Server {
             .arg(port.to_string())
             .arg("--hostname")
             .arg("127.0.0.1")
+            // 2.x prefers OPENCODE_PASSWORD over the legacy name; a user's
+            // own value would otherwise lock us out of our server (401).
+            .env("OPENCODE_PASSWORD", &password)
             .env("OPENCODE_SERVER_PASSWORD", &password)
             .env("OPENCODE_CLIENT", "zeron");
         if let Some(mcp) = mcp {
-            let version_exe = exe.to_path_buf();
-            let version = tokio::task::spawn_blocking(move || {
-                crate::executable::binary_version(&version_exe)
-            })
-            .await
-            .map_err(|e| HarnessError::Protocol(format!("opencode version probe: {e}")))?
-            .ok_or_else(|| {
-                HarnessError::Protocol(
-                    "cannot determine opencode version for MCP configuration".into(),
-                )
-            })?;
-            let protocol = if version.major >= 2 {
-                Protocol::V2
-            } else {
-                Protocol::V1
-            };
-            cmd.env(
-                "OPENCODE_CONFIG_CONTENT",
-                mcp_config(
-                    std::env::var("OPENCODE_CONFIG_CONTENT").ok().as_deref(),
-                    mcp,
-                    protocol,
-                )?,
-            );
+            // The config shape differs by generation. If even the cold probe
+            // can't tell, run without the Zeron MCP server rather than fail.
+            match opencode_version(exe).await {
+                Some(version) => {
+                    let protocol = if version.major >= 2 {
+                        Protocol::V2
+                    } else {
+                        Protocol::V1
+                    };
+                    cmd.env(
+                        "OPENCODE_CONFIG_CONTENT",
+                        mcp_config(
+                            std::env::var("OPENCODE_CONFIG_CONTENT").ok().as_deref(),
+                            mcp,
+                            protocol,
+                        )?,
+                    );
+                }
+                None => tracing::warn!(
+                    binary_path = %exe.display(),
+                    "opencode version unknown; starting without the Zeron MCP server"
+                ),
+            }
         }
         crate::compose_child_path(&mut cmd, exe);
         if let Some(cwd) = cwd {
@@ -4234,6 +4236,46 @@ mod context_tests {
     }
 }
 
+/// Budget for a `--version` the shared probe gave up on: a freshly installed
+/// binary's first exec waits on the OS malware scan (1.1s on an M-series Mac
+/// for 2.0.20, longer on slower machines and under Windows Defender).
+const COLD_VERSION_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// The shared probe caps `--version` at 2s and caches a timeout for the
+/// binary's lifetime, so one cold first exec after an upgrade failed every
+/// later run instantly until restart. Retry past that cache with a longer
+/// budget, and on success clear the cached failure for other callers.
+async fn opencode_version(exe: &std::path::Path) -> Option<semver::Version> {
+    let cached_exe = exe.to_path_buf();
+    let cached =
+        tokio::task::spawn_blocking(move || crate::executable::binary_version(&cached_exe))
+            .await
+            .ok()
+            .flatten();
+    if cached.is_some() {
+        return cached;
+    }
+    let mut cmd = Command::new(exe);
+    cmd.arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .kill_on_drop(true);
+    let output = tokio::time::timeout(COLD_VERSION_TIMEOUT, cmd.output())
+        .await
+        .ok()?
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let version = crate::executable::parse_version(&output.stdout)
+        .or_else(|| crate::executable::parse_version(&output.stderr))?;
+    if let Some(stem) = exe.file_stem().and_then(|s| s.to_str()) {
+        crate::executable::invalidate_versions(&[stem]);
+    }
+    Some(version)
+}
+
 /// Inline config is the final user config layer. Preserve inherited overrides
 /// and other MCP servers; never write chat identity into a shared config file.
 fn mcp_config(
@@ -4346,6 +4388,108 @@ http.createServer((req, res) => {{
         }
     }
 
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn unknown_version_starts_without_mcp_instead_of_failing() {
+        use std::os::unix::fs::PermissionsExt;
+        let fixture = tempfile::tempdir().unwrap();
+        let exe = fixture.path().join("opencode");
+        // `--version` fails (a probe that timed out or printed no version).
+        let script = r#"#!/usr/bin/env node
+const http = require('node:http');
+if (process.argv.includes('--version')) process.exit(1);
+const config = process.env.OPENCODE_CONFIG_CONTENT ?? null;
+const port = Number(process.argv[process.argv.indexOf('--port') + 1]);
+http.createServer((req, res) => {
+  res.setHeader('content-type', 'application/json');
+  if (req.url === '/config-probe') { res.end(JSON.stringify({config})); return; }
+  if (req.url === '/api/info') { res.end(JSON.stringify({version: '2.0.20'})); return; }
+  res.statusCode = 404; res.end('{}');
+}).listen(port, '127.0.0.1');
+"#;
+        std::fs::write(&exe, script).unwrap();
+        std::fs::set_permissions(&exe, std::fs::Permissions::from_mode(0o700)).unwrap();
+        let mcp = zeron_proto::McpServer {
+            name: "zeron".into(),
+            command: "zeron".into(),
+            args: vec!["mcp".into()],
+            env: Default::default(),
+        };
+        let mut server = Server::spawn(
+            &exe,
+            fixture.path().to_str(),
+            Duration::from_secs(5),
+            Some(&mcp),
+        )
+        .await
+        .expect("an unknown version must not fail the run");
+        let probe = server.get_json("/config-probe", None).await.unwrap();
+        server.shutdown(Duration::from_millis(100)).await;
+        assert_eq!(probe["config"], Value::Null);
+    }
+
+    /// A freshly installed binary's first `--version` outlasts the shared
+    /// 2s probe (OS malware scan). That cached failure used to fail every
+    /// run; the cold retry must still find 2.x and inject the MCP config.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn cold_first_version_probe_still_injects_mcp() {
+        use std::os::unix::fs::PermissionsExt;
+        let fixture = tempfile::tempdir().unwrap();
+        let exe = fixture.path().join("opencode");
+        let warmed = fixture.path().join("warmed");
+        let script = format!(
+            r#"#!/usr/bin/env node
+const fs = require('node:fs');
+const http = require('node:http');
+if (process.argv.includes('--version')) {{
+  const cold = !fs.existsSync({warmed:?});
+  fs.writeFileSync({warmed:?}, '');
+  setTimeout(() => {{ console.log('opencode v2.0.20'); process.exit(0); }}, cold ? 3000 : 0);
+}} else {{
+  const config = JSON.parse(process.env.OPENCODE_CONFIG_CONTENT);
+  const auth = {{
+    password: process.env.OPENCODE_PASSWORD,
+    legacy: process.env.OPENCODE_SERVER_PASSWORD,
+  }};
+  const port = Number(process.argv[process.argv.indexOf('--port') + 1]);
+  http.createServer((req, res) => {{
+    res.setHeader('content-type', 'application/json');
+    if (req.url === '/config-probe') {{
+      res.end(JSON.stringify({{server: config.mcp.servers.zeron, auth}})); return;
+    }}
+    if (req.url === '/api/info') {{ res.end(JSON.stringify({{version: '2.0.20'}})); return; }}
+    res.statusCode = 404; res.end('{{}}');
+  }}).listen(port, '127.0.0.1');
+}}
+"#
+        );
+        std::fs::write(&exe, script).unwrap();
+        std::fs::set_permissions(&exe, std::fs::Permissions::from_mode(0o700)).unwrap();
+        let mcp = zeron_proto::McpServer {
+            name: "zeron".into(),
+            command: "zeron".into(),
+            args: vec!["mcp".into()],
+            env: Default::default(),
+        };
+        for _ in 0..2 {
+            let mut server = Server::spawn(
+                &exe,
+                fixture.path().to_str(),
+                Duration::from_secs(10),
+                Some(&mcp),
+            )
+            .await
+            .expect("a slow first --version must not fail the run");
+            let probe = server.get_json("/config-probe", None).await.unwrap();
+            server.shutdown(Duration::from_millis(100)).await;
+            assert_eq!(probe["server"]["command"], json!(["zeron", "mcp"]));
+            // 2.x reads OPENCODE_PASSWORD first: both must carry ours.
+            assert!(probe["auth"]["password"].is_string());
+            assert_eq!(probe["auth"]["password"], probe["auth"]["legacy"]);
+        }
+    }
+
     #[test]
     fn mcp_injection_preserves_config_and_scopes_identity_for_both_protocols() {
         let mut mcp = zeron_proto::McpServer {

From 80b946b153e431f8e3fdd7a99faf81b23c77706c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ga=C3=ABl=20Cado?=
 <130941423+gaelcado@users.noreply.github.com>
Date: Fri, 2 Oct 2026 00:16:51 +0200
Subject: [PATCH 26/74] Add opt-in on-device dictation to the desktop composer
 (#591)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(voice): add local Parakeet v3 capture and transcription backend

* feat(ui): add opt-in dictation settings and composer controls

* build(macos): package microphone permissions and voice attribution

* docs: describe desktop dictation behavior and runtime limits

* fix(ui): clarify dictation states and cancellation controls

* fix(ui): keep composer model controls right aligned

* feat(ui): give Voice a dedicated settings page

* fix(voice): support all native microphone sample formats

* fix(voice): retain model cleanup after interrupted downloads

* fix(ui): preserve dictation while pasted references resolve

* fix(ui): cancel dictation with Escape across composer controls

* fix(ui): refresh dictation state after empty undo and redo

* fix(ui): preserve dictated words on blank recognition results

* fix(voice): clarify retries while native inference finishes

* test(ui): verify repeated Send preserves unfinished dictation

* style(ui): format settings modules

* feat(voice): add microphone selection and streamline Voice settings

* feat(ui): visualize live dictation with a waveform and recording clock

* fix(ui): preserve waveform paint opacity

* feat(ui): morph composer controls into dictation track

* test(voice): exercise real inference on every desktop release target

* fix(voice): keep device choices fresh and cancellation accessible

* ci(voice): verify Linux release packages on x86 and ARM

* ci(voice): keep model and package probes out of permanent CI

* fix(voice): detect missing ALSA before activating Linux installs

* fix(voice): capture audio while Parakeet loads

Run capture independently of serialized model loading and inference. Retain stopped audio until the model is ready, close capture before reporting load failure, and hold admission through native work and stream teardown.

Cover loading, cancellation, device startup, rapid Stop, admission, and recording limits with deterministic coordinator tests.

* test(ui): verify and measure nonblocking dictation startup

Cover selected-draft preservation, delayed final results, single Send delivery, and late results after loading failures or finalization timeouts.

Add transcript-free debug timing from dictation activation to the Listening state and clarify asynchronous capture cancellation.

* docs(voice): explain concurrent capture and startup timing

Document audio retention during loading, cancellation and model-removal limits, race coverage, and the native startup timing procedure.

* fix(ui): stop Shell saves from reverting settings chosen elsewhere

The Shell republished its whole cached UiSettings on every save
(navigation, pane resize) and only refreshed a hand-kept list of fields
first. Anything missing from that list was silently reverted: leaving
Settings → Voice turned dictation off, and the microphone choice,
compact transcript, fit-content code fences, and diff split/wrap toggles
had the same bug.

Replace the list with a three-way merge against the store snapshot the
Shell last synced: fields the Shell changed win, every other field keeps
the store's value. The merge destructures UiSettings exhaustively, so a
new field fails to compile until it is merged too.

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

* feat(voice): hold to talk, default Cmd+D, shortcut on the Voice page

Dictation is now hold to talk. Holding the microphone (pointer, or
Enter/Space while it is focused) or the shortcut records; releasing
transcribes. A pointer release outside the button still counts. For the
shortcut, letting go of its key or any of its modifiers ends the hold,
because macOS does not deliver key-up for Command chords. A release
within 300 ms explains hold to talk instead of transcribing a blip, and a
release that only answered the permission prompt records nothing.
Assistive-technology Click still starts and then finishes, since it
cannot hold.

The default shortcut is Cmd/Ctrl+D (unbound elsewhere). Its rebinding row
moves from Settings → Shortcuts to Settings → Voice through a reusable
ShortcutField that shares the Shortcuts page's chip and conflict rules.
Settings → Shortcuts re-reads the stored keymap while not recording, so
its own commits cannot revert a binding changed on the Voice page.

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

* fix(voice): harden capture, worker and download against edge cases

- Keep the capture flags outside the sample lock. The capture loop polled
  them under the mutex every 10 ms, so the real-time callback's try_lock
  could fail and drop a buffer of speech.
- Catch a native panic on the worker. A panicking job killed the only
  worker thread, leaving every later session "unavailable" until restart.
- Keep loaded weights when a session fails for a microphone or recording
  reason; dropping them made the next attempt reload 670 MB.
- Time out a download request whose response headers never arrive.

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

* fix(ui): dictation review fixes for focus, shortcuts and Windows

- Enter/Space hold on the focused microphone no longer moves focus to the
  editor, which sent its key-up (and auto-repeat spaces, or Enter-to-send)
  to the draft and left the microphone live.
- A key release caused by focus leaving no longer pulls focus back, and an
  unparseable stored shortcut falls back to the default when matching its
  release, as apply_keymap already does.
- Another source can take over a hold whose release went missing, so the
  microphone or shortcut can always end it.
- Dictation cannot start while a queued row is acquiring its edit lease,
  which would replace the draft and silently drop the transcript.
- With dictation off (the default) ⌘D propagates to any other binding of
  the chord instead of being swallowed in the composer.
- The Voice page's shortcut row is always shown, conflicts with a feature
  page's shortcut name that page, and recording stops if the window closes
  so Appshots' capture shortcut is never left suspended.
- Show Settings → Voice on Windows; the PR ships the Windows backend and
  only Appshots is macOS/Linux-only.

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

* fix(ui): give the composer microphone its siblings' hover

At rest the microphone snapped to a different surface colour on hover;
it now uses the paperclip's eased ink wash. While live it dims like Send,
and its focus ring and tooltip match the neighbouring composer buttons.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 ARCHITECTURE.md                           |    1 +
 Cargo.lock                                |  752 ++++++++++++-
 Cargo.toml                                |    1 +
 README.md                                 |    2 +-
 THIRD_PARTY_NOTICES.md                    |    6 +
 crates/ui/Cargo.toml                      |    1 +
 crates/ui/assets/icons/microphone.svg     |    1 +
 crates/ui/build.rs                        |   26 +
 crates/ui/src/composer.rs                 | 1195 +++++++++++++++++++-
 crates/ui/src/composer_dictation_tests.rs | 1199 +++++++++++++++++++++
 crates/ui/src/dictation.rs                |  323 ++++++
 crates/ui/src/dictation/glass.rs          |   89 ++
 crates/ui/src/dictation/meter.rs          |  247 +++++
 crates/ui/src/dictation/model.rs          |  560 ++++++++++
 crates/ui/src/dictation/permission.m      |   17 +
 crates/ui/src/dictation/waveform.rs       |  151 +++
 crates/ui/src/icons.rs                    |    1 +
 crates/ui/src/lib.rs                      |    1 +
 crates/ui/src/pickers.rs                  |    2 +-
 crates/ui/src/queue.rs                    |    9 +
 crates/ui/src/settings.rs                 |  120 ++-
 crates/ui/src/settings/accounts.rs        |   17 +-
 crates/ui/src/settings/appearance.rs      |    4 +-
 crates/ui/src/settings/devices.rs         |   12 +-
 crates/ui/src/settings/shortcuts.rs       |  539 ++++++---
 crates/ui/src/settings/thread_naming.rs   |   13 +-
 crates/ui/src/settings/widgets.rs         |    6 +-
 crates/ui/src/shell.rs                    |  140 ++-
 crates/ui/src/shell/actions_ui.rs         |   10 +-
 crates/voice/Cargo.toml                   |   21 +
 crates/voice/NOTICE.md                    |   17 +
 crates/voice/examples/verify.rs           |   30 +
 crates/voice/model.json                   |   23 +
 crates/voice/src/lib.rs                   |  602 +++++++++++
 crates/voice/src/resample.rs              |   81 ++
 crates/voice/src/session_tests.rs         |  298 +++++
 dist/macos/Dictation.entitlements         |    3 +
 dist/macos/Info-dev.plist                 |    2 +
 dist/macos/Info.plist                     |    2 +
 docs/design/desktop-parakeet-v3.md        |   17 +
 docs/reference/desktop-dictation.md       |   35 +
 edge/src/install.sh                       |   10 +-
 scripts/package-linux.sh                  |    5 +
 scripts/package-macos.sh                  |    5 +-
 scripts/package-windows.ps1               |    1 +
 scripts/run-macos-dev.sh                  |   14 +-
 46 files changed, 6376 insertions(+), 235 deletions(-)
 create mode 100644 crates/ui/assets/icons/microphone.svg
 create mode 100644 crates/ui/src/composer_dictation_tests.rs
 create mode 100644 crates/ui/src/dictation.rs
 create mode 100644 crates/ui/src/dictation/glass.rs
 create mode 100644 crates/ui/src/dictation/meter.rs
 create mode 100644 crates/ui/src/dictation/model.rs
 create mode 100644 crates/ui/src/dictation/permission.m
 create mode 100644 crates/ui/src/dictation/waveform.rs
 create mode 100644 crates/voice/Cargo.toml
 create mode 100644 crates/voice/NOTICE.md
 create mode 100644 crates/voice/examples/verify.rs
 create mode 100644 crates/voice/model.json
 create mode 100644 crates/voice/src/lib.rs
 create mode 100644 crates/voice/src/resample.rs
 create mode 100644 crates/voice/src/session_tests.rs
 create mode 100644 dist/macos/Dictation.entitlements
 create mode 100644 docs/design/desktop-parakeet-v3.md
 create mode 100644 docs/reference/desktop-dictation.md

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 417de516c5..e1fa1c6223 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -152,6 +152,7 @@ zeron/
                                  # sockets ({s,k,to,from} frames)
     theme/        zeron-theme    # source-neutral theme schema + built-in/custom registry,
                                  # validation, provenance, and local VS Code compiler
+    voice/        zeron-voice    # desktop-local optional Parakeet model, capture and inference; no RPC/sync
     ui/           zeron-ui       # gpui app: shell, sidebar, conversation, composer,
                                  # terminal view, diff pane, settings, animation kit
   apps/
diff --git a/Cargo.lock b/Cargo.lock
index e02ae30400..8cdd5d1839 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -163,6 +163,7 @@ dependencies = [
  "const-random",
  "getrandom 0.3.4",
  "once_cell",
+ "serde",
  "version_check",
  "zerocopy",
 ]
@@ -225,6 +226,28 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
+[[package]]
+name = "alsa"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d"
+dependencies = [
+ "alsa-sys",
+ "bitflags 2.13.1",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "alsa-sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.6"
@@ -827,7 +850,7 @@ dependencies = [
  "log",
  "num-rational",
  "num-traits",
- "pastey",
+ "pastey 0.1.1",
  "rayon",
  "thiserror 2.0.20",
  "v_frame",
@@ -878,6 +901,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -1243,6 +1272,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "castaway"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "cbc"
 version = "0.1.2"
@@ -1498,7 +1536,7 @@ dependencies = [
  "cocoa-foundation 0.1.2",
  "core-foundation 0.9.4",
  "core-graphics 0.23.2",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
  "objc",
 ]
@@ -1514,7 +1552,7 @@ dependencies = [
  "cocoa-foundation 0.2.0",
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
  "objc",
 ]
@@ -1590,6 +1628,21 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "compact_str"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
+dependencies = [
+ "castaway",
+ "cfg-if",
+ "itoa",
+ "rustversion",
+ "ryu",
+ "serde",
+ "static_assertions",
+]
+
 [[package]]
 name = "compression-codecs"
 version = "0.4.38"
@@ -1716,7 +1769,7 @@ dependencies = [
  "bitflags 1.3.2",
  "core-foundation 0.9.4",
  "core-graphics-types 0.1.3",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -1729,7 +1782,7 @@ dependencies = [
  "bitflags 2.13.1",
  "core-foundation 0.10.1",
  "core-graphics-types 0.2.0",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -1742,7 +1795,7 @@ dependencies = [
  "bitflags 2.13.1",
  "core-foundation 0.9.4",
  "core-graphics-types 0.1.3",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -1789,7 +1842,7 @@ checksum = "a593227b66cbd4007b2a050dfdd9e1d1318311409c8d600dc82ba1b15ca9c130"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -1816,6 +1869,20 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "coreaudio-rs"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58"
+dependencies = [
+ "bitflags 2.13.1",
+ "libc",
+ "objc2-audio-toolbox",
+ "objc2-core-audio",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "cosmic-text"
 version = "0.19.0"
@@ -1840,6 +1907,36 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "cpal"
+version = "0.17.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8942da362c0f0d895d7cac616263f2f9424edc5687364dfd1d25ef7eba506d7"
+dependencies = [
+ "alsa",
+ "coreaudio-rs",
+ "dasp_sample",
+ "jni",
+ "js-sys",
+ "libc",
+ "mach2",
+ "ndk",
+ "ndk-context",
+ "num-derive",
+ "num-traits",
+ "objc2 0.6.4",
+ "objc2-audio-toolbox",
+ "objc2-avf-audio",
+ "objc2-core-audio",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows 0.62.2",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -2079,6 +2176,12 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "daachorse"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5614204febbc33cc07a2806aa6440b904ac012b68eecc37f4493ea4a76455a3d"
+
 [[package]]
 name = "darling"
 version = "0.20.11"
@@ -2114,6 +2217,21 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "dary_heap"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b1e3a325bc115f096c8b77bbf027a7c2592230e70be2d985be950d3d5e60ebe"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dasp_sample"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
+
 [[package]]
 name = "data-encoding"
 version = "2.11.1"
@@ -2133,7 +2251,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
 dependencies = [
  "const-oid",
- "pem-rfc7468",
+ "pem-rfc7468 0.7.0",
+ "zeroize",
+]
+
+[[package]]
+name = "der"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a878c850e9e421b20262e9b41f9c860e4785fa07541c266b62ff9d1ef998a80a"
+dependencies = [
+ "pem-rfc7468 1.0.0",
  "zeroize",
 ]
 
@@ -2182,6 +2310,37 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "derive_builder"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
+dependencies = [
+ "derive_builder_core",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "derive_more"
 version = "2.1.1"
@@ -2382,7 +2541,7 @@ version = "0.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
 dependencies = [
- "der",
+ "der 0.7.10",
  "digest",
  "elliptic-curve",
  "rfc6979",
@@ -2409,7 +2568,7 @@ dependencies = [
  "generic-array",
  "group",
  "hkdf",
- "pem-rfc7468",
+ "pem-rfc7468 0.7.0",
  "pkcs8",
  "rand_core 0.6.4",
  "sec1",
@@ -2579,6 +2738,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "esaxx-rs"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d817e038c30374a4bcb22f94d0a8a0e216958d4c3dcde369b1439fec4bdda6e6"
+
 [[package]]
 name = "etagere"
 version = "0.2.15"
@@ -2635,6 +2800,17 @@ dependencies = [
  "zune-inflate",
 ]
 
+[[package]]
+name = "eyre"
+version = "0.6.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08309dbcc659c5549a24ddb9b27027640641b282ef5768267c7e675558986a3"
+dependencies = [
+ "autocfg",
+ "indenter",
+ "once_cell",
+]
+
 [[package]]
 name = "fallible-iterator"
 version = "0.3.0"
@@ -2839,6 +3015,15 @@ dependencies = [
  "ttf-parser",
 ]
 
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -2846,7 +3031,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
 dependencies = [
  "foreign-types-macros",
- "foreign-types-shared",
+ "foreign-types-shared 0.3.1",
 ]
 
 [[package]]
@@ -2860,6 +3045,12 @@ dependencies = [
  "syn 3.0.3",
 ]
 
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
 [[package]]
 name = "foreign-types-shared"
 version = "0.3.1"
@@ -3416,7 +3607,7 @@ dependencies = [
  "derive_more",
  "embed-resource",
  "etagere",
- "foreign-types",
+ "foreign-types 0.5.0",
  "futures",
  "futures-concurrency",
  "getrandom 0.3.4",
@@ -3579,7 +3770,7 @@ dependencies = [
  "derive_more",
  "dispatch2",
  "etagere",
- "foreign-types",
+ "foreign-types 0.5.0",
  "futures",
  "gpui",
  "gpui_util",
@@ -3993,6 +4184,12 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "hmac-sha256"
+version = "1.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad320b3b96fb2a455a0726d16efe0a5afdbd34b71dea5bc53b05ea057714d4e"
+
 [[package]]
 name = "home"
 version = "0.5.12"
@@ -4002,6 +4199,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "hound"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62adaabb884c94955b19907d60019f4e145d091c75345379e70d1ee696f7854f"
+
 [[package]]
 name = "html5ever"
 version = "0.39.0"
@@ -4394,6 +4597,12 @@ version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89194689a993ab15268672e99e7b0e19da2da3268ac682e8f02d29d4d1434cd7"
 
+[[package]]
+name = "indenter"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5"
+
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -5140,6 +5349,12 @@ dependencies = [
  "twox-hash",
 ]
 
+[[package]]
+name = "lzma-rust2"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e20f57f9918e5bd7bc58c22cdd70a6afc7375d4dd9683af5f2b34bd3d2bba619"
+
 [[package]]
 name = "mac-notification-sys"
 version = "0.6.15"
@@ -5163,6 +5378,22 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "macro_rules_attribute"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3ae8f6d608c795738406608304d30a2dfbdc8e58e44f7ba43236da5208ded3c"
+dependencies = [
+ "macro_rules_attribute-proc_macro",
+ "pastey 0.2.3",
+]
+
+[[package]]
+name = "macro_rules_attribute-proc_macro"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"
+
 [[package]]
 name = "malloc_buf"
 version = "0.0.6"
@@ -5192,6 +5423,16 @@ dependencies = [
  "regex-automata",
 ]
 
+[[package]]
+name = "matrixmultiply"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
 [[package]]
 name = "maybe-rayon"
 version = "0.1.1"
@@ -5228,7 +5469,7 @@ dependencies = [
  "core-foundation 0.10.1",
  "core-video",
  "ctor",
- "foreign-types",
+ "foreign-types 0.5.0",
  "metal",
  "objc",
 ]
@@ -5292,7 +5533,7 @@ dependencies = [
  "bitflags 2.13.1",
  "block",
  "core-graphics-types 0.2.0",
- "foreign-types",
+ "foreign-types 0.5.0",
  "log",
  "objc",
  "paste",
@@ -5344,6 +5585,28 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "monostate"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3341a273f6c9d5bef1908f17b7267bbab0e95c9bf69a0d4dcf8e9e1b2c76ef67"
+dependencies = [
+ "monostate-impl",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "monostate-impl"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4db6d5580af57bf992f59068d4ea26fd518574ff48d7639b255a36f9de6e7e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "moxcms"
 version = "0.8.1"
@@ -5400,6 +5663,38 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndarray"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
 [[package]]
 name = "ndk"
 version = "0.9.0"
@@ -5415,6 +5710,12 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
 [[package]]
 name = "ndk-sys"
 version = "0.6.0+11769913"
@@ -5791,6 +6092,31 @@ dependencies = [
  "objc2-quartz-core 0.3.2",
 ]
 
+[[package]]
+name = "objc2-audio-toolbox"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08"
+dependencies = [
+ "bitflags 2.13.1",
+ "libc",
+ "objc2 0.6.4",
+ "objc2-core-audio",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+]
+
+[[package]]
+name = "objc2-avf-audio"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"
+dependencies = [
+ "objc2 0.6.4",
+ "objc2-foundation 0.3.2",
+]
+
 [[package]]
 name = "objc2-cloud-kit"
 version = "0.3.2"
@@ -5802,6 +6128,29 @@ dependencies = [
  "objc2-foundation 0.3.2",
 ]
 
+[[package]]
+name = "objc2-core-audio"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2"
+dependencies = [
+ "dispatch2",
+ "objc2 0.6.4",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+]
+
+[[package]]
+name = "objc2-core-audio-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c"
+dependencies = [
+ "bitflags 2.13.1",
+ "objc2 0.6.4",
+]
+
 [[package]]
 name = "objc2-core-data"
 version = "0.2.2"
@@ -5832,7 +6181,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
  "bitflags 2.13.1",
+ "block2 0.6.2",
  "dispatch2",
+ "libc",
  "objc2 0.6.4",
 ]
 
@@ -6135,6 +6486,28 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
+[[package]]
+name = "onig"
+version = "6.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2"
+dependencies = [
+ "bitflags 2.13.1",
+ "libc",
+ "once_cell",
+ "onig_sys",
+]
+
+[[package]]
+name = "onig_sys"
+version = "69.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
 [[package]]
 name = "oo7"
 version = "0.6.0"
@@ -6192,6 +6565,49 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "openssl"
+version = "0.10.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77823a27f0babb03091cb9ed9ef80af3b39dbc82f97e8fa530374b7dafd87a45"
+dependencies = [
+ "bitflags 2.13.1",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b47e7e6bb2c38cd930d25a23b40fa52e068c10e85f3e03a7f5ba5aaca5713695"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -6217,6 +6633,30 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "ort"
+version = "2.0.0-rc.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4336a1e2b38848325241c72889086886004e589b7c74f335e60a8e8db5138a0b"
+dependencies = [
+ "ndarray",
+ "ort-sys",
+ "smallvec",
+ "tracing",
+ "ureq",
+]
+
+[[package]]
+name = "ort-sys"
+version = "2.0.0-rc.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf211e3776eea6aec988552fa118dd746d70e1b1e5e244058d1c98015f3e5872"
+dependencies = [
+ "hmac-sha256",
+ "lzma-rust2",
+ "ureq",
+]
+
 [[package]]
 name = "p256"
 version = "0.13.2"
@@ -6266,6 +6706,22 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "parakeet-rs"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f54545a861dca6b43c8d44e3dd932764ca196d84bcf0d1b48ea212b43b29666"
+dependencies = [
+ "eyre",
+ "hound",
+ "ndarray",
+ "ort",
+ "realfft",
+ "serde",
+ "serde_json",
+ "tokenizers",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -6307,6 +6763,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
 
+[[package]]
+name = "pastey"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
+
 [[package]]
 name = "pathfinder_geometry"
 version = "0.5.1"
@@ -6355,6 +6817,15 @@ dependencies = [
  "base64ct",
 ]
 
+[[package]]
+name = "pem-rfc7468"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9"
+dependencies = [
+ "base64ct",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -6521,7 +6992,7 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
 dependencies = [
- "der",
+ "der 0.7.10",
  "spki",
 ]
 
@@ -6786,6 +7257,15 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "primal-check"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc0d895b311e3af9902528fbb8f928688abbd95872819320517cc24ca6b2bd08"
+dependencies = [
+ "num-integer",
+]
+
 [[package]]
 name = "primeorder"
 version = "0.13.6"
@@ -7338,6 +7818,12 @@ dependencies = [
  "objc2-quartz-core 0.3.2",
 ]
 
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
 [[package]]
 name = "rayon"
 version = "1.12.0"
@@ -7348,6 +7834,17 @@ dependencies = [
  "rayon-core",
 ]
 
+[[package]]
+name = "rayon-cond"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2964d0cf57a3e7a06e8183d14a8b527195c706b7983549cd5462d5aa3747438f"
+dependencies = [
+ "either",
+ "itertools 0.14.0",
+ "rayon",
+]
+
 [[package]]
 name = "rayon-core"
 version = "1.13.0"
@@ -7394,6 +7891,15 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "realfft"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f821338fddb99d089116342c46e9f1fbf3828dba077674613e734e01d6ea8677"
+dependencies = [
+ "rustfft",
+]
+
 [[package]]
 name = "reborrow"
 version = "0.5.5"
@@ -7913,6 +8419,18 @@ dependencies = [
  "sansio",
 ]
 
+[[package]]
+name = "rubato"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5258099699851cfd0082aeb645feb9c084d9a5e1f1b8d5372086b989fc5e56a1"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "realfft",
+]
+
 [[package]]
 name = "rusqlite"
 version = "0.32.1"
@@ -7988,6 +8506,20 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "rustfft"
+version = "6.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21db5f9893e91f41798c88680037dba611ca6674703c1a18601b01a72c8adb89"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "primal-check",
+ "strength_reduce",
+ "transpose",
+]
+
 [[package]]
 name = "rusticata-macros"
 version = "4.1.0"
@@ -8126,6 +8658,15 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c62751faa8bc286982334a082fe125184a29fc89d17775766e4f891b7d726980"
 
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "scheduler"
 version = "0.1.0"
@@ -8235,13 +8776,36 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
  "base16ct",
- "der",
+ "der 0.7.10",
  "generic-array",
  "pkcs8",
  "subtle",
  "zeroize",
 ]
 
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.13.1",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "selectors"
 version = "0.38.0"
@@ -8715,6 +9279,17 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "socks"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"
+dependencies = [
+ "byteorder",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "soup3"
 version = "0.5.0"
@@ -8775,7 +9350,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
 dependencies = [
  "base64ct",
- "der",
+ "der 0.7.10",
+]
+
+[[package]]
+name = "spm_precompiled"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5851699c4033c63636f7ea4cf7b7c1f1bf06d0cc03cfb42e711de5a5c46cf326"
+dependencies = [
+ "base64 0.13.1",
+ "nom 7.1.3",
+ "serde",
+ "unicode-segmentation",
 ]
 
 [[package]]
@@ -8836,6 +9423,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520"
 
+[[package]]
+name = "strength_reduce"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
+
 [[package]]
 name = "strict-num"
 version = "0.1.1"
@@ -9403,6 +9996,39 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
+[[package]]
+name = "tokenizers"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7afbf6e88718afcc138bad01d6ccc3051dbbc3b2ce9793d8b8a3aeb610969cfc"
+dependencies = [
+ "ahash",
+ "compact_str",
+ "daachorse",
+ "dary_heap",
+ "derive_builder",
+ "esaxx-rs",
+ "getrandom 0.3.4",
+ "itertools 0.14.0",
+ "log",
+ "macro_rules_attribute",
+ "monostate",
+ "onig",
+ "paste",
+ "rand 0.9.5",
+ "rayon",
+ "rayon-cond",
+ "regex",
+ "regex-syntax",
+ "serde",
+ "serde_json",
+ "spm_precompiled",
+ "thiserror 2.0.20",
+ "unicode-normalization-alignments",
+ "unicode-segmentation",
+ "unicode_categories",
+]
+
 [[package]]
 name = "tokio"
 version = "1.53.1"
@@ -9692,6 +10318,16 @@ dependencies = [
  "tracing-log",
 ]
 
+[[package]]
+name = "transpose"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
+dependencies = [
+ "num-integer",
+ "strength_reduce",
+]
+
 [[package]]
 name = "tree-sitter"
 version = "0.26.11"
@@ -10092,6 +10728,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
 
+[[package]]
+name = "unicode-normalization-alignments"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43f613e4fa046e69818dd287fdc4bc78175ff20331479dab6e1b0f98d57062de"
+dependencies = [
+ "smallvec",
+]
+
 [[package]]
 name = "unicode-properties"
 version = "0.1.4"
@@ -10128,6 +10773,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unicode_categories"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+
 [[package]]
 name = "uniffi"
 version = "0.32.2"
@@ -10271,6 +10922,36 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "ureq"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7ac20be9b7726e0bbdbf974c059676d9acb1cd414961f570a4e8231cacd7fc"
+dependencies = [
+ "base64 0.23.1",
+ "der 0.8.2",
+ "log",
+ "native-tls",
+ "percent-encoding",
+ "rustls-pki-types",
+ "socks",
+ "ureq-proto",
+ "utf8-zero",
+ "webpki-root-certs",
+]
+
+[[package]]
+name = "ureq-proto"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f86fd172ccca569e458f61b6bdd6220965a9ef36e672a6852953b51a0e1583be"
+dependencies = [
+ "base64 0.23.1",
+ "http",
+ "httparse",
+ "log",
+]
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -10316,6 +10997,12 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
+[[package]]
+name = "utf8-zero"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e"
+
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -10759,6 +11446,15 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
@@ -12432,7 +13128,7 @@ dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
  "fontdb",
- "foreign-types",
+ "foreign-types 0.5.0",
  "futures",
  "gpui",
  "gpui-base",
@@ -12480,6 +13176,7 @@ dependencies = [
  "zeron-syntax",
  "zeron-theme",
  "zeron-update",
+ "zeron-voice",
 ]
 
 [[package]]
@@ -12498,6 +13195,23 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "zeron-voice"
+version = "0.2.101"
+dependencies = [
+ "anyhow",
+ "cpal",
+ "hound",
+ "parakeet-rs",
+ "reqwest",
+ "rubato",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tempfile",
+ "tokio",
+]
+
 [[package]]
 name = "zerotrie"
 version = "0.2.5"
diff --git a/Cargo.toml b/Cargo.toml
index e0ba7ab3c9..5532ceaee7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
+    "crates/voice",
     "crates/theme",
     "crates/proto",
     "crates/preview",
diff --git a/README.md b/README.md
index 1e4476709e..8ff826fcfd 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ curl -fsSL https://zeron.sh/install.sh | sh
 zeron status
 ```
 
-The installer starts the daemon immediately and keeps it running across reboots. No sign-in or sync configuration is required. It also adds Zeron to your application launcher: a per-user `zeron.desktop` and icon under `~/.local/share` (or `$XDG_DATA_HOME`), rewritten each time the installer runs.
+The installer starts the daemon immediately and keeps it running across reboots. No sign-in or sync configuration is required. It also adds Zeron to your application launcher: a per-user `zeron.desktop` and icon under `~/.local/share` (or `$XDG_DATA_HOME`), rewritten each time the installer runs. Linux requires the system ALSA runtime (`libasound.so.2`), including for headless mode because it shares the desktop executable. The installer checks that the binary starts before activating it and reports missing runtime libraries.
 
 The desktop sidebar browser also needs the [Linux browser runtime](docs/reference/linux-browser.md).
 
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index b12292308a..886febec29 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -141,3 +141,9 @@ Zeron code.
 The Zui native overlay renderer adapts Apache-2.0 GPUI code from
 [`egoist/zed` at `57bd4fe`](https://github.com/egoist/zed/tree/57bd4fe181639797d395978d5de17bc9e10a6219/crates/gpui_macos).
 Attribution is retained in the pinned Zui dependency’s `NOTICE`.
+
+## Optional desktop dictation
+
+Parakeet TDT 0.6B v3 model weights are by NVIDIA under CC BY 4.0. The optional download uses Ivan Stupakov's INT8 ONNX conversion, pinned to revision `8f23f0c03c8761650bdb5b40aaf3e40d2c15f1ce`, with per-file SHA-256 verification. Original: https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3. Conversion: https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx. License: https://creativecommons.org/licenses/by/4.0/.
+
+Native runtime dependencies: parakeet-rs 0.3.8 (MIT OR Apache-2.0), ort/ort-sys 2.0.0-rc.13 (MIT OR Apache-2.0), ONNX Runtime 1.28.0 (MIT), cpal 0.17.3 (Apache-2.0), and rubato 0.16.2 (MIT). See `crates/voice/NOTICE.md` for exact conversion provenance, changes, runtime/platform limitations and supported languages. Models are not included in the application bundle.
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 3d66f80f3d..d03039263a 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -47,6 +47,7 @@ name = "compact-picker-fixture"
 required-features = ["compact-picker-fixture"]
 
 [dependencies]
+zeron-voice = { path = "../voice" }
 url = "2"
 zeron-proto.workspace = true
 similar.workspace = true
diff --git a/crates/ui/assets/icons/microphone.svg b/crates/ui/assets/icons/microphone.svg
new file mode 100644
index 0000000000..fb6b33de20
--- /dev/null
+++ b/crates/ui/assets/icons/microphone.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="8" y="2" width="8" height="13" rx="4"/><path d="M5 10v2a7 7 0 0 0 14 0v-2M12 19v3m-4 0h8"/></svg>
\ No newline at end of file
diff --git a/crates/ui/build.rs b/crates/ui/build.rs
index ecf17357da..8f446fcdbe 100644
--- a/crates/ui/build.rs
+++ b/crates/ui/build.rs
@@ -1,6 +1,32 @@
 use std::{env, path::PathBuf, process::Command};
 
 fn main() {
+    if env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos") {
+        println!("cargo:rerun-if-changed=src/dictation/permission.m");
+        let out = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+        let object = out.join("voice-permission.o");
+        assert!(
+            Command::new("clang")
+                .args(["-fobjc-arc", "-c", "src/dictation/permission.m", "-o"])
+                .arg(&object)
+                .status()
+                .unwrap()
+                .success()
+        );
+        assert!(
+            Command::new("ar")
+                .arg("crus")
+                .arg(out.join("libvoice-permission.a"))
+                .arg(object)
+                .status()
+                .unwrap()
+                .success()
+        );
+        println!("cargo:rustc-link-search=native={}", out.display());
+        println!("cargo:rustc-link-lib=static=voice-permission");
+        println!("cargo:rustc-link-lib=framework=AVFoundation");
+    }
+
     println!("cargo:rerun-if-changed=src/browser/linux/helper.c");
     if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("linux") {
         return;
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 658db0e7df..29a6cd49ca 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -16,11 +16,11 @@ use std::time::{Duration, Instant};
 use gpui::{
     AnyTooltip, App, BorderStyle, Bounds, ClipboardEntry, ClipboardItem, Context, CursorStyle,
     DispatchPhase, ElementInputHandler, Entity, EntityInputHandler, EventEmitter, FocusHandle,
-    Focusable, GlobalElementId, KeyBinding, KeyDownEvent, LayoutId, MouseButton, MouseDownEvent,
-    MouseMoveEvent, MouseUpEvent, ObjectFit, PaintQuad, PathPromptOptions, Pixels, Point, Role,
-    ScrollWheelEvent, SharedString, Style, StyledImage as _, Subscription, Task, TextRun,
-    TextStyle, UTF16Selection, UnderlineStyle, Window, WrappedLine, actions, div, fill, img, point,
-    prelude::*, px, quad, relative, size,
+    Focusable, GlobalElementId, KeyBinding, KeyDownEvent, KeyUpEvent, Keystroke, LayoutId,
+    ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, ObjectFit,
+    PaintQuad, PathPromptOptions, Pixels, Point, Role, ScrollWheelEvent, SharedString, Style,
+    StyledImage as _, Subscription, Task, TextRun, TextStyle, UTF16Selection, UnderlineStyle,
+    Window, WrappedLine, actions, div, fill, img, point, prelude::*, px, quad, relative, size,
 };
 use unicode_segmentation::UnicodeSegmentation;
 
@@ -844,6 +844,7 @@ actions!(
         Undo,
         Redo,
         MentionTab,
+        ToggleDictation,
         OutdentList,
     ]
 );
@@ -1695,6 +1696,104 @@ pub enum ComposerInputEvent {
     },
 }
 
+#[derive(Clone)]
+enum DictationInputEvent {
+    /// The dictation shortcut went down (auto-repeat is ignored)…
+    Press,
+    /// …and came back up, or focus left the editor while it was held.
+    Release,
+    Changed,
+    Submit(u64),
+}
+
+/// A held dictation shortcut. `keystroke` is the binding, used to recognise
+/// its release: the key coming up, or any of its modifiers being let go
+/// (macOS does not deliver key-up for Command chords).
+struct DictationKey {
+    keystroke: Option<Keystroke>,
+    _blur: Subscription,
+}
+
+/// Dictation is hold to talk, from the microphone (pointer or Enter/Space
+/// while it is focused) and from the shortcut. Each releases only its own hold.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum HoldSource {
+    Pointer,
+    Button,
+    Key,
+}
+
+struct DictationHold {
+    source: HoldSource,
+    /// When this hold started dictation; `None` when it took over a session
+    /// started another way (assistive Click), which it then only finishes.
+    started: Option<Instant>,
+}
+
+/// A release sooner than this is a click, not speech: explain hold to talk
+/// instead of transcribing a fraction of a second of audio.
+const DICTATION_TAP: Duration = Duration::from_millis(300);
+impl EventEmitter<DictationInputEvent> for ComposerInput {}
+
+/// The composer's morph into and out of dictation, and the clock's warning
+/// window before the recording limit.
+const VOICE_MORPH: Duration = Duration::from_millis(420);
+const VOICE_CURVE: motion::CubicBezier = motion::CubicBezier::new(0.2, 0.0, 0.0, 1.0);
+const VOICE_LIMIT_WARNING: Duration = Duration::from_secs(10);
+/// Height of the voice track and its gap to the Stop control.
+const VOICE_TRACK_HEIGHT: f32 = 32.0;
+const VOICE_TRACK_GAP: f32 = 8.0;
+
+/// Everything the voice track draws, captured from the dictation meter.
+#[derive(Clone)]
+struct VoiceFrame {
+    label: String,
+    mode: crate::dictation::waveform::Mode,
+    bars: Vec<crate::dictation::Bar>,
+    level: f32,
+    elapsed: Option<Duration>,
+}
+
+/// Interruptible 0↔1 progress of the dictation morph: a retarget starts from
+/// the current value, so toggling mid-flight reverses without a jump.
+#[derive(Clone, Copy)]
+struct VoiceTween {
+    from: f32,
+    to: f32,
+    start: Instant,
+}
+
+impl Default for VoiceTween {
+    fn default() -> Self {
+        Self {
+            from: 0.0,
+            to: 0.0,
+            start: Instant::now(),
+        }
+    }
+}
+
+impl VoiceTween {
+    fn value(&self, now: Instant) -> f32 {
+        let raw = now.saturating_duration_since(self.start).as_secs_f32()
+            / (VOICE_MORPH.as_secs_f32() * motion::speed_scale());
+        motion::lerp(self.from, self.to, VOICE_CURVE.eval(raw))
+    }
+
+    fn retarget(&mut self, to: f32, now: Instant, reduced: bool) {
+        if self.to == to {
+            return;
+        }
+        self.from = if reduced { to } else { self.value(now) };
+        self.to = to;
+        self.start = now;
+    }
+
+    fn settled(&self, now: Instant) -> bool {
+        self.value(now) == self.to
+    }
+}
+
 /// Shaping inputs excluding mutable viewport and selection geometry.
 #[derive(Clone, PartialEq)]
 struct InputLayoutKey {
@@ -1802,6 +1901,11 @@ pub struct ComposerInput {
     blink_anchor: Instant,
     /// Half-period repaint driver, alive only while the input is focused.
     blink_task: Option<Task<()>>,
+    dictation: crate::dictation::Dictation,
+    transcriber: Option<Box<dyn crate::dictation::Transcriber>>,
+    dictation_task: Option<Task<()>>,
+    /// The dictation shortcut while it is held down.
+    dictation_key: Option<DictationKey>,
     // -- undo history --
     undo_stack: Vec<EditSnapshot>,
     redo_stack: Vec<EditSnapshot>,
@@ -1890,6 +1994,10 @@ impl ComposerInput {
             display_is_placeholder: true,
             blink_anchor: Instant::now(),
             blink_task: None,
+            dictation: Default::default(),
+            transcriber: None,
+            dictation_task: None,
+            dictation_key: None,
             undo_stack: Vec::new(),
             redo_stack: Vec::new(),
             last_edit: None,
@@ -2173,6 +2281,7 @@ impl ComposerInput {
     }
 
     pub fn set_text(&mut self, text: impl Into<String>, cx: &mut Context<Self>) {
+        self.cancel_dictation();
         self.invalidate_mention_tooltip();
         self.edit_revision = self.edit_revision.wrapping_add(1);
         self.content = text.into();
@@ -2325,6 +2434,242 @@ impl ComposerInput {
         }
     }
 
+    pub(crate) fn cancel_dictation(&mut self) {
+        self.dictation.cancel();
+        self.transcriber = None; // Drop signals capture cancellation and invalidates pending results.
+        self.dictation_task = None;
+    }
+
+    fn begin_dictation(
+        &mut self,
+        transcriber: Box<dyn crate::dictation::Transcriber>,
+        cx: &mut Context<Self>,
+    ) {
+        self.cancel_dictation();
+        self.dictation.begin(
+            &self.content,
+            self.projection.normalize_range(self.selected_range.clone()),
+        );
+        self.transcriber = Some(transcriber);
+        self.last_edit = None;
+        let generation = self.dictation.generation;
+        let started = Instant::now();
+        self.dictation_task = Some(cx.spawn(async move |this, cx| {
+            loop {
+                cx.background_executor()
+                    .timer(Duration::from_millis(40))
+                    .await;
+                if !this
+                    .update(cx, |input, cx| {
+                        let requesting =
+                            input.dictation.phase == crate::dictation::Phase::Requesting;
+                        let active = input.poll_dictation(generation, cx);
+                        if requesting && input.dictation.phase == crate::dictation::Phase::Listening
+                        {
+                            tracing::debug!(
+                                target: "zeron_ui::dictation",
+                                activation_to_listening_ms = started.elapsed().as_millis(),
+                                "Dictation capture ready"
+                            );
+                        }
+                        active
+                    })
+                    .unwrap_or(false)
+                {
+                    break;
+                }
+            }
+        }));
+        cx.emit(DictationInputEvent::Changed);
+        cx.notify();
+    }
+
+    pub(crate) fn finish_dictation(&mut self, send: bool, cx: &mut Context<Self>) -> bool {
+        if !self.dictation.phase.active() {
+            return false;
+        }
+        // Repeated clicks/Enter only mark one pending send and end audio once.
+        if self.dictation.finish(send, Instant::now()) {
+            if let Some(transcriber) = &mut self.transcriber {
+                transcriber.finish();
+            }
+        }
+        cx.emit(DictationInputEvent::Changed);
+        cx.notify();
+        true
+    }
+
+    fn complete_dictation(&mut self, phase: crate::dictation::Phase, cx: &mut Context<Self>) {
+        let send = self.dictation.complete(phase);
+        self.transcriber = None;
+        self.last_edit = None;
+        cx.emit(DictationInputEvent::Changed);
+        if send {
+            cx.emit(DictationInputEvent::Submit(self.dictation.generation));
+        }
+        cx.notify();
+    }
+
+    fn apply_dictation(&mut self, text: &str, cx: &mut Context<Self>) {
+        let before = (!self.dictation.has_partial && !text.is_empty()).then(|| self.snapshot());
+        if let Some(cursor) = self.dictation.replace(&mut self.content, text) {
+            if let Some(before) = before {
+                self.undo_stack.push(before);
+                if self.undo_stack.len() > UNDO_LIMIT {
+                    self.undo_stack.remove(0);
+                }
+                self.redo_stack.clear();
+            }
+            // Moving the selection explicitly stops dictation (see move_to /
+            // select_to). The original selection collapses on the first result.
+            self.selected_range = cursor..cursor;
+            self.selection_reversed = false;
+            self.caret_affinity = CaretAffinity::Downstream;
+            self.preferred_column = None;
+            self.edit_revision = self.edit_revision.wrapping_add(1);
+            self.refresh_projection();
+            self.invalidate_mention_tooltip();
+            self.follow_cursor = true;
+            self.reset_blink();
+            self.needs_measure = true;
+            cx.emit(ComposerInputEvent::Edited);
+            cx.notify();
+        }
+    }
+
+    fn poll_dictation(&mut self, generation: u64, cx: &mut Context<Self>) -> bool {
+        use crate::dictation::{Event, Phase};
+        if generation != self.dictation.generation || !self.dictation.phase.active() {
+            return false;
+        }
+        while let Some(event) = self.transcriber.as_mut().and_then(|service| service.poll()) {
+            match event {
+                Event::Listening => {
+                    if self.dictation.phase == Phase::Requesting {
+                        self.dictation.phase = Phase::Listening;
+                        self.dictation.meter.start(Instant::now());
+                    }
+                    cx.emit(DictationInputEvent::Changed);
+                    cx.notify();
+                }
+                Event::Finalizing => {
+                    self.finish_dictation(false, cx);
+                }
+                Event::Partial(text) => self.apply_dictation(&text, cx),
+                Event::Final(text) => {
+                    if text.trim().is_empty() && !self.dictation.has_partial {
+                        self.complete_dictation(Phase::NoSpeech, cx);
+                        return false;
+                    }
+                    self.apply_dictation(&text, cx);
+                    self.complete_dictation(Phase::Idle, cx);
+                    return false;
+                }
+                Event::Denied(message) => self.complete_dictation(Phase::Denied(message), cx),
+                Event::Unavailable(message) => {
+                    self.complete_dictation(Phase::Unavailable(message), cx)
+                }
+                Event::Failed(message) => self.complete_dictation(Phase::Failed(message), cx),
+                Event::Cancelled => {
+                    self.cancel_dictation();
+                    cx.emit(DictationInputEvent::Changed);
+                    cx.notify();
+                }
+            }
+            if !self.dictation.phase.active() {
+                self.transcriber = None;
+                return false;
+            }
+        }
+        if self.dictation.phase == Phase::Listening
+            && let Some(service) = self.transcriber.as_mut()
+        {
+            let level = service.level();
+            if self.dictation.meter.record(Instant::now(), level) {
+                // The composer drives smooth frames itself; this keeps the
+                // stepped reduced-motion waveform current.
+                cx.emit(DictationInputEvent::Changed);
+            }
+        }
+        if self.dictation.timed_out(Instant::now()) {
+            self.complete_dictation(
+                Phase::Failed(
+                    "Dictation took too long. Your draft is safe. Wait a moment, then try a shorter recording.".into(),
+                ),
+                cx,
+            );
+            return false;
+        }
+        true
+    }
+
+    fn toggle_dictation_action(
+        &mut self,
+        _: &ToggleDictation,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if self.dictation_key.is_some() {
+            return; // Auto-repeat while held.
+        }
+        if !crate::dictation::enabled(cx) && !self.dictation.phase.active() {
+            // Off by default: let another binding of the same chord run.
+            cx.propagate();
+            return;
+        }
+        // Mirror `apply_keymap`, which binds the default for an unparseable combo.
+        let parse = |combo: &str| Keystroke::parse(&crate::settings::platform_combo(combo)).ok();
+        let keystroke = parse(&crate::settings::current(cx).keymap.toggle_dictation)
+            .or_else(|| parse(crate::settings::ShortcutId::ToggleDictation.default_combo()));
+        let blur = cx.on_blur(&self.focus_handle, window, |input, _, cx| {
+            input.release_dictation_key(cx);
+        });
+        self.dictation_key = Some(DictationKey {
+            keystroke,
+            _blur: blur,
+        });
+        cx.emit(DictationInputEvent::Press);
+    }
+
+    fn release_dictation_key(&mut self, cx: &mut Context<Self>) {
+        if self.dictation_key.take().is_some() {
+            cx.emit(DictationInputEvent::Release);
+        }
+    }
+
+    fn on_dictation_key_up(&mut self, event: &KeyUpEvent, _: &mut Window, cx: &mut Context<Self>) {
+        let released = self.dictation_key.as_ref().is_some_and(|held| {
+            held.keystroke
+                .as_ref()
+                .is_none_or(|binding| binding.key.eq_ignore_ascii_case(&event.keystroke.key))
+        });
+        if released {
+            self.release_dictation_key(cx);
+        }
+    }
+
+    fn on_dictation_modifiers(
+        &mut self,
+        event: &ModifiersChangedEvent,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let released = self
+            .dictation_key
+            .as_ref()
+            .and_then(|held| held.keystroke.as_ref())
+            .is_some_and(|binding| {
+                let (bound, now) = (&binding.modifiers, &event.modifiers);
+                (bound.platform && !now.platform)
+                    || (bound.control && !now.control)
+                    || (bound.alt && !now.alt)
+                    || (bound.shift && !now.shift)
+            });
+        if released {
+            self.release_dictation_key(cx);
+        }
+    }
+
     // ---- undo history ----
 
     fn snapshot(&self) -> EditSnapshot {
@@ -2339,6 +2684,7 @@ impl ComposerInput {
     /// Called with the range about to be replaced, BEFORE the content changes,
     /// so the pushed snapshot is the pre-edit state.
     fn record_edit(&mut self, range: &Range<usize>, new_text: &str) {
+        self.cancel_dictation();
         let kind = if new_text.is_empty() {
             EditKind::Delete
         } else {
@@ -2385,6 +2731,7 @@ impl ComposerInput {
     }
 
     fn restore(&mut self, snapshot: EditSnapshot, cx: &mut Context<Self>) {
+        self.cancel_dictation();
         self.invalidate_mention_tooltip();
         self.edit_revision = self.edit_revision.wrapping_add(1);
         self.content = snapshot.content;
@@ -2404,6 +2751,11 @@ impl ComposerInput {
     }
 
     fn undo(&mut self, _: &Undo, _: &mut Window, cx: &mut Context<Self>) {
+        if self.dictation.phase.active() {
+            cx.emit(DictationInputEvent::Changed);
+            cx.notify();
+        }
+        self.cancel_dictation();
         if self.read_only {
             return;
         }
@@ -2415,6 +2767,11 @@ impl ComposerInput {
     }
 
     fn redo(&mut self, _: &Redo, _: &mut Window, cx: &mut Context<Self>) {
+        if self.dictation.phase.active() {
+            cx.emit(DictationInputEvent::Changed);
+            cx.notify();
+        }
+        self.cancel_dictation();
         if self.read_only {
             return;
         }
@@ -2436,6 +2793,7 @@ impl ComposerInput {
     }
 
     fn move_to(&mut self, offset: usize, cx: &mut Context<Self>) {
+        self.cancel_dictation();
         self.last_edit = None;
         let offset = self.projection.normalize_range(offset..offset).start;
         self.selected_range = offset..offset;
@@ -2449,6 +2807,7 @@ impl ComposerInput {
     }
 
     fn select_to(&mut self, offset: usize, cx: &mut Context<Self>) {
+        self.cancel_dictation();
         self.last_edit = None;
         self.extend_selection(offset, cx);
     }
@@ -2883,6 +3242,9 @@ impl ComposerInput {
         cx: &mut Context<Self>,
     ) {
         if self.read_only
+            // A delayed paste lookup must not rewrite the range captured by
+            // dictation and make its final transcript fail the draft guard.
+            || self.dictation.phase.active()
             || self.edit_revision != revision
             || self.text() != original
             || self.marked_range.is_some()
@@ -3038,6 +3400,13 @@ impl ComposerInput {
     }
 
     fn on_key_down(&mut self, event: &KeyDownEvent, _: &mut Window, cx: &mut Context<Self>) {
+        if event.keystroke.key == "escape" && self.dictation.phase.active() {
+            self.cancel_dictation();
+            cx.emit(DictationInputEvent::Changed);
+            cx.notify();
+            cx.stop_propagation();
+            return;
+        }
         if escape_dismisses_completion(&event.keystroke.key, self.mention_open) {
             cx.emit(ComposerInputEvent::MentionDismiss);
             cx.stop_propagation();
@@ -3933,6 +4302,7 @@ impl EntityInputHandler for ComposerInput {
         if self.read_only {
             return;
         }
+        self.cancel_dictation();
         let single_line_text;
         let new_text = if self.single_line {
             single_line_text = new_text.replace(['\r', '\n'], " ");
@@ -3981,6 +4351,7 @@ impl EntityInputHandler for ComposerInput {
         if self.read_only {
             return;
         }
+        self.cancel_dictation();
         let single_line_text;
         let new_text = if self.single_line {
             single_line_text = new_text.replace(['\r', '\n'], " ");
@@ -4556,6 +4927,9 @@ impl Render for ComposerInput {
             .on_action(cx.listener(Self::message_newline_or_accept))
             .on_action(cx.listener(Self::modified_submit))
             .on_action(cx.listener(Self::submit))
+            .on_action(cx.listener(Self::toggle_dictation_action))
+            .on_key_up(cx.listener(Self::on_dictation_key_up))
+            .on_modifiers_changed(cx.listener(Self::on_dictation_modifiers))
             .on_action(cx.listener(Self::undo))
             .on_action(cx.listener(Self::redo))
             .on_key_down(cx.listener(Self::on_key_down))
@@ -5316,6 +5690,7 @@ pub struct Composer {
     pub(crate) queue_edit_renew_task: Option<Task<()>>,
     /// Focus once on mount, navigation, or after opening/closing a queue edit.
     pub(crate) focus_pending: bool,
+    dictation_hold: Option<DictationHold>,
     /// Live drag over the queue panel: which row, and where it would land.
     pub(crate) queue_drag: Option<crate::queue::QueueDragState>,
     pub(crate) queue_scroll: gpui::ScrollHandle,
@@ -5389,6 +5764,14 @@ pub struct Composer {
     side_chat: bool,
     _picker_focus: Subscription,
     _input_events: Subscription,
+    _dictation_events: Subscription,
+    dictation_activation: Option<Subscription>,
+    dictation_blur: Option<Subscription>,
+    dictation_focus: FocusHandle,
+    /// The last live frame of the voice pill, kept so it can settle away
+    /// after the transcript lands instead of vanishing.
+    voice_last: Option<VoiceFrame>,
+    voice_tween: VoiceTween,
 }
 
 impl EventEmitter<ComposerEvent> for Composer {}
@@ -5449,8 +5832,11 @@ impl Composer {
     }
 
     pub fn new(state: Entity<AppState>, cx: &mut Context<Self>) -> Self {
-        cx.on_release(|this, cx| this.release_queue_previews(cx))
-            .detach();
+        cx.on_release(|this, cx| {
+            this.input.update(cx, |input, _| input.cancel_dictation());
+            this.release_queue_previews(cx);
+        })
+        .detach();
         let input = cx.new(|cx| {
             let mut input =
                 ComposerInput::with_context("Do anything…", MESSAGE_COMPOSER_CONTEXT, cx);
@@ -5519,9 +5905,28 @@ impl Composer {
             }
         });
         cx.observe_global::<crate::settings::SettingsStore>(|this, cx| {
+            if !crate::settings::current(cx).dictation_enabled {
+                this.input.update(cx, |input, _| input.cancel_dictation());
+            }
             this.on_input_edited(cx);
         })
         .detach();
+        let dictation_events = cx.subscribe(&input, |this: &mut Self, _, event, cx| match event {
+            DictationInputEvent::Press => this.press_dictation(HoldSource::Key, cx),
+            DictationInputEvent::Release => this.release_dictation(HoldSource::Key, cx),
+            DictationInputEvent::Changed => cx.notify(),
+            DictationInputEvent::Submit(generation) => {
+                if this.input.read(cx).dictation.generation == *generation
+                    && composer_has_content(
+                        this.input.read(cx).text(),
+                        this.staged().len() + this.staged_appshots().len(),
+                        this.staged_comments(cx).len(),
+                    )
+                {
+                    this.on_submit(cx);
+                }
+            }
+        });
         let current_key = state.read(cx).selected_chat.clone().unwrap_or_default();
         let mut composer = Self {
             state,
@@ -5568,6 +5973,7 @@ impl Composer {
             queue_edit_task: None,
             queue_edit_renew_task: None,
             focus_pending: true,
+            dictation_hold: None,
             queue_drag: None,
             queue_scroll: gpui::ScrollHandle::new(),
             queue_full_preview: None,
@@ -5601,6 +6007,12 @@ impl Composer {
             side_chat: false,
             _picker_focus: picker_focus,
             _input_events: input_events,
+            _dictation_events: dictation_events,
+            dictation_activation: None,
+            dictation_blur: None,
+            dictation_focus: cx.focus_handle(),
+            voice_last: None,
+            voice_tween: VoiceTween::default(),
         };
         // Dev knob: pre-stage attachments (drop/paste can't be synthesized on
         // a rig) — `ZERON_ATTACH=/path/a.png[,/path/b.png]`, and
@@ -7374,6 +7786,7 @@ impl Composer {
                     .as_ref()
                     .is_some_and(|w| w.request_id == request_id);
                 if !same {
+                    self.input.update(cx, |input, _| input.cancel_dictation());
                     if self.wizard.is_none() {
                         self.drafts.insert(
                             self.current_key.clone(),
@@ -7490,11 +7903,12 @@ impl Composer {
         if self.editing_queued.is_some() {
             return SendButtonMode::Send;
         }
-        let has_text = composer_has_content(
-            self.input.read(cx).text(),
-            self.staged().len() + self.staged_appshots().len(),
-            self.staged_comments(cx).len(),
-        );
+        let has_text = self.input.read(cx).dictation.phase.active()
+            || composer_has_content(
+                self.input.read(cx).text(),
+                self.staged().len() + self.staged_appshots().len(),
+                self.staged_comments(cx).len(),
+            );
         send_button_mode(self.run_live(cx), has_text)
     }
 
@@ -7516,6 +7930,12 @@ impl Composer {
     }
 
     fn on_submit(&mut self, cx: &mut Context<Self>) {
+        if self
+            .input
+            .update(cx, |input, cx| input.finish_dictation(true, cx))
+        {
+            return;
+        }
         if self.commit_queue_edit(cx) {
             return;
         }
@@ -7563,6 +7983,12 @@ impl Composer {
     /// content. With a truly empty composer it instead activates the most
     /// recently queued row, and never turns an empty chord into Stop.
     fn on_modified_submit(&mut self, cx: &mut Context<Self>) {
+        if self
+            .input
+            .update(cx, |input, cx| input.finish_dictation(true, cx))
+        {
+            return;
+        }
         if self.commit_queue_edit(cx) {
             return;
         }
@@ -8799,6 +9225,512 @@ impl Composer {
         crate::frost::frosted(COMPOSER_RADIUS, crate::frost::MENU_BLUR, panel).into_any_element()
     }
 
+    /// `refocus` returns focus to the editor afterwards. Enter/Space on the
+    /// focused microphone keeps focus there so its key-up ends the hold.
+    fn toggle_dictation(&mut self, refocus: bool, cx: &mut Context<Self>) {
+        use crate::dictation::Phase;
+        if !crate::dictation::enabled(cx) && !self.input.read(cx).dictation.phase.active() {
+            return;
+        }
+        // A queue row still acquiring its edit lease is about to replace the
+        // draft, which would discard the dictation.
+        if self.wizard.is_some()
+            || self.queue_edit_finishing
+            || self.queue_edit_pending_id.is_some()
+            || self.sending
+            || self.input.read(cx).read_only
+        {
+            return;
+        }
+        self.input
+            .update(cx, |input, cx| match input.dictation.phase {
+                Phase::Requesting => {
+                    input.cancel_dictation();
+                    cx.emit(DictationInputEvent::Changed);
+                    cx.notify();
+                }
+                Phase::Listening => {
+                    input.finish_dictation(false, cx);
+                }
+                // The voice track's Cancel stops transcription.
+                Phase::Finalizing => {}
+                _ if input.marked_range.is_some() => {
+                    input.dictation.phase = Phase::Unavailable(
+                        "Finish composing the current character before starting dictation.".into(),
+                    );
+                    cx.emit(DictationInputEvent::Changed);
+                }
+                _ => {
+                    if let Some(service) = crate::dictation::start(cx) {
+                        input.begin_dictation(service, cx);
+                    }
+                }
+            });
+        self.focus_pending |= refocus;
+        cx.notify();
+    }
+
+    /// Hold to talk: the microphone or the shortcut going down starts
+    /// dictation. Pressing during a session started by assistive Click takes
+    /// it over, so releasing finishes it.
+    fn press_dictation(&mut self, source: HoldSource, cx: &mut Context<Self>) {
+        use crate::dictation::Phase;
+        let phase = self.input.read(cx).dictation.phase.clone();
+        // Repeats from the same source are ignored. Another source takes the
+        // session over, so a hold whose release went missing (focus moved
+        // within the composer) can always be ended.
+        if phase.active()
+            && self
+                .dictation_hold
+                .as_ref()
+                .is_some_and(|hold| hold.source == source)
+        {
+            return;
+        }
+        self.dictation_hold = None;
+        match phase {
+            Phase::Finalizing => {}
+            Phase::Requesting | Phase::Listening => {
+                self.dictation_hold = Some(DictationHold {
+                    source,
+                    started: None,
+                });
+            }
+            _ => {
+                self.toggle_dictation(source != HoldSource::Button, cx);
+                if self.input.read(cx).dictation.phase.active() {
+                    self.dictation_hold = Some(DictationHold {
+                        source,
+                        started: Some(Instant::now()),
+                    });
+                }
+            }
+        }
+    }
+
+    /// Letting go transcribes what was said. A tap explains hold to talk,
+    /// and a release that only answered the permission prompt records nothing.
+    fn release_dictation(&mut self, source: HoldSource, cx: &mut Context<Self>) {
+        use crate::dictation::Phase;
+        if self
+            .dictation_hold
+            .as_ref()
+            .is_none_or(|hold| hold.source != source)
+        {
+            return;
+        }
+        let tapped = self
+            .dictation_hold
+            .take()
+            .and_then(|hold| hold.started)
+            .is_some_and(|started| started.elapsed() < DICTATION_TAP);
+        self.input
+            .update(cx, |input, cx| match input.dictation.phase {
+                Phase::Requesting if crate::dictation::permission_pending() => {
+                    input.cancel_dictation();
+                    cx.emit(DictationInputEvent::Changed);
+                    cx.notify();
+                }
+                Phase::Requesting | Phase::Listening if tapped => {
+                    input.cancel_dictation();
+                    input.dictation.phase = Phase::Tapped;
+                    cx.emit(DictationInputEvent::Changed);
+                    cx.notify();
+                }
+                Phase::Requesting | Phase::Listening => {
+                    input.finish_dictation(false, cx);
+                }
+                _ => {}
+            });
+        // Only the pointer moved focus to the microphone. A key hold already
+        // sits in the editor (or focus has left it on purpose), and Enter/Space
+        // keeps the microphone focused.
+        self.focus_pending |= source == HoldSource::Pointer;
+        cx.notify();
+    }
+
+    /// Microphone at rest; the one Stop control while dictating. `t` morphs
+    /// the mic glyph out and the accent glass plate, stop square or spinner
+    /// in; the glow follows the live voice level.
+    fn render_dictation_button(
+        &self,
+        t: f32,
+        frame: Option<&VoiceFrame>,
+        cx: &mut Context<Self>,
+    ) -> Option<gpui::AnyElement> {
+        use crate::dictation::{Phase, glass, waveform::Mode};
+        if !crate::dictation::enabled(cx) || self.wizard.is_some() {
+            return None;
+        }
+        let theme = Theme::of(cx).clone();
+        let phase = self.input.read(cx).dictation.phase.clone();
+        let active = phase.active();
+        let label = phase.action_label().to_owned();
+        let live = frame.is_some_and(|f| f.mode == Mode::Live);
+        let glow = frame.map_or(0.0, |f| f.level * f.level.sqrt());
+        // Spinner while the microphone opens or the model transcribes; the
+        // stop square once the voice is live (and while retracting from it).
+        let busy = matches!(phase, Phase::Requesting | Phase::Finalizing)
+            || (!active && frame.is_some_and(|f| f.mode != Mode::Live));
+        let tooltip = label.clone();
+        let composer = cx.entity().downgrade();
+        let centered = || {
+            div()
+                .absolute()
+                .inset_0()
+                .flex()
+                .items_center()
+                .justify_center()
+        };
+        let button = div()
+            .id("composer-dictation")
+            .debug_selector(|| "composer-dictation".into())
+            .relative()
+            .size(px(28.0))
+            .flex_none()
+            .rounded_full()
+            .role(Role::Button)
+            .aria_label(label)
+            .aria_toggled(if active {
+                gpui::Toggled::True
+            } else {
+                gpui::Toggled::False
+            })
+            .tab_index(0)
+            .cursor_pointer()
+            // At rest it is a sibling of the paperclip: the same eased ink
+            // wash. Live, it is the accent plate and dims like Send.
+            .on_hover(motion::hover_listener("composer-dictation"))
+            .when(t <= 0.0, |el| {
+                el.bg(motion::hover_blend(
+                    "composer-dictation",
+                    gpui::transparent_black(),
+                    crate::theme::ink(0.10),
+                ))
+            })
+            .when(t > 0.0, |el| {
+                glass::accent(el, &theme, t, glow).hover(|style| style.opacity(0.85))
+            })
+            .focus_visible(|style| style.border_1().border_color(theme.accent))
+            .tooltip(crate::settings::widgets::text_tooltip(tooltip))
+            .on_mouse_down(
+                MouseButton::Left,
+                cx.listener(|this, _, _, cx| this.press_dictation(HoldSource::Pointer, cx)),
+            )
+            .on_mouse_up(
+                MouseButton::Left,
+                cx.listener(|this, _, _, cx| this.release_dictation(HoldSource::Pointer, cx)),
+            )
+            .on_mouse_up_out(
+                MouseButton::Left,
+                cx.listener(|this, _, _, cx| this.release_dictation(HoldSource::Pointer, cx)),
+            )
+            .on_key_down(cx.listener(|this, event: &KeyDownEvent, _, cx| {
+                if matches!(event.keystroke.key.as_str(), "enter" | "space") {
+                    cx.stop_propagation();
+                    if !event.is_held {
+                        this.press_dictation(HoldSource::Button, cx);
+                    }
+                }
+            }))
+            .on_key_up(cx.listener(|this, event: &KeyUpEvent, _, cx| {
+                if matches!(event.keystroke.key.as_str(), "enter" | "space") {
+                    cx.stop_propagation();
+                    this.release_dictation(HoldSource::Button, cx);
+                }
+            }))
+            // Assistive technology cannot hold: Click starts, then finishes.
+            .on_a11y_action(gpui::AccessibleAction::Click, move |_, _, cx| {
+                composer
+                    .update(cx, |this, cx| this.toggle_dictation(true, cx))
+                    .ok();
+            })
+            .when(t < 1.0, |el| {
+                let scale = 1.0 - 0.75 * t;
+                el.child(
+                    centered().child(
+                        crate::icons::icon(crate::icons::MICROPHONE)
+                            .size(px(18.0))
+                            .text_color(theme.text_muted.opacity(1.0 - t))
+                            .with_transformation(gpui::Transformation::scale(gpui::size(
+                                scale, scale,
+                            ))),
+                    ),
+                )
+            })
+            .when(t > 0.0 && busy, |el| {
+                el.child(
+                    centered()
+                        .opacity(t)
+                        .child(crate::loaders::mini_mono_spinner(
+                            "dictation-progress",
+                            2.0,
+                            theme.on_accent,
+                            cx.entity_id(),
+                            cx,
+                        )),
+                )
+            })
+            .when(t > 0.0 && !busy, |el| {
+                // Square grows from a quarter of its size, as the mic shrinks.
+                let side = 9.0 * (0.25 + 0.75 * t) * if live { 1.0 + 0.08 * glow } else { 1.0 };
+                el.child(
+                    centered().child(
+                        div()
+                            .size(px(side))
+                            .rounded(px(2.5))
+                            .bg(theme.on_accent.opacity(t)),
+                    ),
+                )
+            });
+        Some(button.into_any_element())
+    }
+
+    fn dismiss_dictation(&mut self, cx: &mut Context<Self>) {
+        self.input.update(cx, |input, cx| {
+            input.cancel_dictation();
+            cx.emit(DictationInputEvent::Changed);
+            cx.notify();
+        });
+        self.focus_pending = true;
+        cx.notify();
+    }
+
+    fn dictation_action_button(
+        &self,
+        active: bool,
+        cx: &mut Context<Self>,
+    ) -> gpui::Stateful<gpui::Div> {
+        let theme = Theme::of(cx);
+        let action_label = if active {
+            "Cancel dictation"
+        } else {
+            "Dismiss dictation message"
+        };
+        let composer = cx.entity().downgrade();
+        div()
+            .id("dictation-dismiss")
+            .debug_selector(|| "dictation-dismiss".into())
+            .role(Role::Button)
+            .aria_label(action_label)
+            .tab_index(0)
+            .flex_none()
+            .h(px(24.0))
+            .px(px(8.0))
+            .flex()
+            .items_center()
+            .rounded_full()
+            .text_color(theme.text_muted)
+            .cursor_pointer()
+            .hover(|s| s.bg(theme.surface_raised_hover).text_color(theme.text))
+            .focus_visible(|s| s.border_1().border_color(theme.accent))
+            .on_click(cx.listener(|this, _, _, cx| this.dismiss_dictation(cx)))
+            .on_key_down(cx.listener(|this, event: &KeyDownEvent, _, cx| {
+                if matches!(event.keystroke.key.as_str(), "enter" | "space") {
+                    cx.stop_propagation();
+                    this.dismiss_dictation(cx);
+                }
+            }))
+            .on_a11y_action(gpui::AccessibleAction::Click, move |_, _, cx| {
+                composer
+                    .update(cx, |this, cx| this.dismiss_dictation(cx))
+                    .ok();
+            })
+    }
+
+    fn render_dictation_status(&self, cx: &mut Context<Self>) -> Option<gpui::AnyElement> {
+        // Live dictation renders inside the composer; only outcomes that
+        // need reading (no speech, errors) appear below it.
+        let phase = self.input.read(cx).dictation.phase.clone();
+        if phase.active() {
+            return None;
+        }
+        let (title, detail) = phase.status()?;
+        let (title, detail) = (title.to_owned(), detail.to_owned());
+        let phase = &phase;
+        let failed = matches!(
+            phase,
+            crate::dictation::Phase::Denied(_)
+                | crate::dictation::Phase::Unavailable(_)
+                | crate::dictation::Phase::Failed(_)
+        );
+        let theme = Theme::of(cx);
+        Some(
+            motion::fade_in(
+                "dictation-message-enter",
+                div()
+                    .id("dictation-status")
+                    .flex()
+                    .items_start()
+                    .gap(px(8.0))
+                    .px(px(12.0))
+                    .text_size(px(12.0))
+                    .line_height(px(18.0))
+                    .child(
+                        div()
+                            .flex_none()
+                            .mt(px(6.0))
+                            .size(px(6.0))
+                            .rounded_full()
+                            .bg(if failed {
+                                theme.warning
+                            } else {
+                                theme.text_faint
+                            }),
+                    )
+                    .child(
+                        div()
+                            .id("dictation-live-status")
+                            .role(Role::Status)
+                            .aria_label(format!("{title}. {detail}"))
+                            .flex_1()
+                            .min_w_0()
+                            .flex()
+                            .flex_wrap()
+                            .gap_x(px(8.0))
+                            .child(div().text_color(theme.text).child(title))
+                            .child(div().min_w_0().text_color(theme.text_muted).child(detail)),
+                    )
+                    .child(
+                        self.dictation_action_button(false, cx)
+                            .mt(px(-3.0))
+                            .child("Dismiss"),
+                    ),
+            )
+            .into_any_element(),
+        )
+    }
+
+    /// Advances the dictation morph. Returns its eased progress and the frame
+    /// to draw: live while dictating, the last live frame while retracting.
+    fn update_voice(&mut self, window: &mut Window, cx: &App) -> (f32, Option<VoiceFrame>) {
+        use crate::dictation::{Phase, waveform::Mode};
+        let now = Instant::now();
+        let reduced = motion::reduced_motion(cx);
+        let dictation = &self.input.read(cx).dictation;
+        let active = dictation.phase.active();
+        self.voice_tween
+            .retarget(if active { 1.0 } else { 0.0 }, now, reduced);
+        let t = self.voice_tween.value(now);
+        if active {
+            let meter = &dictation.meter;
+            let mode = match dictation.phase {
+                Phase::Listening => Mode::Live,
+                Phase::Finalizing if meter.since_start(now).is_some() => Mode::Processing,
+                _ => Mode::Waiting,
+            };
+            let label = dictation
+                .phase
+                .status()
+                .map(|(title, detail)| format!("{title}. {detail}"))
+                .unwrap_or_default();
+            self.voice_last = Some(VoiceFrame {
+                label,
+                mode,
+                bars: meter.bars(now, !reduced),
+                level: if mode == Mode::Live {
+                    meter.level(now)
+                } else {
+                    0.0
+                },
+                elapsed: meter.since_start(now).map(|_| meter.elapsed(now)),
+            });
+        } else if t <= 0.0 {
+            self.voice_last = None;
+        }
+        if !reduced && (active || !self.voice_tween.settled(now)) {
+            // Bars scroll, the glow follows the voice, and the morph advances.
+            window.request_animation_frame();
+        }
+        (t, self.voice_last.clone())
+    }
+
+    /// The waveform track that unrolls from Stop across the action row. `t`
+    /// is the morph progress; the box keeps its final geometry and occludes
+    /// the controls fading out beneath it.
+    fn render_voice_track(
+        &self,
+        t: f32,
+        frame: &VoiceFrame,
+        left: f32,
+        right: f32,
+        top: f32,
+        cx: &mut Context<Self>,
+    ) -> gpui::AnyElement {
+        use crate::dictation::{glass, waveform};
+        let theme = Theme::of(cx).clone();
+        let animate = !motion::reduced_motion(cx);
+        let active = self.input.read(cx).dictation.phase.active();
+        let live = frame.mode == waveform::Mode::Live && active;
+        let clock = frame.elapsed.map(|elapsed| {
+            let limit = Duration::from_secs(zeron_voice::MAX_SECONDS as u64);
+            div()
+                .flex_none()
+                .font_family(theme.font_mono.clone())
+                .text_size(px(11.0))
+                .opacity(t)
+                .text_color(if live && elapsed + VOICE_LIMIT_WARNING >= limit {
+                    theme.warning
+                } else if live {
+                    theme.text_muted
+                } else {
+                    theme.text_faint
+                })
+                .child(waveform::clock(elapsed))
+        });
+        let track = glass::light(
+            div()
+                .id("dictation-live-status")
+                .role(Role::Status)
+                .aria_label(frame.label.clone())
+                .h_full()
+                .w(gpui::relative(t.max(0.0)))
+                .min_w(px(VOICE_TRACK_HEIGHT * t.min(1.0)))
+                .rounded_full()
+                .overflow_hidden()
+                .flex()
+                .items_center()
+                .gap(px(10.0))
+                .pl(px(12.0))
+                .pr(px(12.0)),
+            &theme,
+            t,
+        )
+        .child(
+            div()
+                .flex_1()
+                .min_w_0()
+                .h(px(16.0))
+                .flex()
+                .child(waveform::waveform(
+                    frame.bars.clone(),
+                    frame.mode,
+                    waveform::Paint {
+                        ink: theme.text.opacity(0.8),
+                        quiet: theme.text_faint.opacity(0.5),
+                    },
+                    waveform::Phase {
+                        intro: t,
+                        collapse: if active { 0.0 } else { 1.0 - t },
+                    },
+                    animate,
+                )),
+        )
+        .children(clock);
+        div()
+            .id("dictation-track")
+            .absolute()
+            .left(px(left))
+            .right(px(right))
+            .top(px(top))
+            .h(px(VOICE_TRACK_HEIGHT))
+            .flex()
+            .justify_end()
+            .occlude()
+            .child(track)
+            .into_any_element()
+    }
+
     fn render_send_button(
         &mut self,
         mode: SendButtonMode,
@@ -8829,6 +9761,7 @@ impl Composer {
                 let blocked = self.send_blocked(cx);
                 div()
                     .id("composer-send")
+                    .debug_selector(|| "composer-send".into())
                     .size(px(28.0))
                     .flex_none()
                     .rounded_full()
@@ -8883,6 +9816,48 @@ impl Focusable for Composer {
 
 impl Render for Composer {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        if self.dictation_blur.is_none() {
+            // Stop, Send and keyboard navigation within the composer must not
+            // discard capture. Only leaving the whole composer invalidates it.
+            let focus = self.dictation_focus.clone();
+            self.dictation_blur = Some(cx.on_focus_out(&focus, window, |this, _, _, cx| {
+                this.input.update(cx, |input, cx| {
+                    if !input.dictation.phase.active() {
+                        return;
+                    }
+                    if input.dictation.phase == crate::dictation::Phase::Requesting
+                        && crate::dictation::permission_pending()
+                    {
+                        return;
+                    }
+                    input.cancel_dictation();
+                    cx.emit(DictationInputEvent::Changed);
+                    cx.notify();
+                });
+            }));
+        }
+        if self.dictation_activation.is_none() {
+            self.dictation_activation =
+                Some(cx.observe_window_activation(window, |this, window, cx| {
+                    if !window.is_window_active() {
+                        this.input.update(cx, |input, cx| {
+                            if !input.dictation.phase.active() {
+                                return;
+                            }
+                            // The permission bridge checks the originating key
+                            // window before starting any capture after a prompt.
+                            if input.dictation.phase == crate::dictation::Phase::Requesting
+                                && crate::dictation::permission_pending()
+                            {
+                                return;
+                            }
+                            input.cancel_dictation();
+                            cx.notify();
+                        });
+                        cx.notify();
+                    }
+                }));
+        }
         if self.focus_pending {
             self.focus_pending = false;
             let focus = self.input.focus_handle(cx);
@@ -9339,6 +10314,10 @@ impl Render for Composer {
         });
 
         let send_button = self.render_send_button(mode, cx);
+        let (voice_t, voice_frame) = self.update_voice(window, cx);
+        let dictating = self.input.read(cx).dictation.phase.active();
+        let microphone = self.render_dictation_button(voice_t, voice_frame.as_ref(), cx);
+        let attach_action = cx.entity().downgrade();
         // Attach button — opens the native image picker (the original's hidden
         // `<input type=file accept="image/*" multiple>`); paste/drop also feed
         // the same strip. The leading utility group owns the spacing between
@@ -9359,16 +10338,95 @@ impl Render for Composer {
                 crate::theme::ink(0.10),
             ))
             .on_hover(motion::hover_listener("composer-attach"))
-            .on_click(cx.listener(|this, _, _, cx| this.open_file_picker(cx)))
-            .tooltip(crate::settings::widgets::text_tooltip("Attach images"))
-            .child(
-                crate::icons::icon(crate::icons::PAPERCLIP)
-                    // Its painted bounds are centered in the 24px viewbox;
-                    // a larger glyph balances the brand icon without moving
-                    // it off-center inside the unchanged 28px hit target.
-                    .size(px(18.0))
-                    .text_color(theme.text_muted),
-            );
+            .relative()
+            // While dictating, the attachment slot becomes Cancel: the
+            // paperclip and the cross swap with a scale and fade. The action
+            // follows the dictation phase, never the animation.
+            .role(Role::Button)
+            .aria_label(if dictating {
+                "Cancel dictation"
+            } else {
+                "Attach images"
+            })
+            .tab_index(0)
+            .focus_visible(|style| style.border_1().border_color(theme.accent))
+            .when(dictating, |el| {
+                el.debug_selector(|| "dictation-dismiss".into())
+            })
+            .tooltip(crate::settings::widgets::text_tooltip(if dictating {
+                "Cancel dictation"
+            } else {
+                "Attach images"
+            }))
+            .on_click(cx.listener(move |this, _, _, cx| {
+                if this.input.read(cx).dictation.phase.active() {
+                    this.dismiss_dictation(cx);
+                } else {
+                    this.open_file_picker(cx);
+                }
+            }))
+            .on_key_down(cx.listener(|this, event: &KeyDownEvent, _, cx| {
+                if matches!(event.keystroke.key.as_str(), "enter" | "space") {
+                    cx.stop_propagation();
+                    if this.input.read(cx).dictation.phase.active() {
+                        this.dismiss_dictation(cx);
+                    } else {
+                        this.open_file_picker(cx);
+                    }
+                }
+            }))
+            .on_a11y_action(gpui::AccessibleAction::Click, move |_, _, cx| {
+                attach_action
+                    .update(cx, |this, cx| {
+                        if this.input.read(cx).dictation.phase.active() {
+                            this.dismiss_dictation(cx);
+                        } else {
+                            this.open_file_picker(cx);
+                        }
+                    })
+                    .ok();
+            })
+            .when(voice_t < 1.0, |el| {
+                let scale = 1.0 - 0.75 * voice_t;
+                el.child(
+                    div()
+                        .absolute()
+                        .inset_0()
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .child(
+                            crate::icons::icon(crate::icons::PAPERCLIP)
+                                // Its painted bounds are centered in the 24px viewbox;
+                                // a larger glyph balances the brand icon without moving
+                                // it off-center inside the unchanged 28px hit target.
+                                .size(px(18.0))
+                                .text_color(theme.text_muted.opacity(1.0 - voice_t))
+                                .with_transformation(gpui::Transformation::scale(gpui::size(
+                                    scale, scale,
+                                ))),
+                        ),
+                )
+            })
+            .when(voice_t > 0.0, |el| {
+                let scale = 0.25 + 0.75 * voice_t;
+                el.child(
+                    div()
+                        .absolute()
+                        .inset_0()
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .child(
+                            crate::icons::icon(crate::icons::CLOSE)
+                                .size(px(16.0))
+                                .text_color(theme.text_muted.opacity(voice_t))
+                                .with_transformation(gpui::Transformation::scale(gpui::size(
+                                    scale, scale,
+                                ))),
+                        ),
+                )
+            });
         // Staged-thumbnail strip (attachment-ui.tsx AttachmentStrip), above
         // the input inside the pill in both modes.
         let strip = self.render_attachment_strip(&theme, cx);
@@ -9386,6 +10444,7 @@ impl Render for Composer {
                     // Open menus keep their own keyboard/search focus.
                     if !this.pickers.read(cx).is_open() {
                         window.focus(&this.input.focus_handle(cx), cx);
+                        window.prevent_default();
                     }
                 }),
             )
@@ -9427,6 +10486,38 @@ impl Render for Composer {
                 .inset_0(),
             )
         };
+        // The model chip already contributes 6px of trailing padding. Remove
+        // that from its gap to the narrow microphone glyph so the visible
+        // label–mic and mic–Send spaces balance without shrinking hit targets.
+        let model_action_gap = if microphone.is_some() {
+            ACTION_PRIMARY_GAP - 6.0
+        } else {
+            ACTION_PRIMARY_GAP
+        };
+        // The voice track spans from the attachment slot to Stop, over the
+        // model selector (and, compact, the text), which fade beneath it.
+        let voice_track = voice_frame
+            .as_ref()
+            .filter(|_| voice_t > 0.0 && microphone.is_some())
+            .map(|frame| {
+                // Expanded: the row's 2px top pad; compact: centred in the
+                // 47px line, riding the same cluster glide as the buttons.
+                let top = if expanded {
+                    2.0
+                } else {
+                    (COMPACT_TOTAL_HEIGHT - PILL_BORDER_V - VOICE_TRACK_HEIGHT) / 2.0 - cluster_dy
+                };
+                self.render_voice_track(
+                    voice_t,
+                    frame,
+                    action_inset + 28.0 + VOICE_TRACK_GAP,
+                    action_inset + 28.0 + ACTION_PRIMARY_GAP + 28.0 + VOICE_TRACK_GAP,
+                    top,
+                    cx,
+                )
+            });
+        let beneath_voice = 1.0 - voice_t.clamp(0.0, 1.0);
+        let model_picker = model_picker.opacity(beneath_voice);
         let body = if expanded {
             // Expanded: textarea on top (`px-4 pb-1 pt-4`), actions row
             // (8px bottom + 2px top, 32px chips → 42px) ABSOLUTE at the pill's
@@ -9464,8 +10555,8 @@ impl Render for Composer {
                         .flex()
                         .flex_row()
                         .items_center()
-                        // Attachment stays left; model and Send stay right.
-                        .gap(px(ACTION_PRIMARY_GAP))
+                        // Attachment stays left; model, microphone and Send stay right.
+                        .gap(px(model_action_gap))
                         .px(px(action_inset))
                         .pt(px(2.0))
                         .pb(px(ACTIONS_BOTTOM_PAD))
@@ -9480,16 +10571,25 @@ impl Render for Composer {
                                 .child(attach),
                         )
                         .child(model_picker)
-                        .child(send_button),
+                        .child(
+                            div()
+                                .flex_none()
+                                .flex()
+                                .items_center()
+                                .gap(px(ACTION_PRIMARY_GAP))
+                                .children(microphone)
+                                .child(send_button),
+                        )
+                        .children(voice_track),
                 )
         } else {
             // Compact pill: attachment on the left, input in the middle,
-            // then model and Send on the right, all on one 47px line.
+            // then model, microphone and Send on the right, all on one 47px line.
             // The row is BOTTOM-justified: during the collapse morph the pill
             // top sweeps down over a stationary row, the text walks down from
             // its expanded resting place via a decaying relative offset, and
             // attachment/Send hold their spots (the centering delta gliding
-            // in). The model selector remains beside Send.
+            // in). The model selector remains beside microphone and Send.
             let text_glide = if dock_owns_layout {
                 collapse_text_glide(dock_layout.hero_height, dock_compact_amount)
             } else {
@@ -9509,6 +10609,7 @@ impl Render for Composer {
                 .child(
                     div()
                         .h(px(COMPACT_TOTAL_HEIGHT - PILL_BORDER_V))
+                        .relative()
                         .flex()
                         .flex_row()
                         .items_center()
@@ -9518,6 +10619,9 @@ impl Render for Composer {
                                 .pl(px(action_inset))
                                 .relative()
                                 .top(px(-cluster_dy))
+                                .flex()
+                                .items_center()
+                                .gap(px(ACTION_UTILITY_GAP))
                                 .child(attach),
                         )
                         .child(
@@ -9527,6 +10631,9 @@ impl Render for Composer {
                                 .px(px(8.0))
                                 .relative()
                                 .top(px(-text_glide))
+                                // The draft waits under the voice track and
+                                // fades back as the transcript lands in it.
+                                .opacity(beneath_voice)
                                 .child(self.render_input_with_completion()),
                         )
                         .child(
@@ -9540,12 +10647,17 @@ impl Render for Composer {
                         .child(
                             div()
                                 .flex_none()
-                                .pl(px(ACTION_PRIMARY_GAP))
+                                .pl(px(model_action_gap))
                                 .pr(px(action_inset))
                                 .relative()
                                 .top(px(-cluster_dy))
+                                .flex()
+                                .items_center()
+                                .gap(px(ACTION_PRIMARY_GAP))
+                                .children(microphone)
                                 .child(send_button),
-                        ),
+                        )
+                        .children(voice_track),
                 )
         };
         let new_thread_target_selectors = (new_thread_chrome_opacity > 0.0).then(|| {
@@ -9626,7 +10738,24 @@ impl Render for Composer {
         } else {
             container
         };
-        let container = container.child(pill_surface);
+        let dictation_status = self.render_dictation_status(cx);
+        let container = container.child(
+            div()
+                .track_focus(&self.dictation_focus)
+                .on_key_down(cx.listener(|this, event: &KeyDownEvent, _, cx| {
+                    if event.keystroke.key == "escape"
+                        && this.input.read(cx).dictation.phase.active()
+                    {
+                        this.dismiss_dictation(cx);
+                        cx.stop_propagation();
+                    }
+                }))
+                .flex()
+                .flex_col()
+                .gap(px(Theme::SPACE_SM))
+                .child(pill_surface)
+                .children(dictation_status),
+        );
 
         // The lower slot keeps a stable footprint for Git projects while its
         // old floating checkout/ref controls dissolve into the session footer.
@@ -9737,7 +10866,7 @@ mod modal_selection_tests;
 mod tests {
     use super::*;
 
-    fn composer_focus_window(
+    pub(super) fn composer_focus_window(
         cx: &mut gpui::TestAppContext,
     ) -> (tempfile::TempDir, gpui::WindowHandle<Composer>) {
         let dir = tempfile::tempdir().unwrap();
@@ -14111,3 +15240,7 @@ impl Composer {
         cx.notify();
     }
 }
+
+#[cfg(test)]
+#[path = "composer_dictation_tests.rs"]
+mod dictation_tests;
diff --git a/crates/ui/src/composer_dictation_tests.rs b/crates/ui/src/composer_dictation_tests.rs
new file mode 100644
index 0000000000..30e0f19914
--- /dev/null
+++ b/crates/ui/src/composer_dictation_tests.rs
@@ -0,0 +1,1199 @@
+use super::*;
+use crate::dictation::{Event, Phase, Transcriber};
+use gpui::{AppContext, TestAppContext};
+use std::{cell::RefCell, collections::VecDeque};
+
+#[derive(Default)]
+struct FakeState {
+    events: VecDeque<Event>,
+    finishes: usize,
+    drops: usize,
+}
+
+struct Fake(Rc<RefCell<FakeState>>);
+impl Transcriber for Fake {
+    fn poll(&mut self) -> Option<Event> {
+        self.0.borrow_mut().events.pop_front()
+    }
+    fn finish(&mut self) {
+        self.0.borrow_mut().finishes += 1;
+    }
+}
+impl Drop for Fake {
+    fn drop(&mut self) {
+        self.0.borrow_mut().drops += 1;
+    }
+}
+
+fn start(input: &mut ComposerInput, cx: &mut Context<ComposerInput>) -> Rc<RefCell<FakeState>> {
+    let fake = Rc::new(RefCell::new(FakeState::default()));
+    input.begin_dictation(Box::new(Fake(fake.clone())), cx);
+    fake
+}
+
+fn deliver(
+    input: &mut ComposerInput,
+    fake: &Rc<RefCell<FakeState>>,
+    events: impl IntoIterator<Item = Event>,
+    cx: &mut Context<ComposerInput>,
+) {
+    fake.borrow_mut().events.extend(events);
+    input.poll_dictation(input.dictation.generation, cx);
+}
+
+#[gpui::test]
+fn dictation_replaces_unicode_selection_and_undoes_as_one_edit(cx: &mut TestAppContext) {
+    cx.update(|cx| cx.set_global(Theme::dark()));
+    let window = cx.add_window(|_, cx| ComposerInput::new("Draft", cx));
+    window
+        .update(cx, |input, window, cx| {
+            input.set_text("👩🏽‍💻 replace café", cx);
+            let begin = input.content.find("replace").unwrap();
+            input.selected_range = begin..begin + "replace".len();
+            let fake = start(input, cx);
+            deliver(
+                input,
+                &fake,
+                [
+                    Event::Listening,
+                    Event::Partial("你好".into()),
+                    Event::Partial("bonjour 🌍".into()),
+                ],
+                cx,
+            );
+            assert_eq!(input.content, "👩🏽‍💻 bonjour 🌍 café");
+            assert_eq!(input.undo_stack.len(), 1);
+            input.finish_dictation(false, cx);
+            deliver(input, &fake, [Event::Final("salut 🌍".into())], cx);
+            assert_eq!(input.content, "👩🏽‍💻 salut 🌍 café");
+            assert_eq!(fake.borrow().drops, 1);
+            input.undo(&Undo, window, cx);
+            assert_eq!(input.content, "👩🏽‍💻 replace café");
+            assert_eq!(input.selected_range, begin..begin + 7);
+            input.redo(&Redo, window, cx);
+            assert_eq!(input.content, "👩🏽‍💻 salut 🌍 café");
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_manual_edit_stops_before_replacing_partial(cx: &mut TestAppContext) {
+    cx.update(|cx| cx.set_global(Theme::dark()));
+    let window = cx.add_window(|_, cx| ComposerInput::new("Draft", cx));
+    window
+        .update(cx, |input, window, cx| {
+            input.set_text("before after", cx);
+            input.selected_range = 7..7;
+            let fake = start(input, cx);
+            let old_generation = input.dictation.generation;
+            deliver(input, &fake, [Event::Partial("speech ".into())], cx);
+            input.replace_text_in_range(Some(7..13), "typed", window, cx);
+            assert_eq!(input.content, "before typed after");
+            assert_eq!(fake.borrow().drops, 1);
+            fake.borrow_mut()
+                .events
+                .push_back(Event::Final("stale".into()));
+            assert!(!input.poll_dictation(old_generation, cx));
+            assert_eq!(input.content, "before typed after");
+            input.undo(&Undo, window, cx);
+            assert_eq!(input.content, "before speech after");
+            input.undo(&Undo, window, cx);
+            assert_eq!(input.content, "before after");
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_ime_commit_preserves_composition_and_history(cx: &mut TestAppContext) {
+    cx.update(|cx| cx.set_global(Theme::dark()));
+    let window = cx.add_window(|_, cx| ComposerInput::new("Draft", cx));
+    window
+        .update(cx, |input, window, cx| {
+            let fake = start(input, cx);
+            deliver(input, &fake, [Event::Partial("Hello ".into())], cx);
+            input.replace_and_mark_text_in_range(None, "に", None, window, cx);
+            assert_eq!(fake.borrow().drops, 1);
+            input.replace_and_mark_text_in_range(None, "日本", None, window, cx);
+            input.replace_text_in_range(None, "日本語", window, cx);
+            assert_eq!(input.content, "Hello 日本語");
+            input.undo(&Undo, window, cx);
+            assert_eq!(input.content, "Hello ");
+            input.undo(&Undo, window, cx);
+            assert_eq!(input.content, "");
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_selection_move_and_undo_during_permissions_cancel(cx: &mut TestAppContext) {
+    cx.update(|cx| cx.set_global(Theme::dark()));
+    let window = cx.add_window(|_, cx| ComposerInput::new("Draft", cx));
+    window
+        .update(cx, |input, window, cx| {
+            input.set_text("draft", cx);
+            let fake = start(input, cx);
+            input.undo(&Undo, window, cx); // No history is still a deliberate cancellation.
+            assert_eq!(fake.borrow().drops, 1);
+            let fake = start(input, cx);
+            deliver(input, &fake, [Event::Partial(" words".into())], cx);
+            input.move_to(0, cx);
+            assert_eq!(fake.borrow().drops, 1);
+            assert_eq!(input.content, "draft words");
+            assert_eq!(input.selected_range, 0..0);
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_send_finalizes_once_and_keeps_latest_final(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        let fake = start(input, cx);
+        deliver(
+            input,
+            &fake,
+            [Event::Listening, Event::Partial("hel".into())],
+            cx,
+        );
+        assert!(input.finish_dictation(true, cx));
+        assert!(input.finish_dictation(true, cx));
+        assert!(input.finish_dictation(false, cx));
+        assert_eq!(fake.borrow().finishes, 1);
+        deliver(
+            input,
+            &fake,
+            [
+                Event::Final("hello".into()),
+                Event::Final("duplicate".into()),
+            ],
+            cx,
+        );
+        assert_eq!(input.content, "hello");
+        assert_eq!(input.dictation.phase, Phase::Idle);
+        assert_eq!(fake.borrow().drops, 1);
+    });
+    let mut sends = 0;
+    while let Ok(event) = events.try_recv() {
+        if matches!(event, DictationInputEvent::Submit(_)) {
+            sends += 1;
+        }
+    }
+    assert_eq!(sends, 1);
+}
+
+#[gpui::test]
+fn dictation_failure_cancels_send_and_retry_preserves_draft(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        let fake = start(input, cx);
+        deliver(input, &fake, [Event::Partial("keep me".into())], cx);
+        input.finish_dictation(true, cx);
+        deliver(input, &fake, [Event::Failed("Disconnected".into())], cx);
+        assert_eq!(input.content, "keep me");
+        assert_eq!(input.dictation.phase, Phase::Failed("Disconnected".into()));
+        assert_eq!(fake.borrow().drops, 1);
+        for error in [
+            Event::Denied("Permission denied".into()),
+            Event::Unavailable("Locale unavailable".into()),
+        ] {
+            let fake = start(input, cx);
+            deliver(input, &fake, [error], cx);
+            assert_eq!(input.content, "keep me");
+            assert!(!input.dictation.phase.active());
+            assert_eq!(fake.borrow().drops, 1);
+        }
+        let fake = start(input, cx);
+        deliver(
+            input,
+            &fake,
+            [
+                Event::Partial(" again".into()),
+                Event::Final(" again".into()),
+            ],
+            cx,
+        );
+        assert_eq!(input.content, "keep me again");
+    });
+    while let Ok(event) = events.try_recv() {
+        assert!(!matches!(event, DictationInputEvent::Submit(_)));
+    }
+}
+
+#[gpui::test]
+fn dictation_empty_final_retains_selection_or_partial(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    input.update(cx, |input, cx| {
+        for partial in [None, Some("replacement")] {
+            input.set_text("selected", cx);
+            input.selected_range = 0..8;
+            let fake = start(input, cx);
+            if let Some(text) = partial {
+                deliver(input, &fake, [Event::Partial(text.into())], cx);
+            }
+            input.finish_dictation(false, cx);
+            deliver(input, &fake, [Event::Final(String::new())], cx);
+            assert_eq!(input.content, partial.unwrap_or("selected"));
+            assert_eq!(input.undo_stack.len(), usize::from(partial.is_some()));
+        }
+    });
+}
+
+#[gpui::test]
+fn dictation_draft_swap_invalidates_permissions_finalization_and_stale_results(
+    cx: &mut TestAppContext,
+) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        for finalizing in [false, true] {
+            input.set_text("original", cx);
+            let fake = start(input, cx);
+            let generation = input.dictation.generation;
+            if finalizing {
+                input.finish_dictation(true, cx);
+            }
+            input.set_text("different chat / queued draft", cx);
+            fake.borrow_mut()
+                .events
+                .extend([Event::Listening, Event::Final("late".into())]);
+            assert!(!input.poll_dictation(generation, cx));
+            assert_eq!(fake.borrow().drops, 1);
+            assert_eq!(input.content, "different chat / queued draft");
+            assert!(input.undo_stack.is_empty());
+        }
+    });
+    while let Ok(event) = events.try_recv() {
+        assert!(!matches!(event, DictationInputEvent::Submit(_)));
+    }
+}
+
+#[gpui::test]
+fn dictation_cancelled_native_capture_drops_pending_send(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        let fake = start(input, cx);
+        deliver(input, &fake, [Event::Partial("keep draft".into())], cx);
+        input.finish_dictation(true, cx);
+        deliver(input, &fake, [Event::Cancelled], cx);
+        assert_eq!(fake.borrow().drops, 1);
+        assert_eq!(input.content, "keep draft");
+        assert_eq!(input.dictation.phase, Phase::Idle);
+    });
+    while let Ok(event) = events.try_recv() {
+        assert!(!matches!(event, DictationInputEvent::Submit(_)));
+    }
+}
+
+#[gpui::test]
+fn dictation_releasing_input_releases_microphone(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let fake = input.update(cx, |input, cx| start(input, cx));
+    drop(input);
+    cx.update(|_| {}); // Entity cleanup runs at the end of the update.
+    assert_eq!(fake.borrow().drops, 1);
+}
+
+#[gpui::test]
+fn dictation_empty_send_does_not_interrupt_or_send(cx: &mut TestAppContext) {
+    let state = cx.new(|_| AppState::new());
+    let composer = cx.new(|cx| Composer::new(state, cx));
+    composer.update(cx, |composer, cx| {
+        composer.input.update(cx, |input, cx| {
+            let fake = start(input, cx);
+            input.finish_dictation(true, cx);
+            deliver(input, &fake, [Event::Final(String::new())], cx);
+        });
+    });
+    composer.read_with(cx, |composer, _| {
+        assert!(
+            composer.failure.is_none(),
+            "must not attempt a send to the disconnected engine"
+        );
+        assert!(!composer.sending);
+        assert!(composer.interrupting.is_empty());
+    });
+}
+
+#[gpui::test]
+fn dictation_timeout_preserves_latest_partial_without_sending(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        let fake = start(input, cx);
+        deliver(input, &fake, [Event::Partial("latest".into())], cx);
+        // Drive the same deadline without a wall-clock sleep or real audio.
+        input
+            .dictation
+            .finish(true, Instant::now() - crate::dictation::FINALIZE_TIMEOUT);
+        let generation = input.dictation.generation;
+        assert!(!input.poll_dictation(generation, cx));
+        assert!(!input.poll_dictation(generation, cx));
+        assert_eq!(input.content, "latest");
+        assert_eq!(fake.borrow().drops, 1);
+    });
+    let mut sends = 0;
+    while let Ok(event) = events.try_recv() {
+        if matches!(event, DictationInputEvent::Submit(_)) {
+            sends += 1;
+        }
+    }
+    assert_eq!(sends, 0);
+}
+
+#[gpui::test]
+fn dictation_mention_and_slash_completion_commit_partial_first(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    input.update(cx, |input, cx| {
+        input.enable_mentions();
+        input.set_text("@sr", cx);
+        let fake = start(input, cx);
+        deliver(input, &fake, [Event::Partial(" extra".into())], cx);
+        input.replace_mention(0..3, "src/lib.rs", false, cx);
+        assert_eq!(fake.borrow().drops, 1);
+        assert!(input.content.contains("src/lib.rs"));
+        assert!(input.content.ends_with(" extra"));
+        input.set_text("/com", cx);
+        let fake = start(input, cx);
+        input.replace_plain_token(0..4, "/compact", cx);
+        assert_eq!(fake.borrow().drops, 1);
+        assert_eq!(input.content, "/compact ");
+    });
+}
+
+#[gpui::test]
+fn dictation_queue_save_waits_for_final_and_cancel_drops_capture(cx: &mut TestAppContext) {
+    let state = cx.new(|_| AppState::new());
+    let composer = cx.new(|cx| Composer::new(state, cx));
+    let fake = composer.update(cx, |composer, cx| {
+        composer.editing_queued = Some("queued-row".into());
+        let fake = composer.input.update(cx, |input, cx| {
+            let fake = start(input, cx);
+            deliver(
+                input,
+                &fake,
+                [Event::Listening, Event::Partial("draft".into())],
+                cx,
+            );
+            fake
+        });
+        assert!(composer.commit_queue_edit(cx));
+        assert!(composer.commit_queue_edit(cx));
+        assert!(
+            composer.failure.is_none(),
+            "queue save must wait for the final result"
+        );
+        assert_eq!(fake.borrow().finishes, 1);
+        fake
+    });
+    composer.update(cx, |composer, cx| {
+        composer.input.update(cx, |input, cx| {
+            deliver(input, &fake, [Event::Final("final queue draft".into())], cx)
+        });
+    });
+    composer.read_with(cx, |composer, cx| {
+        assert_eq!(composer.input.read(cx).text(), "final queue draft");
+        // A disconnected test host reports a lease error only AFTER finalization.
+        assert!(
+            composer
+                .failure
+                .as_ref()
+                .is_some_and(|s| s.contains("lease"))
+        );
+    });
+    composer.update(cx, |composer, cx| {
+        let fake = composer.input.update(cx, |input, cx| start(input, cx));
+        composer.cancel_queue_edit(cx);
+        assert_eq!(fake.borrow().drops, 1);
+        let fake = composer.input.update(cx, |input, cx| start(input, cx));
+        composer.clear_queue_edit(cx);
+        assert_eq!(
+            fake.borrow().drops,
+            1,
+            "clearing an edit without a saved draft must still stop capture"
+        );
+    });
+}
+
+#[gpui::test]
+fn dictation_completed_send_event_cannot_send_a_replacement_draft(cx: &mut TestAppContext) {
+    let state = cx.new(|_| AppState::new());
+    let composer = cx.new(|cx| Composer::new(state, cx));
+    composer.update(cx, |composer, cx| {
+        composer.input.update(cx, |input, cx| {
+            let fake = start(input, cx);
+            input.finish_dictation(true, cx);
+            deliver(input, &fake, [Event::Final("old draft".into())], cx);
+            // The Submit effect is queued; invalidate it before effects flush.
+            input.set_text("new draft", cx);
+        });
+    });
+    composer.read_with(cx, |composer, cx| {
+        assert!(composer.failure.is_none());
+        assert!(!composer.sending);
+        assert_eq!(composer.input.read(cx).text(), "new draft");
+    });
+}
+
+#[cfg(target_os = "macos")]
+#[gpui::test]
+fn dictation_shortcut_holds_until_its_modifier_is_released(cx: &mut TestAppContext) {
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    cx.update(|cx| {
+        crate::shell::apply_keymap(
+            cx,
+            &crate::settings::KeymapConfig::default(),
+            ComposerSendBehavior::Enter,
+        )
+    });
+    let fake = handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                let fake = start(input, cx);
+                deliver(
+                    input,
+                    &fake,
+                    [Event::Listening, Event::Partial("keyboard".into())],
+                    cx,
+                );
+                fake
+            })
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    // Key down and its auto-repeat hold the recording open.
+    cx.simulate_keystrokes(handle.into(), "cmd-d cmd-d");
+    cx.run_until_parked();
+    assert_eq!(fake.borrow().finishes, 0);
+    let mut visual = gpui::VisualTestContext::from_window(handle.into(), cx);
+    visual.simulate_modifiers_change(gpui::Modifiers::command());
+    assert_eq!(
+        fake.borrow().finishes,
+        0,
+        "D up alone never arrives on macOS"
+    );
+    // Letting go of Command ends the hold.
+    visual.simulate_modifiers_change(gpui::Modifiers::none());
+    assert_eq!(fake.borrow().finishes, 1);
+    handle
+        .update(cx, |composer, window, cx| {
+            assert!(composer.input.read(cx).focus_handle.is_focused(window));
+            assert_eq!(composer.input.read(cx).dictation.phase, Phase::Finalizing);
+            composer.input.update(cx, |input, cx| {
+                deliver(input, &fake, [Event::Final("keyboard".into())], cx)
+            });
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_pointer_hold_finishes_on_release_even_outside_the_button(cx: &mut TestAppContext) {
+    let (dir, handle) = super::tests::composer_focus_window(cx);
+    enable_dictation(dir.path(), cx);
+    for release_outside in [false, true] {
+        let fake = handle
+            .update(cx, |composer, _, cx| {
+                composer.input.update(cx, |input, cx| {
+                    let fake = start(input, cx);
+                    deliver(input, &fake, [Event::Listening], cx);
+                    fake
+                })
+            })
+            .unwrap();
+        cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+            .unwrap();
+        let mut visual = gpui::VisualTestContext::from_window(handle.into(), cx);
+        let button = visual.debug_bounds("composer-dictation").unwrap();
+        visual.simulate_mouse_down(
+            button.center(),
+            MouseButton::Left,
+            gpui::Modifiers::default(),
+        );
+        assert_eq!(fake.borrow().finishes, 0, "holding keeps recording");
+        let up = if release_outside {
+            button.origin - point(px(40.0), px(40.0))
+        } else {
+            button.center()
+        };
+        visual.simulate_mouse_up(up, MouseButton::Left, gpui::Modifiers::default());
+        assert_eq!(fake.borrow().drops, 0, "release must finish, not cancel");
+        assert_eq!(fake.borrow().finishes, 1, "outside={release_outside}");
+        handle
+            .update(cx, |composer, _, cx| {
+                composer.input.update(cx, |input, cx| {
+                    assert_eq!(input.dictation.phase, Phase::Finalizing);
+                    deliver(input, &fake, [Event::Final("Bonjour".into())], cx);
+                });
+            })
+            .unwrap();
+    }
+}
+
+#[gpui::test]
+fn dictation_tap_explains_hold_to_talk_without_transcribing(cx: &mut TestAppContext) {
+    let (dir, handle) = super::tests::composer_focus_window(cx);
+    enable_dictation(dir.path(), cx);
+    let fake = handle
+        .update(cx, |composer, _, cx| {
+            let fake = composer.input.update(cx, |input, cx| {
+                input.set_text("keep", cx);
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                fake
+            });
+            // As if this press had just started the session.
+            composer.dictation_hold = Some(DictationHold {
+                source: HoldSource::Pointer,
+                started: Some(Instant::now()),
+            });
+            fake
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    let mut visual = gpui::VisualTestContext::from_window(handle.into(), cx);
+    let button = visual.debug_bounds("composer-dictation").unwrap();
+    visual.simulate_mouse_up(
+        button.center(),
+        MouseButton::Left,
+        gpui::Modifiers::default(),
+    );
+    assert_eq!(fake.borrow().finishes, 0);
+    assert_eq!(fake.borrow().drops, 1, "a tap releases the microphone");
+    handle
+        .read_with(cx, |composer, cx| {
+            let input = composer.input.read(cx);
+            assert_eq!(input.dictation.phase, Phase::Tapped);
+            assert_eq!(input.text(), "keep");
+            assert!(composer.dictation_hold.is_none());
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_switching_windows_releases_capture_and_retains_draft(cx: &mut TestAppContext) {
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    handle
+        .update(cx, |_, window, _| window.activate_window())
+        .unwrap();
+    cx.run_until_parked();
+    let fake = handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                let fake = start(input, cx);
+                deliver(
+                    input,
+                    &fake,
+                    [Event::Listening, Event::Partial("keep on switch".into())],
+                    cx,
+                );
+                input.finish_dictation(true, cx);
+                fake
+            })
+        })
+        .unwrap();
+    let other = cx.add_window(|_, cx| ComposerInput::new("Other window", cx));
+    other
+        .update(cx, |_, window, _| window.activate_window())
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(fake.borrow().drops, 1);
+    handle
+        .read_with(cx, |composer, cx| {
+            assert_eq!(composer.input.read(cx).text(), "keep on switch");
+            assert_eq!(composer.input.read(cx).dictation.phase, Phase::Idle);
+            assert!(composer.failure.is_none());
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_question_takeover_stops_capture_without_losing_draft(cx: &mut TestAppContext) {
+    let state = cx.new(|_| AppState::new());
+    let composer = cx.new(|cx| Composer::new(state.clone(), cx));
+    let fake = composer.update(cx, |composer, cx| {
+        composer.input.update(cx, |input, cx| {
+            let fake = start(input, cx);
+            deliver(input, &fake, [Event::Partial("preserved draft".into())], cx);
+            fake
+        })
+    });
+    state.update(cx, |state, cx| {
+        state.transcript = vec![SessionMessageEntry {
+            duration_ms: None,
+            id: "question-message".into(),
+            role: MessageRole::Assistant,
+            created_at: 0,
+            device_id: "host".into(),
+            status: None,
+            continuation_of: None,
+            parts: vec![MessagePart::Input {
+                id: "input".into(),
+                request_id: "request".into(),
+                resolved: false,
+                questions: vec![UserInputQuestion {
+                    id: "q".into(),
+                    header: "Choose".into(),
+                    question: "Continue?".into(),
+                    options: vec!["Yes".into()],
+                    multi_select: false,
+                    prefill: None,
+                    multiline: false,
+                }],
+            }],
+        }];
+        cx.notify();
+    });
+    assert_eq!(fake.borrow().drops, 1);
+    composer.read_with(cx, |composer, cx| {
+        assert!(composer.wizard.is_some());
+        // The question borrows the editor; the dictated draft waits under the
+        // chat's key until the question closes.
+        assert_eq!(composer.input.read(cx).text(), "");
+        assert_eq!(
+            composer
+                .drafts
+                .get(&composer.current_key)
+                .map(String::as_str),
+            Some("preserved draft")
+        );
+    });
+}
+
+#[gpui::test]
+fn dictation_pointer_stop_keeps_capture_until_final_result(cx: &mut TestAppContext) {
+    let (dir, handle) = super::tests::composer_focus_window(cx);
+    enable_dictation(dir.path(), cx);
+    let fake = handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                fake
+            })
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    let mut visual = gpui::VisualTestContext::from_window(handle.into(), cx);
+    let button = visual.debug_bounds("composer-dictation").unwrap();
+    visual.simulate_click(button.center(), gpui::Modifiers::default());
+    assert_eq!(
+        fake.borrow().drops,
+        0,
+        "Stop must finish, not cancel, the recording"
+    );
+    assert_eq!(fake.borrow().finishes, 1);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                assert_eq!(input.dictation.phase, Phase::Finalizing);
+                deliver(input, &fake, [Event::Final("Bonjour".into())], cx);
+                assert_eq!(input.text(), "Bonjour");
+            })
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_pointer_send_waits_for_final_and_submits_once(cx: &mut TestAppContext) {
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    let (input, fake) = handle
+        .update(cx, |composer, _, cx| {
+            let fake = composer.input.update(cx, |input, cx| {
+                let fake = start(input, cx);
+                deliver(
+                    input,
+                    &fake,
+                    [Event::Listening, Event::Partial("unfinished words".into())],
+                    cx,
+                );
+                fake
+            });
+            (composer.input.clone(), fake)
+        })
+        .unwrap();
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    let mut visual = gpui::VisualTestContext::from_window(handle.into(), cx);
+    let button = visual.debug_bounds("composer-send").unwrap();
+    visual.simulate_click(button.center(), gpui::Modifiers::default());
+    visual.simulate_click(button.center(), gpui::Modifiers::default());
+    assert_eq!(fake.borrow().drops, 0);
+    assert_eq!(fake.borrow().finishes, 1);
+    handle
+        .read_with(cx, |composer, cx| {
+            assert!(
+                composer.failure.is_none(),
+                "neither click may attempt an early send"
+            );
+            assert_eq!(composer.input.read(cx).text(), "unfinished words");
+        })
+        .unwrap();
+    input.update(cx, |input, cx| {
+        assert_eq!(input.dictation.phase, Phase::Finalizing);
+        deliver(input, &fake, [Event::Final("send this once".into())], cx);
+    });
+    let mut sends = 0;
+    while let Ok(event) = events.try_recv() {
+        if matches!(event, DictationInputEvent::Submit(_)) {
+            sends += 1;
+        }
+    }
+    assert_eq!(sends, 1);
+}
+
+#[gpui::test]
+fn dictation_silence_explains_empty_result_and_never_sends_existing_draft(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        input.set_text("keep my draft", cx);
+        let fake = start(input, cx);
+        deliver(input, &fake, [Event::Listening], cx);
+        input.finish_dictation(true, cx);
+        deliver(input, &fake, [Event::Final(String::new())], cx);
+        assert_eq!(input.text(), "keep my draft");
+        assert_eq!(input.dictation.phase, Phase::NoSpeech);
+    });
+    while let Ok(event) = events.try_recv() {
+        assert!(!matches!(event, DictationInputEvent::Submit(_)));
+    }
+}
+
+fn enable_dictation(dir: &std::path::Path, cx: &mut TestAppContext) {
+    let model = dir.join("models/parakeet-tdt-0.6b-v3-int8");
+    std::fs::create_dir_all(&model).unwrap();
+    for file in zeron_voice::manifest().files {
+        std::fs::File::create(model.join(file.name))
+            .unwrap()
+            .set_len(file.size)
+            .unwrap();
+    }
+    std::fs::write(model.join("verified"), zeron_voice::manifest().revision).unwrap();
+    cx.update(|cx| {
+        crate::dictation::init(dir.into(), cx);
+        crate::settings::update(crate::settings::SavePolicy::Immediate, cx, |s| {
+            s.dictation_enabled = true
+        });
+    });
+}
+
+#[gpui::test]
+fn dictation_focus_within_composer_keeps_capture_but_leaving_cancels(cx: &mut TestAppContext) {
+    let (dir, handle) = super::tests::composer_focus_window(cx);
+    enable_dictation(dir.path(), cx);
+    handle
+        .update(cx, |_, window, _| window.activate_window())
+        .unwrap();
+    cx.run_until_parked();
+    let fake = handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                fake
+            })
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    handle
+        .update(cx, |composer, window, cx| {
+            // The composer surface is the ancestor of the editor and its controls.
+            window.focus(&composer.dictation_focus, cx);
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(
+        fake.borrow().drops,
+        0,
+        "focus within the composer must retain capture"
+    );
+    let elsewhere = cx.update(|cx| cx.focus_handle());
+    handle
+        .update(cx, |composer, window, cx| {
+            window.focus(&elsewhere, cx);
+            assert!(composer.input.read(cx).dictation.phase.active());
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(fake.borrow().drops, 1);
+    handle
+        .read_with(cx, |composer, cx| {
+            assert_eq!(composer.input.read(cx).dictation.phase, Phase::Idle)
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_cancel_control_preserves_draft_and_clears_pending_send(cx: &mut TestAppContext) {
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    let (input, fake) = handle
+        .update(cx, |composer, _, cx| {
+            let fake = composer.input.update(cx, |input, cx| {
+                input.set_text("Keep this draft", cx);
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                input.finish_dictation(true, cx);
+                fake
+            });
+            (composer.input.clone(), fake)
+        })
+        .unwrap();
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    let mut visual = gpui::VisualTestContext::from_window(handle.into(), cx);
+    let cancel = visual.debug_bounds("dictation-dismiss").unwrap();
+    visual.simulate_click(cancel.center(), gpui::Modifiers::default());
+    assert_eq!(fake.borrow().drops, 1);
+    input.read_with(cx, |input, _| {
+        assert_eq!(input.text(), "Keep this draft");
+        assert_eq!(input.dictation.phase, Phase::Idle);
+    });
+    while let Ok(event) = events.try_recv() {
+        assert!(!matches!(event, DictationInputEvent::Submit(_)));
+    }
+}
+
+#[gpui::test]
+fn dictation_cancel_control_is_keyboard_operable(cx: &mut TestAppContext) {
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    let fake = handle
+        .update(cx, |composer, window, cx| {
+            let fake = composer.input.update(cx, |input, cx| {
+                input.set_text("Keep this draft", cx);
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                fake
+            });
+            window.focus(&composer.input.focus_handle(cx), cx);
+            fake
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| {
+        window.draw(cx).clear();
+        window.focus_next(cx);
+        window.draw(cx).clear();
+    })
+    .unwrap();
+    cx.run_until_parked();
+    assert_eq!(
+        fake.borrow().drops,
+        0,
+        "tabbing to Cancel must retain capture"
+    );
+    cx.simulate_keystrokes(handle.into(), "space");
+    cx.run_until_parked();
+    assert_eq!(fake.borrow().drops, 1);
+    assert_eq!(fake.borrow().finishes, 0, "Cancel must not transcribe");
+    handle
+        .read_with(cx, |composer, cx| {
+            assert_eq!(composer.input.read(cx).text(), "Keep this draft");
+            assert_eq!(composer.input.read(cx).dictation.phase, Phase::Idle);
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_keeps_draft_stable_when_pasted_references_resolve(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        input.set_text("@README.md ", cx);
+        let original = input.text().to_owned();
+        let revision = input.edit_revision;
+        let fake = start(input, cx);
+        deliver(input, &fake, [Event::Listening], cx);
+        input.finish_dictation(true, cx);
+        input.apply_pasted_references(
+            &original,
+            original.len(),
+            revision,
+            vec![(0..10, local_file_link("README.md", false))],
+            cx,
+        );
+        assert_eq!(input.text(), original);
+        deliver(input, &fake, [Event::Final("explain this".into())], cx);
+        assert_eq!(input.text(), "@README.md explain this");
+    });
+    let mut sends = 0;
+    while let Ok(event) = events.try_recv() {
+        if matches!(event, DictationInputEvent::Submit(_)) {
+            sends += 1;
+        }
+    }
+    assert_eq!(sends, 1);
+}
+
+#[gpui::test]
+fn dictation_escape_from_composer_controls_cancels_pending_send(cx: &mut TestAppContext) {
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    let fake = handle
+        .update(cx, |composer, window, cx| {
+            let fake = composer.input.update(cx, |input, cx| {
+                input.set_text("Keep this draft", cx);
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                input.finish_dictation(true, cx);
+                fake
+            });
+            window.focus(&composer.dictation_focus, cx);
+            fake
+        })
+        .unwrap();
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    cx.simulate_keystrokes(handle.into(), "escape");
+    cx.run_until_parked();
+    assert_eq!(fake.borrow().drops, 1);
+    handle
+        .read_with(cx, |composer, cx| {
+            assert_eq!(composer.input.read(cx).dictation.phase, Phase::Idle);
+            assert_eq!(composer.input.read(cx).text(), "Keep this draft");
+            assert!(composer.failure.is_none());
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_empty_undo_and_redo_notify_cancellation(cx: &mut TestAppContext) {
+    cx.update(|cx| cx.set_global(Theme::dark()));
+    let window = cx.add_window(|_, cx| ComposerInput::new("Draft", cx));
+    let input = window.update(cx, |_, _, cx| cx.entity()).unwrap();
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    for redo in [false, true] {
+        let fake = input.update(cx, |input, cx| {
+            let fake = start(input, cx);
+            deliver(input, &fake, [Event::Listening], cx);
+            fake
+        });
+        while events.try_recv().is_ok() {}
+        window
+            .update(cx, |input, window, cx| {
+                if redo {
+                    input.redo(&Redo, window, cx);
+                } else {
+                    input.undo(&Undo, window, cx);
+                }
+                assert_eq!(input.dictation.phase, Phase::Idle);
+            })
+            .unwrap();
+        assert_eq!(fake.borrow().drops, 1);
+        assert!(matches!(
+            events.try_recv(),
+            Ok(DictationInputEvent::Changed)
+        ));
+    }
+}
+
+#[gpui::test]
+fn dictation_blank_results_preserve_partial_and_pending_send(cx: &mut TestAppContext) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        let fake = start(input, cx);
+        deliver(
+            input,
+            &fake,
+            [Event::Partial("Keep these words".into())],
+            cx,
+        );
+        deliver(input, &fake, [Event::Partial("   ".into())], cx);
+        assert_eq!(input.text(), "Keep these words");
+        input.finish_dictation(true, cx);
+        deliver(input, &fake, [Event::Final(" \n\t ".into())], cx);
+        assert_eq!(input.text(), "Keep these words");
+        assert_eq!(input.dictation.phase, Phase::Idle);
+    });
+    let mut sends = 0;
+    while let Ok(event) = events.try_recv() {
+        if matches!(event, DictationInputEvent::Submit(_)) {
+            sends += 1;
+        }
+    }
+    assert_eq!(sends, 1);
+}
+
+#[test]
+fn voice_morph_reverses_mid_flight_without_jumping() {
+    let start = std::time::Instant::now();
+    let mut tween = super::VoiceTween::default();
+    tween.retarget(1.0, start, false);
+    let mid = start + super::VOICE_MORPH / 3;
+    let at_reverse = tween.value(mid);
+    assert!(at_reverse > 0.0 && at_reverse < 1.0, "{at_reverse}");
+    tween.retarget(0.0, mid, false);
+    assert!((tween.value(mid) - at_reverse).abs() < 1e-6);
+    assert_eq!(tween.value(mid + super::VOICE_MORPH), 0.0);
+    // Reduced motion snaps to the target.
+    tween.retarget(1.0, mid, true);
+    assert_eq!(tween.value(mid), 1.0);
+}
+
+#[gpui::test]
+fn dictation_stop_while_loading_keeps_selection_until_final_and_sends_once(
+    cx: &mut TestAppContext,
+) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        input.set_text("keep selected suffix", cx);
+        input.selected_range = 5..13;
+        let fake = start(input, cx);
+        assert_eq!(input.dictation.phase, Phase::Requesting);
+        deliver(input, &fake, [Event::Listening], cx);
+        input.finish_dictation(false, cx);
+        input.finish_dictation(true, cx);
+        // A queued readiness event cannot put a stopped session back in Listening.
+        deliver(input, &fake, [Event::Listening, Event::Finalizing], cx);
+        assert_eq!(input.dictation.phase, Phase::Finalizing);
+        assert_eq!(input.content, "keep selected suffix");
+        assert_eq!(input.selected_range, 5..13);
+        assert_eq!(fake.borrow().finishes, 1);
+        deliver(
+            input,
+            &fake,
+            [Event::Final("speech".into()), Event::Final("late".into())],
+            cx,
+        );
+        assert_eq!(input.content, "keep speech suffix");
+        assert_eq!(input.dictation.phase, Phase::Idle);
+        assert_eq!(fake.borrow().drops, 1);
+    });
+    let mut sends = 0;
+    while let Ok(event) = events.try_recv() {
+        sends += usize::from(matches!(event, DictationInputEvent::Submit(_)));
+    }
+    assert_eq!(sends, 1);
+}
+
+#[gpui::test]
+fn dictation_load_failure_or_timeout_preserves_selected_draft_and_rejects_late_final(
+    cx: &mut TestAppContext,
+) {
+    let input = cx.new(|cx| ComposerInput::new("Draft", cx));
+    let mut events = cx.events::<DictationInputEvent, _>(&input);
+    input.update(cx, |input, cx| {
+        for timeout in [false, true] {
+            input.set_text("keep my draft", cx);
+            input.selected_range = 0..13;
+            let fake = start(input, cx);
+            let generation = input.dictation.generation;
+            deliver(input, &fake, [Event::Listening], cx);
+            if timeout {
+                input
+                    .dictation
+                    .finish(true, Instant::now() - crate::dictation::FINALIZE_TIMEOUT);
+                fake.borrow_mut().events.push_back(Event::Finalizing);
+                input.poll_dictation(generation, cx);
+            } else {
+                input.finish_dictation(true, cx);
+                deliver(
+                    input,
+                    &fake,
+                    [Event::Failed("Could not load the model".into())],
+                    cx,
+                );
+            }
+            assert!(matches!(input.dictation.phase, Phase::Failed(_)));
+            fake.borrow_mut()
+                .events
+                .push_back(Event::Final("late speech".into()));
+            assert!(!input.poll_dictation(generation, cx));
+            assert_eq!(input.content, "keep my draft");
+            assert_eq!(input.selected_range, 0..13);
+            assert!(input.undo_stack.is_empty());
+            assert_eq!(fake.borrow().drops, 1);
+        }
+    });
+    while let Ok(event) = events.try_recv() {
+        assert!(!matches!(event, DictationInputEvent::Submit(_)));
+    }
+}
+
+#[gpui::test]
+fn dictation_microphone_key_hold_keeps_focus_and_queue_lease_blocks_start(cx: &mut TestAppContext) {
+    let (dir, handle) = super::tests::composer_focus_window(cx);
+    enable_dictation(dir.path(), cx);
+    handle
+        .update(cx, |composer, _, cx| {
+            // Enter/Space on the focused microphone must leave focus there,
+            // or its key-up never reaches the hold.
+            composer.focus_pending = false;
+            composer.press_dictation(HoldSource::Button, cx);
+            assert!(composer.input.read(cx).dictation.phase.active());
+            assert!(!composer.focus_pending);
+            composer
+                .input
+                .update(cx, |input, _| input.cancel_dictation());
+            composer.dictation_hold = None;
+            // An edit lease still in flight is about to replace the draft.
+            composer.queue_edit_pending_id = Some("row".into());
+            composer.press_dictation(HoldSource::Pointer, cx);
+            assert!(!composer.input.read(cx).dictation.phase.active());
+            assert!(composer.dictation_hold.is_none());
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn dictation_another_source_takes_over_a_hold_whose_release_was_lost(cx: &mut TestAppContext) {
+    let (dir, handle) = super::tests::composer_focus_window(cx);
+    enable_dictation(dir.path(), cx);
+    let fake = handle
+        .update(cx, |composer, _, cx| {
+            let fake = composer.input.update(cx, |input, cx| {
+                let fake = start(input, cx);
+                deliver(input, &fake, [Event::Listening], cx);
+                fake
+            });
+            composer.dictation_hold = Some(DictationHold {
+                source: HoldSource::Button,
+                started: None,
+            });
+            composer.press_dictation(HoldSource::Pointer, cx);
+            composer.release_dictation(HoldSource::Pointer, cx);
+            fake
+        })
+        .unwrap();
+    assert_eq!(fake.borrow().finishes, 1);
+}
+
+#[gpui::test]
+fn dictation_shortcut_falls_through_while_dictation_is_off(cx: &mut TestAppContext) {
+    gpui::actions!(dictation_test, [Probe]);
+    let (_dir, handle) = super::tests::composer_focus_window(cx);
+    let fired = Rc::new(std::cell::Cell::new(false));
+    let probe = fired.clone();
+    cx.update(|cx| {
+        crate::shell::apply_keymap(
+            cx,
+            &crate::settings::KeymapConfig::default(),
+            ComposerSendBehavior::Enter,
+        );
+        // Another binding of the same chord, as a user may already have.
+        cx.bind_keys([KeyBinding::new("secondary-d", Probe, None)]);
+        cx.on_action(move |_: &Probe, _| probe.set(true));
+    });
+    cx.simulate_keystrokes(handle.into(), "secondary-d");
+    assert!(
+        fired.get(),
+        "dictation is off by default and must not eat ⌘D"
+    );
+    handle
+        .read_with(cx, |composer, cx| {
+            assert!(composer.dictation_hold.is_none());
+            assert!(composer.input.read(cx).dictation_key.is_none());
+        })
+        .unwrap();
+}
diff --git a/crates/ui/src/dictation.rs b/crates/ui/src/dictation.rs
new file mode 100644
index 0000000000..b9b7d40d34
--- /dev/null
+++ b/crates/ui/src/dictation.rs
@@ -0,0 +1,323 @@
+//! Viewport-local dictation. Only transcript strings cross this boundary; audio
+//! never enters the engine, a document, an attachment, or the RPC transport.
+use std::ops::Range;
+use std::time::{Duration, Instant};
+
+pub(crate) mod glass;
+mod meter;
+mod model;
+pub(crate) mod waveform;
+pub(crate) use meter::{Bar, FLOOR, Meter};
+pub(crate) use model::{card, enabled, init};
+
+pub(crate) const FINALIZE_TIMEOUT: Duration = Duration::from_secs(30);
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
+#[serde(tag = "kind", content = "text", rename_all = "snake_case")]
+pub(crate) enum Event {
+    Listening,
+    Finalizing,
+    Partial(String),
+    Final(String),
+    Denied(String),
+    Unavailable(String),
+    Failed(String),
+    Cancelled,
+}
+
+/// Implementations and their callbacks are owned by the UI thread. Tests inject
+/// a fake; permission prompts and microphone access are never needed in CI.
+pub(crate) trait Transcriber {
+    fn poll(&mut self) -> Option<Event>;
+    fn finish(&mut self);
+    /// Peak input RMS since the previous call, for the live waveform.
+    fn level(&mut self) -> f32 {
+        0.0
+    }
+}
+
+#[cfg(target_os = "macos")]
+unsafe extern "C" {
+    fn zeron_microphone_permission() -> i32;
+    fn zeron_request_microphone();
+    fn zeron_microphone_window() -> usize;
+}
+fn permission() -> i32 {
+    #[cfg(target_os = "macos")]
+    {
+        unsafe { zeron_microphone_permission() }
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        1
+    }
+}
+pub(crate) fn permission_pending() -> bool {
+    permission() == 0
+}
+fn origin_window() -> usize {
+    #[cfg(target_os = "macos")]
+    {
+        unsafe { zeron_microphone_window() }
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        1
+    }
+}
+struct Native {
+    pending: Option<Event>,
+    origin_window: usize,
+    dir: std::path::PathBuf,
+    device: Option<String>,
+    session: Option<zeron_voice::Session>,
+    finished: bool,
+}
+impl Transcriber for Native {
+    fn poll(&mut self) -> Option<Event> {
+        if let Some(event) = self.pending.take() {
+            return Some(event);
+        }
+        if self.finished {
+            return None;
+        }
+        if self.session.is_none() {
+            match permission() {
+                0 => return None,
+                -2 => {
+                    self.finished = true;
+                    return Some(Event::Unavailable(
+                        "Dictation requires the packaged Zeron app.".into(),
+                    ));
+                }
+                -1 => {
+                    self.finished = true;
+                    return Some(Event::Denied("Allow Microphone access for Zeron in System Settings → Privacy & Security, then retry.".into()));
+                }
+                _ if self.origin_window == 0 || origin_window() != self.origin_window => {
+                    self.finished = true;
+                    return Some(Event::Cancelled);
+                }
+                _ => match zeron_voice::Session::start(self.dir.clone(), self.device.clone()) {
+                    Ok(s) => self.session = Some(s),
+                    Err(e) => {
+                        self.finished = true;
+                        return Some(Event::Failed(e.to_string()));
+                    }
+                },
+            }
+        }
+        self.session.as_mut()?.poll().map(|event| match event {
+            zeron_voice::Event::Listening => Event::Listening,
+            zeron_voice::Event::Finalizing => Event::Finalizing,
+            zeron_voice::Event::Final(t) => Event::Final(t),
+            zeron_voice::Event::Failed(e) => Event::Failed(e),
+        })
+    }
+    fn level(&mut self) -> f32 {
+        self.session.as_ref().map_or(0.0, |s| s.take_level())
+    }
+    fn finish(&mut self) {
+        if let Some(s) = &mut self.session {
+            s.finish();
+        } else {
+            self.finished = true;
+            self.pending = Some(Event::Final(String::new()));
+        }
+    }
+}
+pub(crate) fn start(cx: &gpui::App) -> Option<Box<dyn Transcriber>> {
+    if !enabled(cx) {
+        return None;
+    }
+    let origin_window = origin_window();
+    #[cfg(target_os = "macos")]
+    if permission() == 0 {
+        unsafe {
+            zeron_request_microphone();
+        }
+    }
+    Some(Box::new(Native {
+        pending: None,
+        origin_window,
+        dir: model::directory(cx),
+        device: crate::settings::current(cx).dictation_input.clone(),
+        session: None,
+        finished: false,
+    }))
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub(crate) enum Phase {
+    #[default]
+    Idle,
+    Requesting,
+    Listening,
+    Finalizing,
+    NoSpeech,
+    /// Released almost immediately: dictation is hold to talk.
+    Tapped,
+    Denied(String),
+    Unavailable(String),
+    Failed(String),
+}
+
+impl Phase {
+    pub fn active(&self) -> bool {
+        matches!(self, Self::Requesting | Self::Listening | Self::Finalizing)
+    }
+
+    /// Button names describe the action, independently of the live status.
+    pub fn action_label(&self) -> &'static str {
+        match self {
+            Self::Idle | Self::Tapped => "Hold to dictate",
+            Self::Requesting | Self::Listening => "Release to transcribe",
+            Self::Finalizing => "Transcribing",
+            Self::NoSpeech | Self::Denied(_) | Self::Unavailable(_) | Self::Failed(_) => {
+                "Hold to retry dictation"
+            }
+        }
+    }
+
+    pub fn status(&self) -> Option<(&str, &str)> {
+        Some(match self {
+            Self::Idle => return None,
+            Self::Requesting => ("Getting ready…", "Wait for Listening before speaking."),
+            Self::Listening => ("Listening", "Release when you’re done · Up to 1 minute"),
+            Self::Finalizing => ("Transcribing…", "Processing on this device."),
+            Self::NoSpeech => (
+                "No speech detected",
+                "Check your microphone, then try again.",
+            ),
+            Self::Tapped => (
+                "Hold to dictate",
+                "Keep holding the microphone or the shortcut while you speak.",
+            ),
+            Self::Denied(message) | Self::Unavailable(message) => {
+                ("Dictation unavailable", message)
+            }
+            Self::Failed(message) => ("Dictation stopped", message),
+        })
+    }
+}
+
+#[derive(Default)]
+pub(crate) struct Dictation {
+    pub phase: Phase,
+    pub generation: u64,
+    range: Range<usize>,
+    expected: String,
+    pub has_partial: bool,
+    pending_send: bool,
+    finish_started: Option<Instant>,
+    pub meter: Meter,
+}
+
+impl Dictation {
+    pub fn begin(&mut self, content: &str, selection: Range<usize>) {
+        self.cancel();
+        self.phase = Phase::Requesting;
+        self.range = selection;
+        self.expected = content.to_owned();
+        self.has_partial = false;
+    }
+
+    /// Invalidates late callbacks AND pending sends, preserving committed text.
+    pub fn cancel(&mut self) {
+        self.generation = self.generation.wrapping_add(1);
+        self.phase = Phase::Idle;
+        self.pending_send = false;
+        self.finish_started = None;
+        self.expected.clear();
+        self.meter.reset();
+    }
+
+    /// Returns true only on the transition that must finish the audio stream.
+    pub fn finish(&mut self, send: bool, now: Instant) -> bool {
+        if !self.phase.active() {
+            return false;
+        }
+        self.pending_send |= send;
+        if self.phase == Phase::Finalizing {
+            return false;
+        }
+        self.phase = Phase::Finalizing;
+        self.finish_started = Some(now);
+        self.meter.freeze(now);
+        true
+    }
+
+    pub fn timed_out(&self, now: Instant) -> bool {
+        self.finish_started
+            .is_some_and(|at| now.duration_since(at) >= FINALIZE_TIMEOUT)
+    }
+
+    /// Empty recognition does not erase selected text or the latest partial.
+    /// A changed draft cannot be overwritten, even if a caller missed cancellation.
+    pub fn replace(&mut self, content: &mut String, transcript: &str) -> Option<usize> {
+        if !self.phase.active() || *content != self.expected {
+            self.cancel();
+            return None;
+        }
+        if transcript.trim().is_empty() {
+            return None;
+        }
+        content.replace_range(self.range.clone(), transcript);
+        self.range.end = self.range.start + transcript.len();
+        self.expected.clone_from(content);
+        self.has_partial = true;
+        Some(self.range.end)
+    }
+
+    pub fn complete(&mut self, phase: Phase) -> bool {
+        let send = self.pending_send && phase == Phase::Idle;
+        self.cancel();
+        self.phase = phase;
+        send
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn finishing_before_permission_does_not_wait_or_start_capture() {
+        let mut native = Native {
+            pending: None,
+            origin_window: 0,
+            dir: std::path::PathBuf::new(),
+            device: None,
+            session: None,
+            finished: false,
+        };
+        native.finish();
+        assert_eq!(native.poll(), Some(Event::Final(String::new())));
+        assert_eq!(native.poll(), None);
+        assert!(native.session.is_none());
+    }
+
+    #[test]
+    fn finalization_deadline_does_not_restart_when_send_follows_stop() {
+        let mut state = Dictation::default();
+        state.begin("draft", 5..5);
+        let start = Instant::now();
+        assert!(state.finish(false, start));
+        assert!(!state.finish(true, start + Duration::from_secs(1)));
+        assert!(!state.timed_out(start + FINALIZE_TIMEOUT - Duration::from_millis(1)));
+        assert!(state.timed_out(start + FINALIZE_TIMEOUT));
+        assert!(state.complete(Phase::Idle));
+        assert!(!state.complete(Phase::Idle));
+    }
+
+    #[test]
+    fn unexpected_draft_change_rejects_late_partial_and_send() {
+        let mut state = Dictation::default();
+        state.begin("old", 0..3);
+        state.finish(true, Instant::now());
+        let mut current = "new draft".to_owned();
+        assert_eq!(state.replace(&mut current, "late"), None);
+        assert_eq!(current, "new draft");
+        assert!(!state.complete(Phase::Idle));
+    }
+}
diff --git a/crates/ui/src/dictation/glass.rs b/crates/ui/src/dictation/glass.rs
new file mode 100644
index 0000000000..e39eae3cc0
--- /dev/null
+++ b/crates/ui/src/dictation/glass.rs
@@ -0,0 +1,89 @@
+//! Glass surfaces for the voice controls: a light plate for the waveform track
+//! and an accent plate for Stop. Each is a vertical gradient (lit from above),
+//! a hairline rim, an inner top highlight, and a soft drop. Dark appearances
+//! keep the structure with translucent white instead of opaque fills.
+use gpui::{
+    Background, BoxShadow, Hsla, Styled, hsla, linear_color_stop, linear_gradient, point, px,
+};
+
+use crate::theme::Theme;
+
+fn shadow(color: Hsla, y: f32, blur: f32, spread: f32, inset: bool) -> BoxShadow {
+    BoxShadow {
+        color,
+        offset: point(px(0.0), px(y)),
+        blur_radius: px(blur),
+        spread_radius: px(spread),
+        inset,
+    }
+}
+
+fn white(alpha: f32) -> Hsla {
+    hsla(0.0, 0.0, 1.0, alpha)
+}
+
+fn black(alpha: f32) -> Hsla {
+    hsla(0.0, 0.0, 0.0, alpha)
+}
+
+fn vertical(top: Hsla, bottom: Hsla) -> Background {
+    linear_gradient(
+        180.0,
+        linear_color_stop(top, 0.0),
+        linear_color_stop(bottom, 1.0),
+    )
+}
+
+/// A lighter tint of `color` for the lit top of a gradient.
+fn lift(color: Hsla, amount: f32) -> Hsla {
+    crate::motion::mix(color, white(color.a), amount)
+}
+
+/// Neutral glass plate. `t` fades the whole treatment in with the morph.
+pub(crate) fn light<E: Styled>(el: E, theme: &Theme, t: f32) -> E {
+    let dark = theme.appearance.is_dark();
+    let (top, bottom, rim, highlight, drop) = if dark {
+        (
+            white(0.09),
+            white(0.04),
+            white(0.10),
+            white(0.10),
+            black(0.35),
+        )
+    } else {
+        (
+            hsla(0.0, 0.0, 0.985, 1.0),
+            hsla(0.0, 0.0, 0.925, 1.0),
+            black(0.10),
+            white(0.95),
+            black(0.08),
+        )
+    };
+    el.bg(vertical(top.opacity(t), bottom.opacity(t)))
+        .border_1()
+        .border_color(rim.opacity(t))
+        .shadow(vec![
+            shadow(highlight.opacity(t), 1.0, 0.0, 0.0, true),
+            shadow(drop.opacity(t), 1.0, 3.0, 0.0, false),
+        ])
+}
+
+/// Accent glass plate. `t` fades it in over the resting control; `glow`
+/// (0–1, the live voice level) spreads its coloured shadow.
+pub(crate) fn accent<E: Styled>(el: E, theme: &Theme, t: f32, glow: f32) -> E {
+    let dark = theme.appearance.is_dark();
+    let base = theme.accent;
+    let top = lift(base, if dark { 0.18 } else { 0.32 });
+    let bottom = base;
+    let rim = lift(base, 0.45).opacity(if dark { 0.45 } else { 0.7 });
+    let highlight = white(if dark { 0.22 } else { 0.38 });
+    let halo = base.opacity((0.22 + 0.4 * glow) * t);
+    el.bg(vertical(top.opacity(t), bottom.opacity(t)))
+        .border_1()
+        .border_color(rim.opacity(t))
+        .shadow(vec![
+            shadow(highlight.opacity(t), 1.0, 0.0, 0.0, true),
+            shadow(white(0.12 * t), 0.0, 0.0, 1.0, true),
+            shadow(halo, 2.0 + 2.0 * glow, 6.0 + 14.0 * glow, 0.0, false),
+        ])
+}
diff --git a/crates/ui/src/dictation/meter.rs b/crates/ui/src/dictation/meter.rs
new file mode 100644
index 0000000000..7ddf7152f5
--- /dev/null
+++ b/crates/ui/src/dictation/meter.rs
@@ -0,0 +1,247 @@
+//! Live input level for the dictation waveform. Only a loudness envelope is
+//! kept here: one normalized amplitude per fixed time slot, never audio.
+//!
+//! Slots sit on a fixed clock from the moment capture starts, so bars stay
+//! evenly spaced however irregularly the UI polls. Drawing trails the clock by
+//! [`LAG`], longer than one poll, which means a slot is always filled before
+//! it scrolls into view and the waveform can glide continuously.
+use std::collections::VecDeque;
+use std::time::{Duration, Instant};
+
+/// One bar per slot.
+pub(crate) const STEP: Duration = Duration::from_millis(60);
+const LAG: Duration = Duration::from_millis(70);
+/// Enough slots for the widest composer; older bars have scrolled away.
+const CAPACITY: usize = 320;
+/// A bar never drops below its neighbour faster than this, so syllables leave
+/// a short tail instead of flickering between loud and silent.
+const RELEASE: f32 = 0.62;
+/// The quietest bar still reads as a dot on the baseline.
+pub(crate) const FLOOR: f32 = 0.08;
+
+#[derive(Debug, Default, Clone)]
+pub(crate) struct Meter {
+    started: Option<Instant>,
+    frozen: Option<Instant>,
+    slots: VecDeque<f32>,
+    filled: u64,
+    pending: f32,
+}
+
+/// One visible bar: `age` in slots behind the trailing edge (0 = newest) and
+/// its normalized height.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) struct Bar {
+    pub age: f32,
+    pub amplitude: f32,
+}
+
+/// Maps microphone RMS onto a perceptual 0–1 scale: −50 dBFS is silence and
+/// −12 dBFS, a close, raised voice, fills the bar.
+pub(crate) fn normalize(rms: f32) -> f32 {
+    if !rms.is_finite() || rms <= 1e-6 {
+        return 0.0;
+    }
+    ((20.0 * rms.log10() + 50.0) / 38.0).clamp(0.0, 1.0)
+}
+
+impl Meter {
+    pub fn start(&mut self, now: Instant) {
+        *self = Self {
+            started: Some(now),
+            ..Self::default()
+        };
+    }
+
+    /// Time since capture began; `None` until the microphone is live.
+    pub fn since_start(&self, now: Instant) -> Option<Duration> {
+        self.started.map(|at| now.saturating_duration_since(at))
+    }
+
+    pub fn reset(&mut self) {
+        *self = Self::default();
+    }
+
+    /// Stops the clock where capture ended; bars and timer hold still.
+    pub fn freeze(&mut self, now: Instant) {
+        if self.started.is_some() && self.frozen.is_none() {
+            self.frozen = Some(now);
+        }
+    }
+
+    /// Folds in the loudest RMS since the previous call. Returns true when a
+    /// new slot was filled.
+    pub fn record(&mut self, now: Instant, rms: f32) -> bool {
+        let Some(started) = self.started.filter(|_| self.frozen.is_none()) else {
+            return false;
+        };
+        self.pending = self.pending.max(normalize(rms));
+        let due = now.saturating_duration_since(started).as_nanos() / STEP.as_nanos() + 1;
+        let due = due as u64;
+        if self.filled >= due {
+            return false;
+        }
+        while self.filled < due {
+            let previous = self.slots.back().copied().unwrap_or(0.0);
+            self.slots.push_back(self.pending.max(previous * RELEASE));
+            if self.slots.len() > CAPACITY {
+                self.slots.pop_front();
+            }
+            self.filled += 1;
+        }
+        self.pending = 0.0;
+        true
+    }
+
+    pub fn elapsed(&self, now: Instant) -> Duration {
+        self.started.map_or(Duration::ZERO, |started| {
+            self.frozen
+                .unwrap_or(now)
+                .saturating_duration_since(started)
+        })
+    }
+
+    /// Bars visible at `now`, newest first. `continuous` false snaps the
+    /// scroll to whole slots for reduced motion.
+    pub fn bars(&self, now: Instant, continuous: bool) -> Vec<Bar> {
+        let Some(started) = self.started else {
+            return Vec::new();
+        };
+        let clock = self
+            .frozen
+            .map_or(now, |frozen| frozen.min(now))
+            .saturating_duration_since(started);
+        let Some(clock) = clock.checked_sub(LAG) else {
+            return Vec::new();
+        };
+        let head = clock.as_secs_f32() / STEP.as_secs_f32();
+        let first = self.filled - self.slots.len() as u64;
+        self.slots
+            .iter()
+            .enumerate()
+            .rev()
+            .filter_map(|(i, amplitude)| {
+                let age = head - (first + i as u64) as f32;
+                (age >= 0.0).then(|| Bar {
+                    age: if continuous { age } else { age.floor() },
+                    amplitude: *amplitude,
+                })
+            })
+            .collect()
+    }
+
+    /// Current loudness for the glow, blended between the two newest visible
+    /// slots as the newest one scrolls in, so it changes without steps.
+    pub fn level(&self, now: Instant) -> f32 {
+        let bars = self.bars(now, true);
+        match bars.as_slice() {
+            [] => 0.0,
+            [only] => only.amplitude * only.age.clamp(0.0, 1.0),
+            [newest, previous, ..] => {
+                let t = newest.age.clamp(0.0, 1.0);
+                previous.amplitude + (newest.amplitude - previous.amplitude) * t
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ms(n: u64) -> Duration {
+        Duration::from_millis(n)
+    }
+
+    #[test]
+    fn normalizes_speech_range_and_rejects_invalid_levels() {
+        assert_eq!(normalize(0.0), 0.0);
+        assert_eq!(normalize(f32::NAN), 0.0);
+        assert_eq!(normalize(10f32.powf(-50.0 / 20.0)), 0.0);
+        assert_eq!(normalize(1.0), 1.0);
+        let mid = normalize(0.02);
+        assert!(mid > 0.2 && mid < 0.8, "{mid}");
+    }
+
+    #[test]
+    fn slots_stay_on_the_clock_when_polls_are_irregular() {
+        let t0 = Instant::now();
+        let mut meter = Meter::default();
+        meter.start(t0);
+        assert!(meter.record(t0 + ms(5), 0.1));
+        assert!(!meter.record(t0 + ms(30), 0.0));
+        // A late poll fills every slot it skipped.
+        assert!(meter.record(t0 + STEP * 3 + ms(1), 0.0));
+        assert_eq!(meter.filled, 4);
+        let bars = meter.bars(t0 + STEP * 3 + LAG + ms(1), true);
+        assert_eq!(bars.len(), 4);
+        for pair in bars.windows(2) {
+            assert!((pair[1].age - pair[0].age - 1.0).abs() < 1e-3);
+        }
+        // Loud slot decays into its neighbours instead of dropping to zero.
+        let loud = normalize(0.1);
+        assert_eq!(bars[3].amplitude, loud);
+        assert!((bars[2].amplitude - loud * RELEASE).abs() < 1e-6);
+    }
+
+    #[test]
+    fn peak_between_slots_is_kept_for_the_next_slot() {
+        let t0 = Instant::now();
+        let mut meter = Meter::default();
+        meter.start(t0);
+        meter.record(t0, 0.0);
+        assert!(!meter.record(t0 + ms(20), 0.2));
+        assert!(meter.record(t0 + STEP, 0.0));
+        assert_eq!(meter.slots.back().copied(), Some(normalize(0.2)));
+    }
+
+    #[test]
+    fn freezing_stops_scroll_and_timer() {
+        let t0 = Instant::now();
+        let mut meter = Meter::default();
+        meter.start(t0);
+        meter.record(t0 + STEP * 5, 0.05);
+        meter.freeze(t0 + STEP * 5);
+        assert!(!meter.record(t0 + STEP * 9, 0.5));
+        let later = t0 + Duration::from_secs(10);
+        assert_eq!(meter.elapsed(later), STEP * 5);
+        assert_eq!(meter.bars(later, true), meter.bars(later + ms(500), true));
+    }
+
+    #[test]
+    fn level_glides_between_slots() {
+        let t0 = Instant::now();
+        let mut meter = Meter::default();
+        meter.start(t0);
+        meter.record(t0, 0.0);
+        meter.record(t0 + STEP, 0.1);
+        let at = |offset: Duration| meter.level(t0 + STEP + LAG + ms(1) + offset);
+        let loud = normalize(0.1);
+        assert!(at(Duration::ZERO) < 0.03);
+        let half = at(STEP / 2);
+        assert!((half - loud / 2.0).abs() < 0.03, "{half}");
+        assert!((at(STEP) - loud).abs() < 1e-6);
+    }
+
+    #[test]
+    fn reduced_motion_snaps_to_whole_slots() {
+        let t0 = Instant::now();
+        let mut meter = Meter::default();
+        meter.start(t0);
+        meter.record(t0 + STEP * 2, 0.05);
+        let bars = meter.bars(t0 + STEP * 2 + LAG + ms(20), false);
+        assert!(bars.iter().all(|bar| bar.age.fract() == 0.0));
+    }
+
+    #[test]
+    fn capacity_bounds_history() {
+        let t0 = Instant::now();
+        let mut meter = Meter::default();
+        meter.start(t0);
+        meter.record(t0 + STEP * (CAPACITY as u32 * 2), 0.05);
+        assert_eq!(meter.slots.len(), CAPACITY);
+        let bars = meter.bars(t0 + STEP * (CAPACITY as u32 * 2) + LAG + ms(1), true);
+        assert_eq!(bars.len(), CAPACITY);
+        assert!(bars[0].age < 1.0);
+    }
+}
diff --git a/crates/ui/src/dictation/model.rs b/crates/ui/src/dictation/model.rs
new file mode 100644
index 0000000000..88a635116b
--- /dev/null
+++ b/crates/ui/src/dictation/model.rs
@@ -0,0 +1,560 @@
+use crate::{
+    popover,
+    settings::{self, widgets},
+    theme::Theme,
+};
+use gpui::{App, Context, Entity, Global, Task, Window, div, prelude::*, px};
+use std::{
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicU64, Ordering},
+    },
+    time::{Duration, Instant},
+};
+struct VoiceGlobal {
+    card: Entity<VoiceCard>,
+    directory: PathBuf,
+}
+impl Global for VoiceGlobal {}
+pub(crate) fn init(root: PathBuf, cx: &mut App) {
+    let directory = root.join("models/parakeet-tdt-0.6b-v3-int8");
+    let card = cx.new(|_| VoiceCard {
+        scroll: widgets::PageScroll::default(),
+        ready: zeron_voice::installed(&directory),
+        cache_present: directory.exists(),
+        directory: directory.clone(),
+        cancel: None,
+        task: None,
+        progress: 0,
+        error: None,
+        inputs: Inputs::default(),
+        input_select: widgets::SelectState::default(),
+        shortcut: None,
+    });
+    cx.set_global(VoiceGlobal { card, directory });
+}
+pub(crate) fn directory(cx: &App) -> PathBuf {
+    cx.global::<VoiceGlobal>().directory.clone()
+}
+pub(crate) fn enabled(cx: &App) -> bool {
+    settings::current(cx).dictation_enabled
+        && cx
+            .try_global::<VoiceGlobal>()
+            .is_some_and(|g| g.card.read(cx).ready)
+}
+pub(crate) fn card(cx: &mut App) -> Entity<VoiceCard> {
+    if !cx.has_global::<VoiceGlobal>() {
+        init(std::env::temp_dir().join("zeron-voice-test"), cx);
+    }
+    cx.global::<VoiceGlobal>().card.clone()
+}
+pub(crate) struct VoiceCard {
+    scroll: widgets::PageScroll,
+    directory: PathBuf,
+    ready: bool,
+    cache_present: bool,
+    cancel: Option<Arc<AtomicBool>>,
+    task: Option<Task<()>>,
+    progress: u64,
+    error: Option<String>,
+    inputs: Inputs,
+    input_select: widgets::SelectState,
+    /// Created on first render (it needs this card's context).
+    shortcut: Option<Entity<settings::shortcuts::ShortcutField>>,
+}
+/// Microphones as last enumerated, refreshed off the UI thread while the page
+/// is visible so newly connected devices appear.
+#[derive(Default)]
+struct Inputs {
+    devices: Vec<zeron_voice::InputDevice>,
+    default: Option<String>,
+    checked: Option<Instant>,
+    task: Option<Task<()>>,
+}
+const INPUT_REFRESH: Duration = Duration::from_secs(3);
+impl VoiceCard {
+    fn set_enabled(&mut self, enabled: bool, cx: &mut Context<Self>) {
+        settings::update(settings::SavePolicy::Immediate, cx, |s| {
+            s.dictation_enabled = enabled
+        });
+        cx.refresh_windows();
+        cx.notify();
+    }
+    fn primary(&mut self, cx: &mut Context<Self>) {
+        if let Some(cancel) = &self.cancel {
+            cancel.store(true, Ordering::Release);
+        } else if self.ready {
+            self.set_enabled(!settings::current(cx).dictation_enabled, cx);
+        } else {
+            self.download(cx);
+        }
+        cx.notify();
+    }
+    fn download(&mut self, cx: &mut Context<Self>) {
+        if self.cancel.is_some() {
+            return;
+        }
+        self.error = None;
+        self.progress = 0;
+        let cancel = Arc::new(AtomicBool::new(false));
+        self.cancel = Some(cancel.clone());
+        let progress = Arc::new(AtomicU64::new(0));
+        let counter = progress.clone();
+        let dir = self.directory.clone();
+        let (tx, rx) = std::sync::mpsc::sync_channel(1);
+        std::thread::spawn(move || {
+            let r = zeron_voice::download(&dir, &cancel, |n| counter.store(n, Ordering::Relaxed))
+                .map_err(|_| {
+                if cancel.load(Ordering::Acquire) { "Download cancelled.".to_owned() }
+                else { "Couldn’t download or verify the model. Check your connection and free storage, then retry.".to_owned() }
+            });
+            let _ = tx.send(r);
+        });
+        self.task = Some(cx.spawn(async move |this, cx| {
+            loop {
+                cx.background_executor()
+                    .timer(Duration::from_millis(100))
+                    .await;
+                let result = rx.try_recv();
+                let done = !matches!(result, Err(std::sync::mpsc::TryRecvError::Empty));
+                if this
+                    .update(cx, |this, cx| {
+                        this.progress = progress.load(Ordering::Relaxed);
+                        if done {
+                            this.cache_present = this.directory.exists();
+                        }
+                        match result {
+                            Ok(Ok(())) => {
+                                this.ready = true;
+                                let cancelled = this
+                                    .cancel
+                                    .as_ref()
+                                    .is_some_and(|c| c.load(Ordering::Acquire));
+                                this.cancel = None;
+                                this.set_enabled(!cancelled, cx);
+                            }
+                            Ok(Err(e)) => {
+                                this.cancel = None;
+                                this.error = Some(e);
+                            }
+                            Err(std::sync::mpsc::TryRecvError::Disconnected) => {
+                                this.cancel = None;
+                                this.error = Some("Download interrupted. Try again.".into());
+                            }
+                            _ => {}
+                        }
+                        cx.notify();
+                    })
+                    .is_err()
+                    || done
+                {
+                    break;
+                }
+            }
+        }));
+        cx.notify();
+    }
+    fn remove(&mut self, cx: &mut Context<Self>) {
+        if zeron_voice::busy() {
+            self.error = Some("Stop dictation before removing the model.".into());
+            cx.notify();
+            return;
+        }
+        self.set_enabled(false, cx);
+        zeron_voice::unload();
+        match std::fs::remove_dir_all(&self.directory) {
+            Ok(()) => {
+                self.cache_present = false;
+                self.ready = false;
+                self.progress = 0;
+                self.error = None
+            }
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                self.cache_present = false;
+                self.ready = false;
+                self.progress = 0;
+                self.error = None;
+            }
+            Err(_) => {
+                self.error =
+                    Some("Could not remove the model. Check folder permissions and retry.".into())
+            }
+        }
+        cx.notify();
+    }
+}
+impl popover::ScrollRailHost for VoiceCard {
+    fn rail_bar(&mut self) -> &mut popover::MenuScrollbarState {
+        self.scroll.rail_bar()
+    }
+    fn rail_scroll(&self) -> Option<gpui::ScrollHandle> {
+        self.scroll.rail_scroll()
+    }
+}
+impl VoiceCard {
+    fn refresh_inputs(&mut self, cx: &mut Context<Self>) {
+        if self.inputs.task.is_some()
+            || self
+                .inputs
+                .checked
+                .is_some_and(|at| at.elapsed() < INPUT_REFRESH)
+        {
+            return;
+        }
+        let scan = cx.background_executor().spawn(async {
+            (
+                zeron_voice::input_devices(),
+                zeron_voice::default_input_device(),
+            )
+        });
+        self.inputs.task = Some(cx.spawn(async move |this, cx| {
+            let (devices, default) = scan.await;
+            this.update(cx, |this, cx| {
+                let changed = this.inputs.devices != devices || this.inputs.default != default;
+                this.inputs.devices = devices;
+                this.inputs.default = default;
+                this.inputs.checked = Some(Instant::now());
+                if changed {
+                    cx.notify();
+                }
+            })
+            .ok();
+            // A static settings page otherwise has no reason to render again,
+            // so checking the age only in render misses hot-plugged devices.
+            // Invalidate once when the scan expires. Only a visible card starts
+            // the next scan, so leaving Settings does not keep polling devices.
+            cx.background_executor().timer(INPUT_REFRESH).await;
+            this.update(cx, |this, cx| {
+                this.inputs.task = None;
+                cx.notify();
+            })
+            .ok();
+        }));
+    }
+
+    /// Options for the microphone select and the index of the current one. A
+    /// saved device that is unplugged stays listed so the choice is visible;
+    /// recording falls back to the system default meanwhile.
+    fn input_options(&self, saved: Option<&str>) -> (Vec<widgets::SelectOption>, usize) {
+        let default_name = self.inputs.default.as_ref().and_then(|id| {
+            self.inputs
+                .devices
+                .iter()
+                .find(|d| &d.id == id)
+                .map(|d| d.name.clone())
+        });
+        let mut options = vec![match default_name {
+            Some(name) => widgets::SelectOption::new("System default").detail(name),
+            None => widgets::SelectOption::new("System default"),
+        }];
+        options.extend(
+            self.inputs
+                .devices
+                .iter()
+                .map(|d| widgets::SelectOption::new(d.name.clone())),
+        );
+        let selected = match saved {
+            None => 0,
+            Some(id) => match self.inputs.devices.iter().position(|d| d.id == id) {
+                Some(ix) => ix + 1,
+                None => {
+                    options.push(widgets::SelectOption::new("Disconnected microphone"));
+                    options.len() - 1
+                }
+            },
+        };
+        (options, selected)
+    }
+}
+impl Render for VoiceCard {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = Theme::of(cx).for_settings_surface();
+        let enabled = settings::current(cx).dictation_enabled;
+        let downloading = self.cancel.is_some();
+        let on = downloading || (enabled && self.ready);
+        let size_mb = zeron_voice::download_size() as f64 / 1e6;
+        let meta = if downloading {
+            Some(format!(
+                "Downloading · {:.0} of {size_mb:.0} MB",
+                self.progress as f64 / 1e6
+            ))
+        } else if !self.ready {
+            Some(format!("{size_mb:.0} MB download"))
+        } else {
+            None
+        };
+        let weak = cx.entity().downgrade();
+        let switch = widgets::toggle_switch(&theme, on, "voice-dictation")
+            .id("voice-enable")
+            .cursor_pointer()
+            .tab_index(0)
+            .role(gpui::Role::Switch)
+            .aria_label("Dictation")
+            .aria_toggled(if on {
+                gpui::Toggled::True
+            } else {
+                gpui::Toggled::False
+            })
+            .focus_visible(|s| s.border_2().border_color(theme.accent).opacity(1.0))
+            .on_click(cx.listener(|this, _, _, cx| this.primary(cx)))
+            .on_key_down(cx.listener(|this, event: &gpui::KeyDownEvent, _, cx| {
+                if matches!(event.keystroke.key.as_str(), "enter" | "space") {
+                    cx.stop_propagation();
+                    this.primary(cx);
+                }
+            }))
+            .on_a11y_action(gpui::AccessibleAction::Click, move |_, _, cx| {
+                weak.update(cx, |this, cx| this.primary(cx)).ok();
+            });
+        let progress = downloading.then(|| {
+            div()
+                .mt(px(8.0))
+                .w_full()
+                .h(px(3.0))
+                .rounded_full()
+                .bg(theme.border)
+                .child(
+                    div()
+                        .h_full()
+                        .rounded_full()
+                        .w(gpui::relative(
+                            (self.progress as f32 / zeron_voice::download_size() as f32)
+                                .clamp(0.0, 1.0),
+                        ))
+                        .bg(theme.accent),
+                )
+        });
+        let dictation_row = widgets::card_row(&theme, true)
+            .child(
+                div()
+                    .flex_1()
+                    .min_w(px(160.0))
+                    .flex()
+                    .flex_col()
+                    .child(widgets::row_title(&theme, "Dictation"))
+                    .children(meta.map(|meta| {
+                        div()
+                            .id("voice-status")
+                            .role(gpui::Role::Status)
+                            .aria_label(meta.clone())
+                            .child(widgets::meta_line(&theme, vec![meta.into_any_element()]))
+                    }))
+                    .children(progress),
+            )
+            .child(switch);
+        let microphone_row = (enabled && self.ready).then(|| {
+            self.refresh_inputs(cx);
+            let saved = settings::current(cx).dictation_input.clone();
+            let (options, selected) = self.input_options(saved.as_deref());
+            let ids: Vec<Option<String>> = std::iter::once(None)
+                .chain(self.inputs.devices.iter().map(|d| Some(d.id.clone())))
+                .chain(std::iter::once(saved))
+                .collect();
+            let control = widgets::select(
+                "voice-microphone",
+                "Microphone",
+                &theme,
+                |card: &mut Self| &mut card.input_select,
+            )
+            .options(options, selected)
+            .width(200.0)
+            .on_select(move |_, ix, _, cx| {
+                let input = ids.get(ix).cloned().flatten();
+                settings::update(settings::SavePolicy::Immediate, cx, |s| {
+                    s.dictation_input = input
+                });
+                cx.notify();
+            })
+            .render(&self.input_select, cx);
+            widgets::card_row(&theme, false)
+                .child(
+                    div()
+                        .flex_1()
+                        .min_w(px(160.0))
+                        .child(widgets::row_title(&theme, "Microphone")),
+                )
+                .child(control)
+        });
+        // Always visible, so ⌘D can be rebound (and freed) before the model
+        // is downloaded.
+        let shortcut_row = {
+            let field = self
+                .shortcut
+                .get_or_insert_with(|| {
+                    cx.new(|cx| {
+                        settings::shortcuts::ShortcutField::new(
+                            settings::ShortcutId::ToggleDictation,
+                            cx,
+                        )
+                    })
+                })
+                .clone();
+            widgets::card_row(&theme, false)
+                .child(
+                    div()
+                        .flex_1()
+                        .min_w(px(160.0))
+                        .flex()
+                        .flex_col()
+                        .child(widgets::row_title(&theme, "Shortcut"))
+                        .child(widgets::meta_line(
+                            &theme,
+                            vec!["Hold to talk, release to transcribe".into_any_element()],
+                        )),
+                )
+                .child(field)
+        };
+        let model_card = (self.cache_present && !downloading).then(|| {
+            let remove_weak = cx.entity().downgrade();
+            widgets::section_card(&theme).child(
+                widgets::card_row(&theme, true)
+                    .child(
+                        div()
+                            .flex_1()
+                            .min_w(px(160.0))
+                            .flex()
+                            .flex_col()
+                            .child(widgets::row_title(&theme, "Speech model"))
+                            .child(widgets::meta_line(
+                                &theme,
+                                vec![
+                                    "Parakeet v3".into_any_element(),
+                                    format!("{size_mb:.0} MB").into_any_element(),
+                                ],
+                            )),
+                    )
+                    .child(
+                        widgets::action_button(&theme, widgets::ActionTone::Quiet)
+                            .id("voice-remove")
+                            .role(gpui::Role::Button)
+                            .aria_label("Remove speech model")
+                            .tab_index(0)
+                            .child("Remove")
+                            .focus_visible(|s| s.border_2().border_color(theme.accent))
+                            .on_click(cx.listener(|this, _, _, cx| this.remove(cx)))
+                            .on_key_down(cx.listener(|this, event: &gpui::KeyDownEvent, _, cx| {
+                                if matches!(event.keystroke.key.as_str(), "enter" | "space") {
+                                    cx.stop_propagation();
+                                    this.remove(cx);
+                                }
+                            }))
+                            .on_a11y_action(gpui::AccessibleAction::Click, move |_, _, cx| {
+                                remove_weak.update(cx, |this, cx| this.remove(cx)).ok();
+                            }),
+                    ),
+            )
+        });
+        let error = self.error.as_ref().map(|e| {
+            div()
+                .id("voice-error")
+                .role(gpui::Role::Status)
+                .aria_label(e.clone())
+                .child(widgets::error_strip(&theme, e.clone()))
+        });
+        let scrollbar = popover::rail(self, "voice-page-scrollbar", &theme, cx);
+        div()
+            .id("voice-page-host")
+            .relative()
+            .size_full()
+            .on_hover(cx.listener(|this, hovered: &bool, _, cx| {
+                if this.scroll.set_list_hovered(*hovered) {
+                    cx.notify();
+                }
+            }))
+            .child(
+                crate::edge_fade::edge_faded(
+                    16.0,
+                    true,
+                    true,
+                    div()
+                        .id("voice-page")
+                        .size_full()
+                        .overflow_y_scroll()
+                        .track_scroll(&self.scroll.scroll)
+                        .child(
+                            widgets::page_column()
+                                .child(widgets::page_header(&theme, "Voice", None))
+                                .child(widgets::page_subtitle(
+                                    &theme,
+                                    "Transcribed on this device. Audio is never saved.",
+                                ))
+                                .child(
+                                    widgets::section_card(&theme)
+                                        .child(dictation_row)
+                                        .children(microphone_row)
+                                        .child(shortcut_row),
+                                )
+                                .children(error)
+                                .children(model_card),
+                        ),
+                )
+                .fade_overflow_y(&self.scroll.scroll),
+            )
+            .children(scrollbar)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[gpui::test]
+    fn dictation_partial_cache_is_removable_after_restart(cx: &mut gpui::TestAppContext) {
+        let root = tempfile::tempdir().unwrap();
+        let cache = root.path().join("models/parakeet-tdt-0.6b-v3-int8");
+        std::fs::create_dir_all(&cache).unwrap();
+        std::fs::write(cache.join("encoder-model.int8.onnx.part"), b"partial").unwrap();
+        cx.update(|cx| settings::init(settings::UiSettings::default(), root.path(), cx));
+        let card = cx.update(card);
+        card.update(cx, |card, cx| {
+            assert!(!card.ready);
+            assert_eq!(card.progress, 0);
+            assert!(card.cache_present);
+            card.remove(cx);
+            assert!(!card.cache_present);
+            assert!(!card.ready);
+        });
+        assert!(!cache.exists());
+    }
+    #[gpui::test]
+    fn microphone_choice_survives_disconnection(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| settings::init(settings::UiSettings::default(), dir.path(), cx));
+        let card = cx.update(card);
+        card.update(cx, |card, _| {
+            card.inputs.devices = vec![
+                zeron_voice::InputDevice {
+                    id: "coreaudio:built-in".into(),
+                    name: "MacBook Pro Microphone".into(),
+                },
+                zeron_voice::InputDevice {
+                    id: "coreaudio:usb".into(),
+                    name: "USB Microphone".into(),
+                },
+            ];
+            let (options, selected) = card.input_options(None);
+            assert_eq!((options.len(), selected), (3, 0));
+            assert_eq!(card.input_options(Some("coreaudio:usb")).1, 2);
+            let (options, selected) = card.input_options(Some("coreaudio:gone"));
+            assert_eq!((options.len(), selected), (4, 3));
+        });
+    }
+    #[gpui::test]
+    fn dictation_is_opt_in_and_disabling_preserves_download(cx: &mut gpui::TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| settings::init(settings::UiSettings::default(), dir.path(), cx));
+        cx.update(|cx| assert!(!enabled(cx)));
+        let card = cx.update(card);
+        card.update(cx, |card, cx| {
+            card.ready = true;
+            assert!(!settings::current(cx).dictation_enabled);
+            card.primary(cx);
+        });
+        cx.update(|cx| assert!(enabled(cx)));
+        card.update(cx, |card, cx| {
+            card.primary(cx);
+            assert!(card.ready);
+        });
+        cx.update(|cx| assert!(!enabled(cx)));
+    }
+}
diff --git a/crates/ui/src/dictation/permission.m b/crates/ui/src/dictation/permission.m
new file mode 100644
index 0000000000..00bf5d8f26
--- /dev/null
+++ b/crates/ui/src/dictation/permission.m
@@ -0,0 +1,17 @@
+#import <AppKit/AppKit.h>
+#import <AVFoundation/AVFoundation.h>
+// No Rust callbacks or audio retained by permission blocks.
+int zeron_microphone_permission(void) {
+    NSBundle *bundle = NSBundle.mainBundle;
+    if (![bundle.bundlePath.pathExtension isEqualToString:@"app"] || ![bundle objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"]) return -2;
+    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
+    if (status == AVAuthorizationStatusAuthorized) return 1;
+    if (status == AVAuthorizationStatusNotDetermined) return 0;
+    return -1;
+}
+void zeron_request_microphone(void) {
+    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {}];
+}
+uintptr_t zeron_microphone_window(void) {
+    return NSApp.active ? (uintptr_t)(__bridge void *)NSApp.keyWindow : 0;
+}
diff --git a/crates/ui/src/dictation/waveform.rs b/crates/ui/src/dictation/waveform.rs
new file mode 100644
index 0000000000..8dfe87ef3e
--- /dev/null
+++ b/crates/ui/src/dictation/waveform.rs
@@ -0,0 +1,151 @@
+//! Painted dictation waveform: one rounded bar per meter slot, scrolling from
+//! the trailing edge. A single canvas keeps a full-width waveform to one
+//! element and a handful of quads per frame.
+use std::time::Instant;
+
+use gpui::{Bounds, Hsla, IntoElement, Styled, point, px, size};
+
+use super::{Bar, FLOOR};
+
+pub(crate) const BAR_WIDTH: f32 = 3.0;
+const BAR_GAP: f32 = 3.0;
+const PITCH: f32 = BAR_WIDTH + BAR_GAP;
+/// Bars dissolve over this distance at the leading edge instead of clipping.
+const EDGE_FADE: f32 = 28.0;
+/// Seconds for the transcribing highlight to cross the bars once.
+const SWEEP_PERIOD: f32 = 1.6;
+/// Seconds per breath of the placeholder baseline while capture starts.
+const BREATH_PERIOD: f32 = 1.4;
+
+#[derive(Clone, Copy, PartialEq)]
+pub(crate) enum Mode {
+    /// Microphone is opening: a quiet baseline breathes.
+    Waiting,
+    /// Live input: bars follow the voice.
+    Live,
+    /// Capture ended: bars hold still while a highlight sweeps across them.
+    Processing,
+}
+
+pub(crate) struct Paint {
+    pub ink: Hsla,
+    pub quiet: Hsla,
+}
+
+/// A process-wide clock so repeated renders stay phase-continuous.
+pub(crate) fn seconds() -> f32 {
+    static EPOCH: std::sync::OnceLock<Instant> = std::sync::OnceLock::new();
+    EPOCH.get_or_init(Instant::now).elapsed().as_secs_f32()
+}
+
+pub(crate) fn ease_out(t: f32) -> f32 {
+    let t = t.clamp(0.0, 1.0);
+    1.0 - (1.0 - t).powi(3)
+}
+
+/// Entrance and exit progress, each 0–1.
+#[derive(Clone, Copy, Default)]
+pub(crate) struct Phase {
+    /// Baseline draws in from the trailing edge as the pill appears.
+    pub intro: f32,
+    /// Bars settle back into the baseline as the transcript lands.
+    pub collapse: f32,
+}
+
+/// Bars ride a fixed grid of dots, so live input rises out of the same
+/// baseline the waiting state shows. `motion` false freezes the waiting
+/// breath and the processing sweep; the indicator still names the state.
+pub(crate) fn waveform(
+    bars: Vec<Bar>,
+    mode: Mode,
+    paint: Paint,
+    phase: Phase,
+    motion: bool,
+) -> impl IntoElement {
+    let now = if motion { seconds() } else { 0.0 };
+    gpui::canvas(
+        |_, _, _| {},
+        move |bounds, _, window, _| {
+            let height = f32::from(bounds.size.height);
+            let left = f32::from(bounds.left());
+            let right = f32::from(bounds.right()) - BAR_WIDTH;
+            let mid = f32::from(bounds.center().y);
+            let width = (right - left).max(1.0);
+            // Newest slot's scroll position; the dots scroll with the bars.
+            let offset = match mode {
+                Mode::Waiting => 0.0,
+                _ => bars.first().map_or(0.0, |bar| bar.age.fract()),
+            };
+            let count = ((width + BAR_WIDTH) / PITCH).ceil() as usize + 1;
+            let sweep = (now / SWEEP_PERIOD).fract();
+            let settle = 1.0 - ease_out(phase.collapse);
+            for k in 0..count {
+                let x = right - (k as f32 + offset) * PITCH;
+                let fade = ((x - left) / EDGE_FADE).clamp(0.0, 1.0);
+                // Draw in from the trailing edge: 0 there, 1 at the leading edge.
+                let distance = 1.0 - (x - left) / width;
+                let reveal = ease_out((phase.intro - 0.5 * distance) / 0.5);
+                let alpha = fade * reveal;
+                if alpha <= 0.0 {
+                    continue;
+                }
+                let (amplitude, color) = match (mode, bars.get(k)) {
+                    (Mode::Waiting, _) | (_, None) => {
+                        // A soft swell travels toward the leading edge.
+                        let swell = if mode == Mode::Waiting {
+                            let wave = now / BREATH_PERIOD - k as f32 / 18.0;
+                            (0.5 + 0.5 * (wave * std::f32::consts::TAU).sin()).powi(3)
+                        } else {
+                            0.0
+                        };
+                        (FLOOR + 0.1 * swell, paint.quiet)
+                    }
+                    (_, Some(bar)) => {
+                        // The newest bar rises out of the baseline as it enters.
+                        let grow = if motion { ease_out(bar.age) } else { 1.0 };
+                        let color = if mode == Mode::Live {
+                            paint.ink
+                        } else {
+                            // Right-to-left highlight, matching the scroll.
+                            let position = 1.0 - (x - left) / width;
+                            let distance = (position - (sweep * 1.4 - 0.2)).abs();
+                            let glow = (1.0 - distance / 0.18).clamp(0.0, 1.0);
+                            crate::motion::mix(paint.quiet, paint.ink, ease_out(glow))
+                        };
+                        let lift = (1.0 - FLOOR) * bar.amplitude * grow * settle;
+                        (FLOOR + lift, crate::motion::mix(paint.quiet, color, settle))
+                    }
+                };
+                let h =
+                    (amplitude.clamp(FLOOR, 1.0) * height * (0.4 + 0.6 * reveal)).max(BAR_WIDTH);
+                window.paint_quad(
+                    gpui::fill(
+                        Bounds::new(point(px(x), px(mid - h / 2.0)), size(px(BAR_WIDTH), px(h))),
+                        color.opacity(alpha),
+                    )
+                    .corner_radii(px(BAR_WIDTH / 2.0)),
+                );
+            }
+        },
+    )
+    .flex_1()
+    .min_w_0()
+    .h_full()
+}
+
+/// Display time for the recording clock: `0:07`.
+pub(crate) fn clock(elapsed: std::time::Duration) -> String {
+    let seconds = elapsed.as_secs();
+    format!("{}:{:02}", seconds / 60, seconds % 60)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clock_formats_minutes_and_padded_seconds() {
+        assert_eq!(clock(std::time::Duration::from_millis(7_900)), "0:07");
+        assert_eq!(clock(std::time::Duration::from_secs(60)), "1:00");
+    }
+}
diff --git a/crates/ui/src/icons.rs b/crates/ui/src/icons.rs
index b211fc05e1..20d990664a 100644
--- a/crates/ui/src/icons.rs
+++ b/crates/ui/src/icons.rs
@@ -48,6 +48,7 @@ macro_rules! icon_assets {
 }
 
 icon_assets![
+    (MICROPHONE, "microphone"),
     (PROJECT_DEFAULT, "project-default"),
     (REMOTE_SERVER, "remote-server"),
     // Service-tier bolt, drawn in the toolbar family's linear weight; the
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index e41a30df09..9abec8dd97 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -28,6 +28,7 @@ pub mod composer;
 mod composer_dock;
 mod composer_markdown;
 mod context_usage;
+mod dictation;
 pub mod edge_fade;
 pub mod file_icons;
 pub mod files;
diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 1bd2389404..df67c24519 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -5818,7 +5818,7 @@ impl Render for Pickers {
             None => None,
         };
 
-        // The composer places this model chip beside Send:
+        // The composer places this model chip beside microphone and Send:
         // brand icon + model name, then the effort as the chip's muted second
         // tone — the ladder's level, else an effort option's choice (Cursor).
         // None for the title picker (titles always run at minimal reasoning).
diff --git a/crates/ui/src/queue.rs b/crates/ui/src/queue.rs
index b727c7bf54..db2dfcdcef 100644
--- a/crates/ui/src/queue.rs
+++ b/crates/ui/src/queue.rs
@@ -1492,6 +1492,12 @@ impl Composer {
         if self.editing_queued.is_none() {
             return false;
         }
+        if self
+            .input
+            .update(cx, |input, cx| input.finish_dictation(true, cx))
+        {
+            return true;
+        }
         let text = self.input.read(cx).text().to_string();
         if !self.check_reference_delivery(&text, cx) {
             return true;
@@ -1509,6 +1515,7 @@ impl Composer {
         if self.editing_queued.is_none() {
             return false;
         }
+        self.input.update(cx, |input, _| input.cancel_dictation());
         self.finish_queue_edit("cancel", None, cx);
         true
     }
@@ -1527,6 +1534,7 @@ impl Composer {
         self.queue_edit_pending_id = None;
         self.queue_edit_finishing = false;
         self.input.update(cx, |input, cx| {
+            input.cancel_dictation();
             input.read_only = false;
             cx.notify();
         });
@@ -1577,6 +1585,7 @@ impl Composer {
         });
         self.queue_edit_finishing = true;
         self.input.update(cx, |input, cx| {
+            input.cancel_dictation();
             input.read_only = true;
             cx.notify();
         });
diff --git a/crates/ui/src/settings.rs b/crates/ui/src/settings.rs
index 6aaad42a3d..c578b1f3e8 100644
--- a/crates/ui/src/settings.rs
+++ b/crates/ui/src/settings.rs
@@ -331,6 +331,8 @@ impl SettingsStore {
 }
 
 pub fn init(settings: UiSettings, data_dir: impl Into<PathBuf>, cx: &mut App) {
+    let data_dir = data_dir.into();
+    crate::dictation::init(data_dir.clone(), cx);
     cx.set_global(SettingsStore {
         current: settings,
         data_dir: data_dir.into(),
@@ -785,6 +787,11 @@ pub const SKILL_COMPLETION_HARNESSES: [(zeron_proto::HarnessId, &str); 9] = [
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct UiSettings {
+    pub dictation_enabled: bool,
+    /// Dictation microphone as a `zeron_voice::InputDevice` id; `None`
+    /// follows the system default.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dictation_input: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_geometry: Option<WindowGeometry>,
     /// Submit using Enter or the platform modifier plus Enter.
@@ -967,6 +974,8 @@ pub struct UiSettings {
 impl Default for UiSettings {
     fn default() -> Self {
         Self {
+            dictation_enabled: false,
+            dictation_input: None,
             window_geometry: None,
             sidebar_width: SIDEBAR_DEFAULT,
             sidebar_collapsed: false,
@@ -1077,6 +1086,7 @@ const JUMP_LABELS: [&str; JUMP_SLOTS] = [
 /// rather than panicking.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ShortcutId {
+    ToggleDictation,
     CaptureAppshot,
     RandomWallpaper,
     SaveFile,
@@ -1095,7 +1105,8 @@ pub enum ShortcutId {
 }
 
 impl ShortcutId {
-    pub const ALL: [ShortcutId; 14 + JUMP_SLOTS] = [
+    pub const ALL: [ShortcutId; 15 + JUMP_SLOTS] = [
+        ShortcutId::ToggleDictation,
         ShortcutId::CaptureAppshot,
         ShortcutId::RandomWallpaper,
         ShortcutId::SaveFile,
@@ -1128,6 +1139,7 @@ impl ShortcutId {
     /// Row label (zeron lib/shortcuts.ts `SHORTCUT_DEFINITIONS`, verbatim).
     pub fn label(self) -> &'static str {
         match self {
+            ShortcutId::ToggleDictation => "Hold to dictate",
             ShortcutId::RandomWallpaper => "Random wallpaper",
             ShortcutId::CaptureAppshot => "Capture Appshot",
             ShortcutId::SaveFile => "Save file",
@@ -1155,6 +1167,7 @@ impl ShortcutId {
     /// this guards against only exists off macOS).
     pub fn default_combo_on(self, mac: bool) -> &'static str {
         match self {
+            ShortcutId::ToggleDictation => "mod-d",
             ShortcutId::RandomWallpaper => "mod-u",
             ShortcutId::CaptureAppshot if mac => "ctrl-alt-space",
             ShortcutId::CaptureAppshot => "mod-alt-space",
@@ -1203,6 +1216,7 @@ impl ShortcutId {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct KeymapConfig {
+    pub toggle_dictation: String,
     #[cfg_attr(not(any(target_os = "macos", target_os = "linux")), serde(skip))]
     pub capture_appshot: String,
     pub random_wallpaper: String,
@@ -1269,6 +1283,7 @@ pub fn sidebar_pin_profile_key(
 impl Default for KeymapConfig {
     fn default() -> Self {
         Self {
+            toggle_dictation: ShortcutId::ToggleDictation.default_combo().into(),
             capture_appshot: ShortcutId::CaptureAppshot.default_combo().into(),
             random_wallpaper: ShortcutId::RandomWallpaper.default_combo().into(),
             save_file: ShortcutId::SaveFile.default_combo().into(),
@@ -1291,6 +1306,7 @@ impl Default for KeymapConfig {
 impl KeymapConfig {
     pub fn get(&self, id: ShortcutId) -> &str {
         match id {
+            ShortcutId::ToggleDictation => &self.toggle_dictation,
             ShortcutId::CaptureAppshot => &self.capture_appshot,
             ShortcutId::RandomWallpaper => &self.random_wallpaper,
             ShortcutId::SaveFile => &self.save_file,
@@ -1315,6 +1331,7 @@ impl KeymapConfig {
 
     pub fn set(&mut self, id: ShortcutId, combo: String) {
         match id {
+            ShortcutId::ToggleDictation => self.toggle_dictation = combo,
             ShortcutId::CaptureAppshot => self.capture_appshot = combo,
             ShortcutId::RandomWallpaper => self.random_wallpaper = combo,
             ShortcutId::SaveFile => self.save_file = combo,
@@ -1581,6 +1598,104 @@ impl UiSettings {
             }
     }
 
+    /// Three-way merge for a view that keeps a working copy of the settings:
+    /// fields `edited` changed since `base` win, every other field keeps
+    /// `current`. A stale copy therefore never reverts a choice another
+    /// surface saved meanwhile. The destructure is exhaustive, so a new field
+    /// does not compile until it is merged here too.
+    pub fn merge_changes(base: &Self, edited: &Self, mut current: Self) -> Self {
+        macro_rules! merge {
+            ($($field:ident),* $(,)?) => {{
+                let Self { $($field),* } = edited;
+                $(if *$field != base.$field {
+                    current.$field = $field.clone();
+                })*
+            }};
+        }
+        merge!(
+            dictation_enabled,
+            dictation_input,
+            window_geometry,
+            composer_send_behavior,
+            skills_in_slash_menu,
+            skill_completion_by_harness,
+            compact_model_picker,
+            sidebar_width,
+            sidebar_collapsed,
+            sidebar_grouped,
+            sidebar_organization,
+            sidebar_sort,
+            sidebar_show_project_label,
+            sidebar_compact,
+            sidebar_show_project_icon,
+            sidebar_show_harness,
+            sidebar_show_branch,
+            sidebar_show_pull_request,
+            github_star_banner_dismissed,
+            last_space_id,
+            last_project_action_by_space_id,
+            open_tabs,
+            space_filter,
+            sidebar_sections_by_profile,
+            sidebar_pinned_session_ids_by_profile,
+            tab_order,
+            space_order,
+            sound_enabled,
+            sound_completion_enabled,
+            sound_input_enabled,
+            sound_attention_enabled,
+            notifications_enabled,
+            notifications_background_only,
+            files_panel_width,
+            agent_update_notifications,
+            right_pane_width,
+            right_pane_open,
+            terminal_height,
+            terminal_open,
+            keymap,
+            appshots_enabled,
+            appshot_sound_enabled,
+            appshot_destination,
+            escape_stops_active_agent,
+            settings_section,
+            appearance,
+            git_history_columns,
+            git_history_column_widths,
+            git_history_column_order,
+            git_history_author_display,
+            ui_font_family,
+            ui_font_size,
+            terminal_font_family,
+            terminal_font_size,
+            code_font_family,
+            code_font_size,
+            theme_selection,
+            diff_split,
+            diff_wrap,
+            code_fences_fit_content,
+            transcript_width,
+            open_web_links_in_zeron,
+            transcript_compact_mode,
+            files_autosave_enabled,
+            files_autosave_delay_ms,
+            files_word_wrap,
+            files_show_all,
+            accent,
+            surface,
+            new_thread_composer_background,
+            wallpaper_folder,
+            wallpaper_source,
+            wallpaper_history,
+            wallpaper_theme_colors,
+            wallpaper_color,
+            new_thread_background_effect,
+            reduce_motion,
+            pause_animations_in_background,
+            legacy_accent_color,
+        );
+        current
+    }
+
     /// Clamp widths into their legal ranges (also heals NaN to defaults).
     pub fn clamped(mut self) -> Self {
         self.transcript_width = normalize_transcript_width(self.transcript_width);
@@ -1893,6 +2008,7 @@ mod tests {
             height: 800.0,
         };
         let settings = UiSettings {
+            dictation_enabled: false,
             window_geometry: Some(geometry),
             ..Default::default()
         };
@@ -2499,6 +2615,8 @@ mod tests {
     fn round_trip() {
         let dir = tempfile::tempdir().unwrap();
         let settings = UiSettings {
+            dictation_enabled: false,
+            dictation_input: Some("coreaudio:usb-mic".into()),
             window_geometry: None,
             sidebar_width: 300.0,
             sidebar_collapsed: true,
diff --git a/crates/ui/src/settings/accounts.rs b/crates/ui/src/settings/accounts.rs
index 35eaddaf39..260c8afd45 100644
--- a/crates/ui/src/settings/accounts.rs
+++ b/crates/ui/src/settings/accounts.rs
@@ -121,7 +121,9 @@ pub fn is_openable_login_url(url: &str) -> bool {
         "https" => true,
         "http" => {
             let authority = rest.split(['/', '?', '#']).next().unwrap_or("");
-            let authority = authority.rsplit_once('@').map_or(authority, |(_, host)| host);
+            let authority = authority
+                .rsplit_once('@')
+                .map_or(authority, |(_, host)| host);
             let host = match authority.strip_prefix('[') {
                 Some(v6) => v6.split(']').next().unwrap_or(""),
                 None => authority.split(':').next().unwrap_or(""),
@@ -1185,7 +1187,10 @@ impl AccountsPage {
         // line, so a failed probe never changes the row's height.
         let usage: AnyElement = if account.usage_windows.is_empty() {
             meta.extend(self.render_usage_missing(account, theme));
-            div().w(px(USAGE_COLUMN_WIDTH)).flex_none().into_any_element()
+            div()
+                .w(px(USAGE_COLUMN_WIDTH))
+                .flex_none()
+                .into_any_element()
         } else {
             let resets = account
                 .usage_windows
@@ -1371,7 +1376,9 @@ impl AccountsPage {
                     .flex_1()
                     .min_w_0()
                     .child(widgets::row_title(theme, email.clone()).truncate())
-                    .when(!meta.is_empty(), |el| el.child(widgets::meta_line(theme, meta))),
+                    .when(!meta.is_empty(), |el| {
+                        el.child(widgets::meta_line(theme, meta))
+                    }),
             )
             .child(usage)
             .child(
@@ -2218,7 +2225,9 @@ impl Render for AccountsPage {
 mod tests {
     #[test]
     fn only_web_and_loopback_login_urls_open() {
-        assert!(is_openable_login_url("https://claude.com/cai/oauth/authorize?x=1"));
+        assert!(is_openable_login_url(
+            "https://claude.com/cai/oauth/authorize?x=1"
+        ));
         assert!(is_openable_login_url("http://localhost:1455/auth/callback"));
         assert!(is_openable_login_url("http://127.0.0.1:8080/"));
         assert!(is_openable_login_url("http://[::1]:9000/cb"));
diff --git a/crates/ui/src/settings/appearance.rs b/crates/ui/src/settings/appearance.rs
index 3fc10efcce..06eea23100 100644
--- a/crates/ui/src/settings/appearance.rs
+++ b/crates/ui/src/settings/appearance.rs
@@ -4526,7 +4526,9 @@ mod tests {
         });
         let (_page, cx) = cx.add_window_view(|_, cx| AppearancePage::new(cx));
         cx.update(|window, cx| window.draw(cx).clear());
-        let trigger = cx.debug_bounds("appearance-surface").expect("glass trigger");
+        let trigger = cx
+            .debug_bounds("appearance-surface")
+            .expect("glass trigger");
         cx.simulate_click(trigger.center(), gpui::Modifiers::default());
         cx.update(|window, cx| window.draw(cx).clear());
         let frosted = cx
diff --git a/crates/ui/src/settings/devices.rs b/crates/ui/src/settings/devices.rs
index 7777ca7061..a851c40fdd 100644
--- a/crates/ui/src/settings/devices.rs
+++ b/crates/ui/src/settings/devices.rs
@@ -289,7 +289,9 @@ impl Render for DevicesPage {
             let rename_name = device.name.clone();
             let mut meta: Vec<AnyElement> = vec![
                 div()
-                    .child(SharedString::from(platform_label(&device.platform).to_string()))
+                    .child(SharedString::from(
+                        platform_label(&device.platform).to_string(),
+                    ))
                     .into_any_element(),
             ];
             if let Some(version) = device.version.as_deref().filter(|v| !v.is_empty()) {
@@ -340,9 +342,11 @@ impl Render for DevicesPage {
                             .role(gpui::Role::Button)
                             .aria_label(format!("Copy device ID {}", device.id))
                             .focus_visible(|s| s.border_2().border_color(theme.accent))
-                            .on_click(cx.listener(move |this, _, _, cx| {
-                                this.copy_id(copy_id.clone(), cx);
-                            })),
+                            .on_click(cx.listener(
+                                move |this, _, _, cx| {
+                                    this.copy_id(copy_id.clone(), cx);
+                                },
+                            )),
                         )
                         .child(
                             widgets::text_action(&theme, widgets::ActionTone::Filled, "Rename")
diff --git a/crates/ui/src/settings/shortcuts.rs b/crates/ui/src/settings/shortcuts.rs
index a461748d1d..de18c564f7 100644
--- a/crates/ui/src/settings/shortcuts.rs
+++ b/crates/ui/src/settings/shortcuts.rs
@@ -230,53 +230,14 @@ impl ShortcutsPage {
             }
             RecordOutcome::Ignored => {}
             RecordOutcome::Set(combo) => {
-                if recording == ShortcutId::CaptureAppshot
-                    && crate::appshots::validate_shortcut(&combo).is_err()
-                {
-                    self.conflict_notice = Some(
-                        format!(
-                            "Use {} with a letter, number, function key or navigation key.",
-                            if cfg!(target_os = "macos") {
-                                "Control, Option or Command"
-                            } else {
-                                "Control or Alt"
-                            }
-                        )
-                        .into(),
-                    );
-                    self.stop_recording();
-                    cx.notify();
-                    cx.stop_propagation();
-                    return;
-                }
-                if send_combo_is_reserved(self.composer_send_behavior, &combo) {
-                    self.conflict_notice = Some(
-                        format!("{} is reserved for the composer.", display_combo(&combo)).into(),
-                    );
-                    self.stop_recording();
-                    cx.notify();
-                    cx.stop_propagation();
-                    return;
-                }
-                // A combo already bound elsewhere is REFUSED, naming the owner
-                // (zeron settings.shortcuts.tsx: "… is already assigned to …").
-                if let Some(owner) = conflict_owner(&self.keymap, recording, &combo) {
-                    self.conflict_notice = Some(
-                        format!(
-                            "{} is already assigned to {}.",
-                            display_combo(&combo),
-                            owner.label()
-                        )
-                        .into(),
-                    );
-                    self.stop_recording();
-                    cx.notify();
-                } else {
+                self.stop_recording();
+                self.conflict_notice =
+                    refusal(&self.keymap, self.composer_send_behavior, recording, &combo);
+                if self.conflict_notice.is_none() {
                     self.keymap.set(recording, combo);
-                    self.stop_recording();
-                    self.conflict_notice = None;
                     self.commit(cx);
                 }
+                cx.notify();
             }
         }
         cx.stop_propagation();
@@ -329,87 +290,28 @@ impl ShortcutsPage {
         theme: &Theme,
         cx: &mut Context<Self>,
     ) -> gpui::Div {
-        let accent = theme.accent;
-        let combo = self.keymap.get(id).to_string();
-        let is_recording = recording == Some(id);
-        let non_default = combo != id.default_combo();
-        let chip_text: SharedString = if is_recording {
-            "Press keys…".into()
-        } else {
-            display_combo(&combo).into()
-        };
-        div()
-            .flex()
-            .flex_none()
-            .items_center()
-            .gap(px(20.0))
-            .when(non_default && !is_recording, |el| {
-                el.child(
-                    div()
-                        .id(("shortcut-reset", ix))
-                        .role(gpui::Role::Button)
-                        .aria_label(format!("Reset {} shortcut", id.label()))
-                        .min_h(px(24.0))
-                        .tab_index(0)
-                        .focus_visible(move |style| style.border_2().border_color(accent))
-                        .text_size(crate::typography::ui_rems(11.0))
-                        .text_color(theme.text_muted)
-                        .cursor_pointer()
-                        .hover(|s| s.text_color(theme.text))
-                        .on_click(cx.listener(move |this, _, _, cx| {
-                            this.keymap.reset(id);
-                            this.stop_recording();
-                            this.commit(cx);
-                        }))
-                        .child(SharedString::from("Reset")),
-                )
-            })
-            .child(
-                div()
-                    .id(("shortcut-combo", ix))
-                    .role(gpui::Role::Button)
-                    .aria_label(format!(
-                        "Change {} shortcut: {}",
-                        id.label(),
-                        display_combo(&combo)
-                    ))
-                    .tab_index(0)
-                    .min_w(px(96.0))
-                    .h(px(widgets::SELECT_HEIGHT))
-                    .px(px(12.0))
-                    .rounded(px(8.0))
-                    // Same glass wash as the settings dropdowns; the
-                    // transparent edge is held for the focus ring.
-                    .border_1()
-                    .border_color(gpui::transparent_black())
-                    .focus_visible(move |style| style.border_color(accent))
-                    .flex()
-                    .items_center()
-                    .justify_center()
-                    .font_family(theme.font_mono.clone())
-                    .text_size(crate::typography::ui_rems(12.0))
-                    .cursor_pointer()
-                    .map(|el| {
-                        if is_recording {
-                            el.bg(accent.opacity(0.16))
-                                .border_color(accent.opacity(0.55))
-                                .text_color(theme.text)
-                        } else {
-                            let hover_key = format!("shortcut-combo-{ix}-hover");
-                            el.bg(crate::motion::hover_blend(
-                                &hover_key,
-                                widgets::select_fill(theme, false),
-                                widgets::select_fill(theme, true),
-                            ))
-                            .on_hover(crate::motion::hover_listener(hover_key))
-                            .text_color(theme.text)
-                        }
+        let page = cx.entity().downgrade();
+        let reset_page = page.clone();
+        binding_control(
+            id,
+            ix,
+            self.keymap.get(id),
+            recording == Some(id),
+            theme,
+            move |_, cx| {
+                reset_page
+                    .update(cx, |this, cx| {
+                        this.keymap.reset(id);
+                        this.stop_recording();
+                        this.commit(cx);
                     })
-                    .on_click(cx.listener(move |this, _, window, cx| {
-                        this.start_recording(id, window, cx);
-                    }))
-                    .child(chip_text),
-            )
+                    .ok();
+            },
+            move |window, cx| {
+                page.update(cx, |this, cx| this.start_recording(id, window, cx))
+                    .ok();
+            },
+        )
     }
 
     fn on_scroll_hovered(&mut self, hovered: &bool, _: &mut Window, cx: &mut Context<Self>) {
@@ -459,6 +361,303 @@ impl popover::ScrollRailHost for ShortcutsPage {
     }
 }
 
+/// One rebindable shortcut on the settings page of the feature it drives
+/// (Settings → Voice). Records and refuses combos exactly like a Shortcuts
+/// row, then saves straight to the store and re-applies the keymap.
+pub struct ShortcutField {
+    id: ShortcutId,
+    focus: FocusHandle,
+    recording: bool,
+    recording_subscriptions: Option<[gpui::Subscription; 3]>,
+    notice: Option<SharedString>,
+}
+
+impl ShortcutField {
+    pub fn new(id: ShortcutId, cx: &mut Context<Self>) -> Self {
+        cx.on_release(|field, _| {
+            if field.recording {
+                crate::appshots::set_recording(false);
+            }
+        })
+        .detach();
+        Self {
+            id,
+            focus: cx.focus_handle(),
+            recording: false,
+            recording_subscriptions: None,
+            notice: None,
+        }
+    }
+
+    fn start_recording(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.recording = true;
+        crate::appshots::set_recording(true);
+        let field = cx.entity().downgrade();
+        // Bound actions run before Div key listeners; intercept first so the
+        // chord being recorded (⌘D itself) never starts dictation.
+        let interceptor = cx.intercept_keystrokes(move |event, window, cx| {
+            let _ = field.update(cx, |field, cx| {
+                if field.focus.is_focused(window) {
+                    field.record_keystroke(&event.keystroke, cx);
+                }
+            });
+        });
+        let blur = cx.on_blur(&self.focus, window, |field, _, cx| {
+            field.stop_recording();
+            cx.notify();
+        });
+        // The Voice page outlives its window (closing it keeps the app
+        // running), and a close does not blur. Never leave Appshots'
+        // capture shortcut suspended.
+        let field = cx.entity().downgrade();
+        let closed = cx.on_window_closed(move |cx, _| {
+            field
+                .update(cx, |field, cx| {
+                    field.stop_recording();
+                    cx.notify();
+                })
+                .ok();
+        });
+        self.recording_subscriptions = Some([interceptor, blur, closed]);
+        self.notice = None;
+        window.focus(&self.focus, cx);
+        cx.notify();
+    }
+
+    fn stop_recording(&mut self) {
+        if self.recording {
+            crate::appshots::set_recording(false);
+        }
+        self.recording = false;
+        self.recording_subscriptions = None;
+    }
+
+    fn record_keystroke(&mut self, keystroke: &Keystroke, cx: &mut Context<Self>) {
+        let mods = &keystroke.modifiers;
+        match record_key(
+            &keystroke.key,
+            mods.control,
+            mods.alt,
+            mods.shift,
+            mods.platform,
+        ) {
+            RecordOutcome::Cancelled => self.stop_recording(),
+            RecordOutcome::Ignored => {}
+            RecordOutcome::Set(combo) => {
+                self.stop_recording();
+                let current = crate::settings::current(cx);
+                self.notice = refusal(
+                    &current.keymap,
+                    current.composer_send_behavior,
+                    self.id,
+                    &combo,
+                );
+                if self.notice.is_none() {
+                    self.save(Some(combo), cx);
+                }
+            }
+        }
+        cx.notify();
+        cx.stop_propagation();
+    }
+
+    /// `None` restores the default binding.
+    fn save(&mut self, combo: Option<String>, cx: &mut Context<Self>) {
+        let id = self.id;
+        crate::settings::update(
+            crate::settings::SavePolicy::Immediate,
+            cx,
+            |settings| match combo {
+                Some(combo) => settings.keymap.set(id, combo),
+                None => settings.keymap.reset(id),
+            },
+        );
+        let current = crate::settings::current(cx);
+        crate::shell::apply_keymap(cx, &current.keymap, current.composer_send_behavior);
+        cx.notify();
+    }
+}
+
+impl Render for ShortcutField {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = Theme::of(cx).for_settings_surface();
+        let combo = crate::settings::current(cx).keymap.get(self.id).to_string();
+        let ix = ShortcutId::ALL
+            .iter()
+            .position(|&id| id == self.id)
+            .unwrap_or(0);
+        let reset = cx.entity().downgrade();
+        let record = reset.clone();
+        let helper: Option<SharedString> = if self.recording {
+            Some("Press Escape to cancel.".into())
+        } else {
+            self.notice.clone()
+        };
+        div()
+            .id("shortcut-field")
+            .track_focus(&self.focus)
+            .flex()
+            .flex_col()
+            .items_end()
+            .gap(px(4.0))
+            .child(binding_control(
+                self.id,
+                ix,
+                &combo,
+                self.recording,
+                &theme,
+                move |_, cx| {
+                    reset
+                        .update(cx, |field, cx| {
+                            field.stop_recording();
+                            field.notice = None;
+                            field.save(None, cx);
+                        })
+                        .ok();
+                },
+                move |window, cx| {
+                    record
+                        .update(cx, |field, cx| field.start_recording(window, cx))
+                        .ok();
+                },
+            ))
+            .children(helper.map(|helper| {
+                div()
+                    .text_size(crate::typography::ui_rems(12.0))
+                    .text_color(theme.text_muted)
+                    .child(helper)
+            }))
+    }
+}
+
+/// Reset (when customized) plus the click-to-record combo chip; recording
+/// inverts it to the accent wash. Shared by Settings → Shortcuts and the
+/// feature pages that own a shortcut ([`ShortcutField`]).
+fn binding_control(
+    id: ShortcutId,
+    ix: usize,
+    combo: &str,
+    is_recording: bool,
+    theme: &Theme,
+    on_reset: impl Fn(&mut Window, &mut gpui::App) + 'static,
+    on_record: impl Fn(&mut Window, &mut gpui::App) + 'static,
+) -> gpui::Div {
+    let accent = theme.accent;
+    let combo = combo.to_string();
+    let non_default = combo != id.default_combo();
+    let chip_text: SharedString = if is_recording {
+        "Press keys…".into()
+    } else {
+        display_combo(&combo).into()
+    };
+    div()
+        .flex()
+        .flex_none()
+        .items_center()
+        .gap(px(20.0))
+        .when(non_default && !is_recording, |el| {
+            el.child(
+                div()
+                    .id(("shortcut-reset", ix))
+                    .role(gpui::Role::Button)
+                    .aria_label(format!("Reset {} shortcut", id.label()))
+                    .min_h(px(24.0))
+                    .tab_index(0)
+                    .focus_visible(move |style| style.border_2().border_color(accent))
+                    .text_size(crate::typography::ui_rems(11.0))
+                    .text_color(theme.text_muted)
+                    .cursor_pointer()
+                    .hover(|s| s.text_color(theme.text))
+                    .on_click(move |_, window, cx| on_reset(window, cx))
+                    .child(SharedString::from("Reset")),
+            )
+        })
+        .child(
+            div()
+                .id(("shortcut-combo", ix))
+                .role(gpui::Role::Button)
+                .aria_label(format!(
+                    "Change {} shortcut: {}",
+                    id.label(),
+                    display_combo(&combo)
+                ))
+                .tab_index(0)
+                .min_w(px(96.0))
+                .h(px(widgets::SELECT_HEIGHT))
+                .px(px(12.0))
+                .rounded(px(8.0))
+                // Same glass wash as the settings dropdowns; the
+                // transparent edge is held for the focus ring.
+                .border_1()
+                .border_color(gpui::transparent_black())
+                .focus_visible(move |style| style.border_color(accent))
+                .flex()
+                .items_center()
+                .justify_center()
+                .font_family(theme.font_mono.clone())
+                .text_size(crate::typography::ui_rems(12.0))
+                .cursor_pointer()
+                .map(|el| {
+                    if is_recording {
+                        el.bg(accent.opacity(0.16))
+                            .border_color(accent.opacity(0.55))
+                            .text_color(theme.text)
+                    } else {
+                        let hover_key = format!("shortcut-combo-{ix}-hover");
+                        el.bg(crate::motion::hover_blend(
+                            &hover_key,
+                            widgets::select_fill(theme, false),
+                            widgets::select_fill(theme, true),
+                        ))
+                        .on_hover(crate::motion::hover_listener(hover_key))
+                        .text_color(theme.text)
+                    }
+                })
+                .on_click(move |_, window, cx| on_record(window, cx))
+                .child(chip_text),
+        )
+}
+
+/// Why `combo` cannot be bound to `id`, if it cannot. Conflicts never
+/// persist; they're refused at record time, naming the owner (zeron
+/// settings.shortcuts.tsx: "… is already assigned to …"). Pure.
+fn refusal(
+    keymap: &KeymapConfig,
+    behavior: ComposerSendBehavior,
+    id: ShortcutId,
+    combo: &str,
+) -> Option<SharedString> {
+    if id == ShortcutId::CaptureAppshot && crate::appshots::validate_shortcut(combo).is_err() {
+        return Some(
+            format!(
+                "Use {} with a letter, number, function key or navigation key.",
+                if cfg!(target_os = "macos") {
+                    "Control, Option or Command"
+                } else {
+                    "Control or Alt"
+                }
+            )
+            .into(),
+        );
+    }
+    if send_combo_is_reserved(behavior, combo) {
+        return Some(format!("{} is reserved for the composer.", display_combo(combo)).into());
+    }
+    conflict_owner(keymap, id, combo).map(|owner| {
+        // Name the page for shortcuts that live on their feature's page.
+        let page = match group(owner) {
+            page @ ("Appshots" | "Voice") => format!(" in Settings → {page}"),
+            _ => String::new(),
+        };
+        format!(
+            "{} is already assigned to {}{page}.",
+            display_combo(combo),
+            owner.label()
+        )
+        .into()
+    })
+}
+
 /// The shortcut (other than `id`) already bound to `combo`, if any. Pure.
 pub fn conflict_owner(keymap: &KeymapConfig, id: ShortcutId, combo: &str) -> Option<ShortcutId> {
     ShortcutId::ALL
@@ -479,7 +678,7 @@ pub fn modifier_send_label(is_macos: bool) -> &'static str {
 /// extends the match and appears on the page by construction
 /// (`every_shortcut_lands_in_a_rendered_group` holds the other half: its group
 /// name must be listed here).
-const GROUP_ORDER: [&str; 8] = [
+const GROUP_ORDER: [&str; 9] = [
     "Appearance",
     "Files",
     "Browser",
@@ -488,6 +687,7 @@ const GROUP_ORDER: [&str; 8] = [
     "Projects",
     "Jump to session",
     "Appshots",
+    "Voice",
 ];
 
 /// The section a shortcut's row renders under.
@@ -502,6 +702,7 @@ fn group(id: ShortcutId) -> &'static str {
         | ShortcutId::ToggleFiles
         | ShortcutId::ToggleTerminal => "Panels",
         ShortcutId::NewProject => "Projects",
+        ShortcutId::ToggleDictation => "Voice",
         ShortcutId::OpenModelPicker
         | ShortcutId::NewSession
         | ShortcutId::NextSession
@@ -513,6 +714,13 @@ fn group(id: ShortcutId) -> &'static str {
 
 impl Render for ShortcutsPage {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        // Feature pages (Voice) rebind their shortcut through the store. Read
+        // it back so a later commit here never republishes an older keymap.
+        if self.recording.is_none()
+            && let Some(store) = cx.try_global::<crate::settings::SettingsStore>()
+        {
+            self.keymap.clone_from(&store.current.keymap);
+        }
         if self.appshots_page {
             if std::mem::take(&mut self.appshots_focus_pending) {
                 window.focus(&self.focus, cx);
@@ -712,7 +920,8 @@ impl Render for ShortcutsPage {
         // own top margin is zeroed.
         let mut groups: Vec<gpui::AnyElement> = Vec::new();
         for name in GROUP_ORDER {
-            if name == "Appshots" {
+            // Feature pages own these: Settings → Appshots and → Voice.
+            if name == "Appshots" || name == "Voice" {
                 continue;
             }
             let mut card = widgets::section_card(&theme).mt_0();
@@ -839,6 +1048,84 @@ impl Render for ShortcutsPage {
 mod tests {
     use super::*;
 
+    #[gpui::test]
+    fn voice_shortcut_records_on_its_own_page_and_shortcuts_reads_it_back(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::settings::init(crate::settings::UiSettings::default(), dir.path(), cx);
+        });
+        assert_eq!(ShortcutId::ToggleDictation.default_combo(), "mod-d");
+        assert_eq!(group(ShortcutId::ToggleDictation), "Voice");
+        let modifier = if cfg!(target_os = "macos") {
+            "cmd"
+        } else {
+            "ctrl"
+        };
+        let (field, cx) =
+            cx.add_window_view(|_, cx| ShortcutField::new(ShortcutId::ToggleDictation, cx));
+        // A chord another shortcut owns is refused and the binding is kept.
+        field.update_in(cx, |field, window, cx| field.start_recording(window, cx));
+        cx.simulate_keystrokes(&format!("{modifier}-b"));
+        field.update(cx, |field, cx| {
+            assert!(!field.recording);
+            assert!(field.notice.is_some());
+            assert_eq!(
+                crate::settings::current(cx).keymap.toggle_dictation,
+                "mod-d"
+            );
+        });
+        field.update_in(cx, |field, window, cx| field.start_recording(window, cx));
+        cx.simulate_keystrokes(&format!("{modifier}-shift-v"));
+        field.update(cx, |field, cx| {
+            assert!(field.notice.is_none());
+            assert_eq!(
+                crate::settings::current(cx).keymap.toggle_dictation,
+                "mod-shift-v"
+            );
+        });
+        // Closing the window mid-recording (the app keeps running) must not
+        // leave Appshots' capture shortcut suspended.
+        field.update_in(cx, |field, window, cx| field.start_recording(window, cx));
+        cx.update(|window, _| window.remove_window());
+        cx.run_until_parked();
+        field.update(cx, |field, _| assert!(!field.recording));
+        // Elsewhere, a clash with a feature page's shortcut says where it lives.
+        let notice = refusal(
+            &KeymapConfig::default(),
+            ComposerSendBehavior::Enter,
+            ShortcutId::ToggleSidebar,
+            "mod-d",
+        )
+        .unwrap();
+        assert!(
+            notice.ends_with("Hold to dictate in Settings → Voice."),
+            "{notice}"
+        );
+        // Settings → Shortcuts, opened later with an older copy, adopts the
+        // store's binding so its own commits cannot revert Voice's.
+        let (page, cx) = cx.add_window_view(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            ShortcutsPage::new(
+                state,
+                KeymapConfig::default(),
+                false,
+                ComposerSendBehavior::Enter,
+                false,
+                false,
+                AppshotDestination::Automatic,
+                cx,
+            )
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        page.update(cx, |page, _| {
+            assert_eq!(page.keymap.toggle_dictation, "mod-shift-v");
+        });
+    }
+
     #[gpui::test]
     fn conversation_controls_work_after_moving_out_of_shortcuts(cx: &mut gpui::TestAppContext) {
         cx.update(|cx| {
diff --git a/crates/ui/src/settings/thread_naming.rs b/crates/ui/src/settings/thread_naming.rs
index 2c7012230c..7e566afbdf 100644
--- a/crates/ui/src/settings/thread_naming.rs
+++ b/crates/ui/src/settings/thread_naming.rs
@@ -27,9 +27,12 @@ impl ThreadNamingCard {
             let state = state.clone();
             cx.new(|cx| Pickers::new_for_titles(state, TitleSettings::default(), cx))
         };
-        let picked = cx.subscribe(&picker, |this: &mut Self, _, event: &TitleModelPicked, cx| {
-            this.call(Some(event.0.clone()), cx);
-        });
+        let picked = cx.subscribe(
+            &picker,
+            |this: &mut Self, _, event: &TitleModelPicked, cx| {
+                this.call(Some(event.0.clone()), cx);
+            },
+        );
         // Settings can open before the engine connects: load once it does.
         let state_sub = cx.observe(&state, |this: &mut Self, _, cx| {
             if matches!(this.settings, Loadable::Idle) {
@@ -155,7 +158,9 @@ impl Render for ThreadNamingCard {
                     .child(control),
             )
             .when_some(self.error.clone(), |card, error| {
-                card.child(widgets::card_row(&theme, false).child(widgets::error_strip(&theme, error)))
+                card.child(
+                    widgets::card_row(&theme, false).child(widgets::error_strip(&theme, error)),
+                )
             })
     }
 }
diff --git a/crates/ui/src/settings/widgets.rs b/crates/ui/src/settings/widgets.rs
index fdbd8928db..e649bf555a 100644
--- a/crates/ui/src/settings/widgets.rs
+++ b/crates/ui/src/settings/widgets.rs
@@ -1652,7 +1652,11 @@ impl RenderOnce for SettingsScroll {
 pub struct TextTooltip(pub SharedString);
 
 impl Render for TextTooltip {
-    fn render(&mut self, _window: &mut gpui::Window, cx: &mut gpui::Context<Self>) -> impl IntoElement {
+    fn render(
+        &mut self,
+        _window: &mut gpui::Window,
+        cx: &mut gpui::Context<Self>,
+    ) -> impl IntoElement {
         let theme = Theme::of(cx);
         let card = div()
             .max_w(px(320.0))
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index b788e66744..ed2749e2e9 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -418,6 +418,14 @@ pub fn apply_keymap(
     // rebuilding Zeron's bindings so the file editor keymap remains active.
     gpui_base::init(cx);
     crate::composer::init(cx, composer_send_behavior);
+    cx.bind_keys([KeyBinding::new(
+        &valid_or_default(
+            &keymap.toggle_dictation,
+            ShortcutId::ToggleDictation.default_combo(),
+        ),
+        crate::composer::ToggleDictation,
+        Some("MessageComposer"),
+    )]);
     // Fixed app-level shortcuts (Settings on every platform; ⌘Q quit, ⌘W
     // close, ⌘M minimize, ⌘H hide on macOS) — these back the native menu
     // key equivalents and must survive keymap re-application.
@@ -523,6 +531,7 @@ pub enum SettingsSection {
     Appearance,
     Files,
     Notifications,
+    Voice,
     Shortcuts,
     /// Composer and conversation behavior plus thread naming.
     #[default]
@@ -533,10 +542,11 @@ pub enum SettingsSection {
 
 impl SettingsSection {
     /// Sections shown in Settings. `Agents` is a legacy Accounts route alias.
-    pub const ALL: [SettingsSection; 9] = [
+    pub const ALL: [SettingsSection; 10] = [
         SettingsSection::General,
         SettingsSection::Appearance,
         SettingsSection::Notifications,
+        SettingsSection::Voice,
         SettingsSection::Shortcuts,
         SettingsSection::Harnesses,
         SettingsSection::Devices,
@@ -561,7 +571,7 @@ impl SettingsSection {
 
     /// Where a generic "open Settings" lands for a remembered section: legacy
     /// aliases resolve to their page, and a section this build does not show
-    /// (Appshots off-desktop) falls back to General.
+    /// (Appshots off macOS/Linux) falls back to General.
     pub(crate) fn reopenable(self) -> Self {
         let section = self.canonical();
         if section.visible_in_nav() {
@@ -580,6 +590,7 @@ impl SettingsSection {
             SettingsSection::Appearance => "appearance",
             SettingsSection::Files => "files",
             SettingsSection::Notifications => "notifications",
+            SettingsSection::Voice => "voice",
             SettingsSection::Shortcuts => "shortcuts",
             SettingsSection::General => "general",
             SettingsSection::Appshots => "appshots",
@@ -596,6 +607,7 @@ impl SettingsSection {
             "appearance" => SettingsSection::Appearance,
             "files" => SettingsSection::Files,
             "notifications" => SettingsSection::Notifications,
+            "voice" => SettingsSection::Voice,
             "shortcuts" => SettingsSection::Shortcuts,
             "general" | "conversations" => SettingsSection::General,
             "appshots" => SettingsSection::Appshots,
@@ -620,6 +632,7 @@ impl SettingsSection {
             SettingsSection::Appearance => "Appearance",
             SettingsSection::Files => "Files",
             SettingsSection::Notifications => "Notifications",
+            SettingsSection::Voice => "Voice",
             SettingsSection::Shortcuts => "Shortcuts",
             SettingsSection::General => "General",
             SettingsSection::Appshots => "Appshots",
@@ -1958,6 +1971,9 @@ pub struct Shell {
     boot: EngineBootConfig,
     data_dir: PathBuf,
     settings: UiSettings,
+    /// The store's settings when `settings` last synced with it. Fields that
+    /// differ from this are the Shell's edits; all others follow the store.
+    settings_base: UiSettings,
     /// Session-scoped panel open flags (terminal / changes per chat; §1.10-1.11
     /// parity — heights stay in [`UiSettings`]).
     panels: SessionPanels,
@@ -2363,6 +2379,7 @@ impl Shell {
             import_current: None,
             boot,
             data_dir,
+            settings_base: settings::current(cx),
             settings,
             panels: SessionPanels::default(),
             active_chat: String::new(),
@@ -4460,38 +4477,20 @@ impl Shell {
         self.settings.theme_selection = crate::appearance::themes(cx);
         self.settings.accent = crate::appearance::accent(cx);
         self.settings.surface = crate::appearance::surface(cx);
-        self.sync_independent_settings(cx);
+        self.pull_settings(cx);
         settings::replace(self.settings.clone(), SavePolicy::Debounced, cx);
+        self.settings_base = settings::current(cx);
     }
 
-    /// Controls outside the Shell mutate these choices directly. A geometry
-    /// save must never publish the Shell's older values over those selections.
-    /// The typography globals own the font choices but persist every change
-    /// immediately, so the central store is an equally canonical read and
-    /// keeps this block on a single source.
-    fn sync_independent_settings(&mut self, cx: &App) {
+    /// Controls outside the Shell (Voice, typography, diff and transcript
+    /// toggles, …) save to the central store directly. Fold those into the
+    /// working copy while keeping the Shell's own edits, so a geometry save
+    /// can never publish an older value over another surface's choice.
+    fn pull_settings(&mut self, cx: &App) {
         let current = settings::current(cx);
-        self.settings.window_geometry = current.window_geometry;
-        self.settings.new_thread_composer_background = current.new_thread_composer_background;
-        self.settings.new_thread_background_effect = current.new_thread_background_effect;
-        self.settings.wallpaper_folder = current.wallpaper_folder;
-        self.settings.wallpaper_source = current.wallpaper_source;
-        self.settings.wallpaper_history = current.wallpaper_history;
-        self.settings.wallpaper_theme_colors = current.wallpaper_theme_colors;
-        self.settings.wallpaper_color = current.wallpaper_color;
-        self.settings.open_web_links_in_zeron = current.open_web_links_in_zeron;
-        self.settings.ui_font_family = current.ui_font_family;
-        self.settings.ui_font_size = current.ui_font_size;
-        self.settings.terminal_font_family = current.terminal_font_family;
-        self.settings.terminal_font_size = current.terminal_font_size;
-        self.settings.code_font_family = current.code_font_family;
-        self.settings.code_font_size = current.code_font_size;
-        self.settings.transcript_width = current.transcript_width;
-        self.settings.skill_completion_by_harness = current.skill_completion_by_harness;
-        self.settings.skills_in_slash_menu = current.skills_in_slash_menu;
-        self.settings.reduce_motion = current.reduce_motion;
-        self.settings.pause_animations_in_background = current.pause_animations_in_background;
-        self.settings.compact_model_picker = current.compact_model_picker;
+        self.settings =
+            UiSettings::merge_changes(&self.settings_base, &self.settings, current.clone());
+        self.settings_base = current;
     }
 
     fn retry_engine(&mut self, cx: &mut Context<Self>) {
@@ -4899,9 +4898,8 @@ impl Shell {
                     None => Empty.into_any_element(),
                 }
             }
-            SettingsSection::Shortcuts
-            | SettingsSection::General
-            | SettingsSection::Appshots => {
+            SettingsSection::Voice => crate::dictation::card(cx).into_any_element(),
+            SettingsSection::Shortcuts | SettingsSection::General | SettingsSection::Appshots => {
                 if self.shortcuts_page.is_none() {
                     let state = self.state.clone();
                     let keymap = self.settings.keymap.clone();
@@ -6847,6 +6845,7 @@ impl Shell {
             SettingsSection::Appearance => icons::TUNING,
             SettingsSection::Files => icons::FOLDER,
             SettingsSection::Notifications => icons::BELL,
+            SettingsSection::Voice => icons::MICROPHONE,
             SettingsSection::Shortcuts => icons::KEYBOARD,
             SettingsSection::General => icons::SETTINGS,
             SettingsSection::Appshots => icons::MONITOR,
@@ -12239,7 +12238,7 @@ impl Render for Shell {
         self.settings.theme_selection = crate::appearance::themes(cx);
         self.settings.accent = crate::appearance::accent(cx);
         self.settings.surface = crate::appearance::surface(cx);
-        self.sync_independent_settings(cx);
+        self.pull_settings(cx);
         let theme = Theme::of(cx);
         // The shell frost sits over native desktop blur on macOS and Windows.
         // Content surfaces add their own backgrounds over this shared tint.
@@ -14709,6 +14708,78 @@ mod exit_regressions {
             .unwrap();
     }
 
+    #[gpui::test]
+    fn shell_saves_keep_every_setting_chosen_outside_the_shell(cx: &mut TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+            crate::history::init(
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                cx,
+            );
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+        });
+        let window = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Shell::new(
+                state,
+                EngineBootConfig {
+                    data_dir: dir.path().into(),
+                    ipc_port: 0,
+                    edge_url: "http://127.0.0.1:1".into(),
+                    edge_token: None,
+                    org_id: None,
+                    workos_client_id: None,
+                    default_harness: zeron_proto::HarnessId::Mock,
+                },
+                cx,
+            )
+        });
+        window
+            .update(cx, |shell, _, cx| {
+                // Voice, transcript and diff controls save straight to the
+                // store. None of them is known to the Shell.
+                settings::update(SavePolicy::Immediate, cx, |settings| {
+                    settings.dictation_enabled = true;
+                    settings.dictation_input = Some("coreaudio:usb".into());
+                    settings.transcript_compact_mode = true;
+                    settings.code_fences_fit_content = true;
+                    settings.diff_split = true;
+                    settings.diff_wrap = true;
+                });
+                // Leaving Settings and resizing both republish the Shell's copy.
+                shell.settings.settings_section = SettingsSection::Appearance;
+                shell.settings.sidebar_width = 300.0;
+                shell.schedule_save(cx);
+                let saved = settings::current(cx);
+                assert!(saved.dictation_enabled);
+                assert_eq!(saved.dictation_input.as_deref(), Some("coreaudio:usb"));
+                assert!(saved.transcript_compact_mode);
+                assert!(saved.code_fences_fit_content);
+                assert!(saved.diff_split);
+                assert!(saved.diff_wrap);
+                assert_eq!(saved.settings_section, SettingsSection::Appearance);
+                assert_eq!(saved.sidebar_width, 300.0);
+                // An outside change to a field the Shell also holds still wins
+                // once the Shell has nothing newer of its own.
+                settings::update(SavePolicy::Immediate, cx, |settings| {
+                    settings.dictation_enabled = false;
+                    settings.sidebar_width = 320.0;
+                });
+                shell.schedule_save(cx);
+                let saved = settings::current(cx);
+                assert!(!saved.dictation_enabled);
+                assert_eq!(saved.sidebar_width, 320.0);
+                assert_eq!(shell.settings.sidebar_width, 320.0);
+            })
+            .unwrap();
+    }
+
     #[gpui::test]
     fn sidebar_settings_trigger_toggles_the_settings_route(cx: &mut TestAppContext) {
         // Just the footer row: the full shell's settings modal would cover it.
@@ -16443,6 +16514,7 @@ mod settings_modal_regressions {
             ("settings/agents", SettingsSection::Harnesses),
             ("settings/harnesses", SettingsSection::Harnesses),
             ("settings/general", SettingsSection::General),
+            ("settings/voice", SettingsSection::Voice),
             ("settings/conversations", SettingsSection::General),
             ("settings/files", SettingsSection::Files),
             ("settings/appshots", SettingsSection::Appshots),
diff --git a/crates/ui/src/shell/actions_ui.rs b/crates/ui/src/shell/actions_ui.rs
index c2b5df9358..217625c8e2 100644
--- a/crates/ui/src/shell/actions_ui.rs
+++ b/crates/ui/src/shell/actions_ui.rs
@@ -188,8 +188,14 @@ impl Shell {
         name.update(cx, |input, cx| input.set_text(draft.name, cx));
         let command = cx.new(|cx| ComposerInput::new("Command", cx));
         command.update(cx, |input, cx| input.set_text(draft.command, cx));
-        let name_events = cx.subscribe(&name, |_: &mut Shell, _, _, cx| cx.notify());
-        let command_events = cx.subscribe(&command, |_: &mut Shell, _, _, cx| cx.notify());
+        let name_events = cx.subscribe(
+            &name,
+            |_: &mut Shell, _, _: &crate::composer::ComposerInputEvent, cx| cx.notify(),
+        );
+        let command_events = cx.subscribe(
+            &command,
+            |_: &mut Shell, _, _: &crate::composer::ComposerInputEvent, cx| cx.notify(),
+        );
         self.project_actions.editor = Some(ProjectActionEditor {
             key,
             action_id,
diff --git a/crates/voice/Cargo.toml b/crates/voice/Cargo.toml
new file mode 100644
index 0000000000..0730ba7a63
--- /dev/null
+++ b/crates/voice/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "zeron-voice"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+parakeet-rs = "=0.3.8"
+cpal = "=0.17.3"
+rubato = "=0.16.2"
+reqwest.workspace = true
+tokio.workspace = true
+sha2.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+
+[dev-dependencies]
+hound = "3.5"
+tempfile.workspace = true
diff --git a/crates/voice/NOTICE.md b/crates/voice/NOTICE.md
new file mode 100644
index 0000000000..e780303383
--- /dev/null
+++ b/crates/voice/NOTICE.md
@@ -0,0 +1,17 @@
+# Parakeet v3 attribution and runtime
+
+NVIDIA Parakeet TDT 0.6B v3 weights © NVIDIA, licensed under Creative Commons Attribution 4.0 International: https://creativecommons.org/licenses/by/4.0/
+
+Original model: https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3
+Source model card inspected at revision `541d1f99c6b0c3cd0b11a95167540bb8edefd82b`.
+
+ONNX conversion by Ivan Stupakov: https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx/tree/8f23f0c03c8761650bdb5b40aaf3e40d2c15f1ce
+The conversion card identifies NVIDIA v3 as its base and documents NeMo ASRModel export and vocabulary extraction. Its exact original-weight revision and INT8 conversion tool version are not published. Zeron pins the conversion's immutable revision and SHA-256 of every consumed artifact in model.json; it does not claim independent numerical equivalence to NVIDIA's FP32 weights. The change is an INT8 ONNX conversion; no fine-tuned model is used.
+
+Runtime: parakeet-rs 0.3.8 (MIT OR Apache-2.0), ONNX Runtime 1.28.0 via ort/ort-sys 2.0.0-rc.13, CPU execution. Cargo.lock pins registry checksums and the transitive graph. ONNX Runtime is MIT licensed. Capture: cpal 0.17.3 (Apache-2.0). Sample-rate conversion: rubato 0.16.2 (MIT), using its anti-aliasing FFT resampler to convert device-rate mono audio to 16 kHz. Runtime libraries are linked into the application by ort-sys; model weights are an optional download, never bundled.
+
+TDT v3 is an offline model. Zeron records at most 60 seconds and decodes once on Stop. There are no live partial hypotheses in the production adapter. The editor's partial-result seam exists for deterministic lifecycle tests and future adapter work; it does not imply native streaming support.
+
+Supported languages: Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Spanish, Swedish, Ukrainian.
+
+Platform baseline: native CPU ONNX and CPAL on macOS, Windows, and Linux. Linux build hosts need ALSA development headers in addition to existing desktop dependencies. macOS requires a packaged app with NSMicrophoneUsageDescription and the audio-input entitlement under hardened runtime. No Apple Speech entitlement, cloud provider, Python installation, or engine-host audio transport is used. Only macOS arm64 is verified locally; other targets require their native CI/package validation.
diff --git a/crates/voice/examples/verify.rs b/crates/voice/examples/verify.rs
new file mode 100644
index 0000000000..794aa1b2f2
--- /dev/null
+++ b/crates/voice/examples/verify.rs
@@ -0,0 +1,30 @@
+use std::{path::PathBuf, sync::atomic::AtomicBool, time::Instant};
+fn main() -> anyhow::Result<()> {
+    let mut args = std::env::args().skip(1);
+    let dir = PathBuf::from(args.next().expect("model directory"));
+    if !zeron_voice::installed(&dir) {
+        zeron_voice::download(&dir, &AtomicBool::new(false), |_| {})?;
+    }
+    let start = Instant::now();
+    let mut model = zeron_voice::Recognizer::load(&dir)?;
+    println!("load_ms={}", start.elapsed().as_millis());
+    for file in args {
+        let mut wav = hound::WavReader::open(&file)?;
+        let spec = wav.spec();
+        anyhow::ensure!(
+            spec.channels == 1 && spec.bits_per_sample == 16,
+            "mono PCM16 fixture required"
+        );
+        let samples: Vec<f32> = wav
+            .samples::<i16>()
+            .map(|s| s.unwrap() as f32 / 32768.)
+            .collect();
+        let start = Instant::now();
+        let text = model.transcribe(samples, spec.sample_rate)?;
+        println!(
+            "fixture={file} inference_ms={} transcript={text:?}",
+            start.elapsed().as_millis()
+        );
+    }
+    Ok(())
+}
diff --git a/crates/voice/model.json b/crates/voice/model.json
new file mode 100644
index 0000000000..50779f63e3
--- /dev/null
+++ b/crates/voice/model.json
@@ -0,0 +1,23 @@
+{
+  "repository": "istupakov/parakeet-tdt-0.6b-v3-onnx",
+  "revision": "8f23f0c03c8761650bdb5b40aaf3e40d2c15f1ce",
+  "source": "nvidia/parakeet-tdt-0.6b-v3",
+  "license": "CC-BY-4.0",
+  "files": [
+    {
+      "name": "decoder_joint-model.int8.onnx",
+      "size": 18202004,
+      "sha256": "eea7483ee3d1a30375daedc8ed83e3960c91b098812127a0d99d1c8977667a70"
+    },
+    {
+      "name": "encoder-model.int8.onnx",
+      "size": 652183999,
+      "sha256": "6139d2fa7e1b086097b277c7149725edbab89cc7c7ae64b23c741be4055aff09"
+    },
+    {
+      "name": "vocab.txt",
+      "size": 93939,
+      "sha256": "d58544679ea4bc6ac563d1f545eb7d474bd6cfa467f0a6e2c1dc1c7d37e3c35d"
+    }
+  ]
+}
diff --git a/crates/voice/src/lib.rs b/crates/voice/src/lib.rs
new file mode 100644
index 0000000000..e475e93c2a
--- /dev/null
+++ b/crates/voice/src/lib.rs
@@ -0,0 +1,602 @@
+//! Desktop-local Parakeet v3. No engine, document, RPC or audio persistence.
+use anyhow::{Context, Result, bail};
+use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use parakeet_rs::{ParakeetTDT, Transcriber};
+use sha2::{Digest, Sha256};
+use std::{
+    io::Write,
+    path::Path,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, AtomicU32, Ordering},
+    },
+};
+
+mod resample;
+
+pub const MAX_SECONDS: usize = 60;
+#[derive(serde::Deserialize)]
+pub struct Artifact {
+    pub name: String,
+    pub size: u64,
+    pub sha256: String,
+}
+#[derive(serde::Deserialize)]
+pub struct Manifest {
+    pub repository: String,
+    pub revision: String,
+    pub files: Vec<Artifact>,
+}
+pub fn manifest() -> Manifest {
+    serde_json::from_str(include_str!("../model.json")).expect("pinned model manifest")
+}
+pub fn download_size() -> u64 {
+    manifest().files.iter().map(|f| f.size).sum()
+}
+pub fn installed(dir: &Path) -> bool {
+    manifest()
+        .files
+        .iter()
+        .all(|f| std::fs::metadata(dir.join(&f.name)).is_ok_and(|m| m.len() == f.size))
+        && std::fs::read_to_string(dir.join("verified")).is_ok_and(|r| r == manifest().revision)
+}
+
+/// Called only on a worker. Temporary files never establish readiness.
+pub fn download(dir: &Path, cancel: &AtomicBool, mut progress: impl FnMut(u64)) -> Result<()> {
+    tokio::runtime::Builder::new_current_thread().enable_all().build()?.block_on(async {
+        std::fs::create_dir_all(dir)?;
+        let client = reqwest::Client::builder().connect_timeout(std::time::Duration::from_secs(20)).build()?;
+        let m=manifest(); let mut total=0;
+        for file in m.files {
+            if cancel.load(Ordering::Acquire) { bail!("Download cancelled") }
+            let staging=dir.join(format!("{}.part",file.name));
+            let result=async {
+                let mut response=tokio::select! {
+                    _=cancelled(cancel)=>bail!("Download cancelled"),
+                    response=tokio::time::timeout(std::time::Duration::from_secs(30),client.get(format!("https://huggingface.co/{}/resolve/{}/{}",m.repository,m.revision,file.name)).send())=>response??.error_for_status()?,
+                };
+                let mut out=std::fs::File::create(&staging)?;let mut hash=Sha256::new();let mut size=0;
+                loop {
+                    let chunk=tokio::select! {
+                        _=cancelled(cancel)=>bail!("Download cancelled"),
+                        chunk=tokio::time::timeout(std::time::Duration::from_secs(30),response.chunk())=>chunk??,
+                    };
+                    let Some(chunk)=chunk else {break};
+                    size+=chunk.len() as u64;if size>file.size {bail!("Unexpected model size")}
+                    hash.update(&chunk);out.write_all(&chunk)?;total+=chunk.len() as u64;progress(total);
+                }
+                if size!=file.size || format!("{:x}",hash.finalize())!=file.sha256 {bail!("Model checksum verification failed")}
+                out.sync_all()?;std::fs::rename(&staging,dir.join(&file.name))?;Ok::<_,anyhow::Error>(())
+            }.await;
+            if result.is_err() {let _=std::fs::remove_file(staging);} result?;
+        }
+        if cancel.load(Ordering::Acquire) {bail!("Download cancelled")}
+        std::fs::write(dir.join("verified"),manifest().revision)?;Ok(())
+    })
+}
+async fn cancelled(cancel: &AtomicBool) {
+    while !cancel.load(Ordering::Acquire) {
+        tokio::time::sleep(std::time::Duration::from_millis(40)).await;
+    }
+}
+
+pub struct Recognizer(ParakeetTDT);
+impl Recognizer {
+    pub fn load(dir: &Path) -> Result<Self> {
+        // Verify before handing bytes to the native runtime, including after restart.
+        for f in manifest().files {
+            let mut input = std::fs::File::open(dir.join(&f.name))?;
+            let mut hash = Sha256::new();
+            std::io::copy(&mut input, &mut hash)?;
+            if format!("{:x}", hash.finalize()) != f.sha256 {
+                bail!("Model is damaged. Remove it in Settings and download again.")
+            }
+        }
+        Ok(Self(ParakeetTDT::from_pretrained(dir, None).map_err(
+            |_| anyhow::anyhow!("Could not load Parakeet v3"),
+        )?))
+    }
+    pub fn transcribe(&mut self, samples: Vec<f32>, rate: u32) -> Result<String> {
+        if !(8_000..=192_000).contains(&rate) {
+            bail!("Unsupported microphone sample rate")
+        }
+        if samples.len() > rate as usize * MAX_SECONDS {
+            bail!("Recording exceeds one minute")
+        }
+        if samples.len() < rate as usize / 5 || samples.iter().all(|s| s.abs() < 0.0001) {
+            return Ok(String::new());
+        }
+        let samples = resample::for_model(samples, rate)?;
+        self.0
+            .transcribe_samples(samples, resample::MODEL_RATE, 1, None)
+            .map(|r| r.text)
+            .map_err(|_| anyhow::anyhow!("Could not transcribe this recording"))
+    }
+}
+
+struct Audio {
+    /// Only the audio callback touches this until the stream is dropped.
+    samples: Mutex<Vec<f32>>,
+    // Outside the lock: the capture loop polls these every 10 ms and must
+    // never make the real-time callback's `try_lock` drop a buffer.
+    failed: AtomicBool,
+    full: AtomicBool,
+}
+impl Audio {
+    fn with_capacity(capacity: usize) -> Self {
+        Self {
+            samples: Mutex::new(Vec::with_capacity(capacity)),
+            failed: AtomicBool::new(false),
+            full: AtomicBool::new(false),
+        }
+    }
+}
+/// Loudest RMS since the UI last read it. Non-negative `f32` bit patterns sort
+/// like their values, so `fetch_max` keeps the peak without a lock.
+fn meter<T: cpal::Sample>(data: &[T], channels: usize, level: &AtomicU32)
+where
+    f32: cpal::FromSample<T>,
+{
+    let frames = data.len() / channels.max(1);
+    if frames == 0 {
+        return;
+    }
+    let energy = data
+        .chunks_exact(channels)
+        .map(|frame| {
+            let s = frame.iter().map(|s| s.to_sample::<f32>()).sum::<f32>() / channels as f32;
+            s * s
+        })
+        .sum::<f32>();
+    let rms = (energy / frames as f32).sqrt();
+    if rms.is_finite() {
+        level.fetch_max(rms.to_bits(), Ordering::Relaxed);
+    }
+}
+fn append<T: cpal::Sample>(data: &[T], channels: usize, rate: u32, a: &Audio)
+where
+    f32: cpal::FromSample<T>,
+{
+    if let Ok(mut samples) = a.samples.try_lock() {
+        for frame in data.chunks_exact(channels) {
+            if samples.len() >= rate as usize * MAX_SECONDS {
+                a.full.store(true, Ordering::Release);
+                break;
+            }
+            samples.push(frame.iter().map(|s| s.to_sample::<f32>()).sum::<f32>() / channels as f32);
+        }
+    }
+}
+/// A microphone the user can choose: a stable identifier and a display name.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InputDevice {
+    pub id: String,
+    pub name: String,
+}
+
+/// Every input device the default host reports. Enumeration can block on the
+/// audio server, so call it off the UI thread.
+pub fn input_devices() -> Vec<InputDevice> {
+    let Ok(devices) = cpal::default_host().input_devices() else {
+        return Vec::new();
+    };
+    let mut devices: Vec<_> = devices
+        .filter_map(|device| {
+            Some(InputDevice {
+                id: device.id().ok()?.to_string(),
+                name: device.description().ok()?.name().to_owned(),
+            })
+        })
+        .collect();
+    devices.dedup_by(|a, b| a.id == b.id);
+    devices
+}
+
+/// The id of the device the system currently records from by default.
+pub fn default_input_device() -> Option<String> {
+    Some(
+        cpal::default_host()
+            .default_input_device()?
+            .id()
+            .ok()?
+            .to_string(),
+    )
+}
+
+/// The chosen device when it is connected, the system default otherwise.
+fn input_device(id: Option<&str>) -> Option<cpal::Device> {
+    let host = cpal::default_host();
+    id.and_then(|id| id.parse::<cpal::DeviceId>().ok())
+        .and_then(|id| host.device_by_id(&id))
+        .or_else(|| host.default_input_device())
+}
+
+pub struct Capture {
+    stream: Option<cpal::Stream>,
+    audio: Arc<Audio>,
+    rate: u32,
+}
+impl Capture {
+    pub fn start(device: Option<&str>, level: Arc<AtomicU32>) -> Result<Self> {
+        let device = input_device(device).context("No microphone available")?;
+        let config = device.default_input_config()?;
+        let rate = config.sample_rate();
+        let channels = config.channels() as usize;
+        let audio = Arc::new(Audio::with_capacity(rate as usize * MAX_SECONDS));
+        let a = audio.clone();
+        let e = audio.clone();
+        let err = move |_| e.failed.store(true, Ordering::Release);
+        // Preserve the device's native configuration; convert every CPAL
+        // sample representation through the same bounded mono callback.
+        macro_rules! stream {
+            ($sample:ty) => {
+                device.build_input_stream(
+                    &config.into(),
+                    move |d: &[$sample], _| {
+                        meter(d, channels, &level);
+                        append(d, channels, rate, &a)
+                    },
+                    err,
+                    None,
+                )?
+            };
+        }
+        let stream = match config.sample_format() {
+            cpal::SampleFormat::I8 => stream!(i8),
+            cpal::SampleFormat::I16 => stream!(i16),
+            cpal::SampleFormat::I24 => stream!(cpal::I24),
+            cpal::SampleFormat::I32 => stream!(i32),
+            cpal::SampleFormat::I64 => stream!(i64),
+            cpal::SampleFormat::U8 => stream!(u8),
+            cpal::SampleFormat::U16 => stream!(u16),
+            cpal::SampleFormat::U24 => stream!(cpal::U24),
+            cpal::SampleFormat::U32 => stream!(u32),
+            cpal::SampleFormat::U64 => stream!(u64),
+            cpal::SampleFormat::F32 => stream!(f32),
+            cpal::SampleFormat::F64 => stream!(f64),
+            _ => bail!("Unsupported microphone format"),
+        };
+        stream.play()?;
+        Ok(Self {
+            stream: Some(stream),
+            audio,
+            rate,
+        })
+    }
+    pub fn ended(&self) -> bool {
+        self.audio.full.load(Ordering::Acquire) || self.audio.failed.load(Ordering::Acquire)
+    }
+    pub fn finish(mut self) -> Result<(Vec<f32>, u32)> {
+        self.stream.take();
+        if self.audio.failed.load(Ordering::Acquire) {
+            bail!("Microphone disconnected. Your draft is safe.")
+        }
+        let mut samples = self.audio.samples.lock().unwrap_or_else(|e| e.into_inner());
+        Ok((std::mem::take(&mut *samples), self.rate))
+    }
+}
+
+#[derive(Debug)]
+pub enum Event {
+    Listening,
+    Finalizing,
+    Final(String),
+    Failed(String),
+}
+struct Job {
+    dir: std::path::PathBuf,
+    stop: Arc<AtomicBool>,
+    cancel: Arc<AtomicBool>,
+    level: Arc<AtomicU32>,
+    device: Option<String>,
+    events: std::sync::mpsc::SyncSender<Event>,
+}
+// Capture owns its stream on a separate thread. Model loading and inference
+// remain serialized on WORKER, including after the user cancels native work.
+trait Recording {
+    fn ended(&self) -> bool;
+    fn finish(self) -> Result<(Vec<f32>, u32)>;
+}
+impl Recording for Capture {
+    fn ended(&self) -> bool {
+        self.ended()
+    }
+    fn finish(self) -> Result<(Vec<f32>, u32)> {
+        self.finish()
+    }
+}
+
+fn record<C: Recording>(
+    job: &Job,
+    start: impl FnOnce() -> Result<C>,
+) -> Result<Option<(Vec<f32>, u32)>> {
+    if job.cancel.load(Ordering::Acquire) || job.stop.load(Ordering::Acquire) {
+        return Ok(None);
+    }
+    let capture = start()?;
+    // Stop/cancel may arrive while the audio device is opening.
+    if job.cancel.load(Ordering::Acquire) {
+        return Ok(None);
+    }
+    if !job.stop.load(Ordering::Acquire) {
+        let _ = job.events.try_send(Event::Listening);
+    }
+    let started = std::time::Instant::now();
+    while !job.stop.load(Ordering::Acquire)
+        && !job.cancel.load(Ordering::Acquire)
+        && !capture.ended()
+        && started.elapsed().as_secs() < MAX_SECONDS as u64
+    {
+        std::thread::sleep(std::time::Duration::from_millis(10));
+    }
+    if job.cancel.load(Ordering::Acquire) {
+        return Ok(None);
+    }
+    let audio = capture.finish()?; // Close the microphone before waiting for the model.
+    let _ = job.events.try_send(Event::Finalizing);
+    Ok(Some(audio))
+}
+
+fn run_job<C, F>(
+    job: &Job,
+    start: impl FnOnce() -> Result<C> + Send,
+    load: impl FnOnce() -> Result<F>,
+) -> Result<Option<String>>
+where
+    C: Recording,
+    F: FnOnce(Vec<f32>, u32) -> Result<String>,
+{
+    if job.cancel.load(Ordering::Acquire) {
+        return Ok(None);
+    }
+    std::thread::scope(|scope| {
+        let capture = std::thread::Builder::new()
+            .name("dictation-capture".into())
+            .spawn_scoped(scope, || record(job, start))?;
+        // If native loading unwinds, scope teardown still has to close capture
+        // before joining it. Normal cancellation uses the same signal.
+        struct CancelOnDrop<'a>(&'a AtomicBool);
+        impl Drop for CancelOnDrop<'_> {
+            fn drop(&mut self) {
+                self.0.store(true, Ordering::Release);
+            }
+        }
+        let _close_capture = CancelOnDrop(&job.cancel);
+        let model = load();
+        // A load failure must stop capture even if the user has not pressed Stop.
+        // Keep the admission guard until the stream has actually been dropped.
+        if model.is_err() {
+            job.cancel.store(true, Ordering::Release);
+        }
+        let audio = capture
+            .join()
+            .map_err(|_| anyhow::anyhow!("Microphone worker failed"))?;
+        let transcribe = model?;
+        if job.cancel.load(Ordering::Acquire) {
+            return Ok(None);
+        }
+        let Some((samples, rate)) = audio? else {
+            return Ok(Some(String::new()));
+        };
+        let text = transcribe(samples, rate)?;
+        Ok((!job.cancel.load(Ordering::Acquire)).then_some(text))
+    })
+}
+
+static BUSY: AtomicBool = AtomicBool::new(false);
+// The command owns admission through capture teardown and uninterruptible
+// native work. Queue failure also releases it, so rapid retries cannot wedge it.
+struct BusyGuard;
+impl BusyGuard {
+    fn acquire() -> Result<Self> {
+        if BUSY
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed)
+            .is_err()
+        {
+            bail!("Dictation is still active or finishing. Wait a moment, then try again.")
+        }
+        Ok(Self)
+    }
+}
+impl Drop for BusyGuard {
+    fn drop(&mut self) {
+        BUSY.store(false, Ordering::Release);
+    }
+}
+enum Command {
+    Transcribe(Job, BusyGuard),
+    Unload,
+}
+static WORKER: std::sync::OnceLock<std::sync::mpsc::SyncSender<Command>> =
+    std::sync::OnceLock::new();
+pub struct Session {
+    stop: Arc<AtomicBool>,
+    cancel: Arc<AtomicBool>,
+    level: Arc<AtomicU32>,
+    events: std::sync::mpsc::Receiver<Event>,
+}
+impl Session {
+    /// `device` is an [`InputDevice::id`]; `None` or a disconnected device
+    /// records from the system default.
+    pub fn start(dir: std::path::PathBuf, device: Option<String>) -> Result<Self> {
+        let admission = BusyGuard::acquire()?;
+        let sender = WORKER.get_or_init(|| {
+            let (tx, rx) = std::sync::mpsc::sync_channel::<Command>(1);
+            std::thread::spawn(move || {
+                let mut cached: Option<(std::path::PathBuf, Recognizer)> = None;
+                loop {
+                    let (job, _admission) = match rx.recv_timeout(std::time::Duration::from_secs(30)) {
+                        Ok(Command::Transcribe(j, admission)) => (j, admission),
+                        Ok(Command::Unload) => {
+                            cached = None;
+                            continue;
+                        }
+                        Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                            cached = None;
+                            continue;
+                        }
+                        Err(_) => break,
+                    };
+                    // A native panic must not take down the worker, and with
+                        // it every later session, until the app restarts.
+                    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| run_job(
+                        &job,
+                        || Capture::start(job.device.as_deref(), job.level.clone()),
+                        || {
+                            if cached.as_ref().is_none_or(|(path, _)| *path != job.dir) {
+                                let model = Recognizer::load(&job.dir).context(
+                                    "Could not load the model. Remove it in Settings and download again.",
+                                )?;
+                                cached = Some((job.dir.clone(), model));
+                            }
+                            let model = &mut cached.as_mut().unwrap().1;
+                            Ok(move |samples, rate| model.transcribe(samples, rate))
+                        },
+                    )))
+                    .unwrap_or_else(|_| {
+                        cached = None;
+                        Err(anyhow::anyhow!("Dictation stopped unexpectedly. Your draft is safe."))
+                    });
+                    match result {
+                        Ok(Some(text)) => {
+                            let _ = job.events.try_send(Event::Final(text));
+                        }
+                        Ok(None) => {}
+                        // Keep loaded weights: a microphone or recording error says
+                        // nothing about the model, and reloading takes seconds.
+                        Err(e) => {
+                            let _ = job.events.try_send(Event::Failed(e.to_string()));
+                        }
+                    }
+                }
+            });
+            tx
+        });
+        let stop = Arc::new(AtomicBool::new(false));
+        let cancel = Arc::new(AtomicBool::new(false));
+        let level = Arc::new(AtomicU32::new(0));
+        let (tx, events) = std::sync::mpsc::sync_channel(4);
+        if sender
+            .try_send(Command::Transcribe(
+                Job {
+                    dir,
+                    stop: stop.clone(),
+                    cancel: cancel.clone(),
+                    level: level.clone(),
+                    device,
+                    events: tx,
+                },
+                admission,
+            ))
+            .is_err()
+        {
+            bail!("Dictation worker unavailable")
+        }
+        Ok(Self {
+            stop,
+            cancel,
+            level,
+            events,
+        })
+    }
+    pub fn poll(&mut self) -> Option<Event> {
+        self.events.try_recv().ok()
+    }
+    pub fn finish(&mut self) {
+        self.stop.store(true, Ordering::Release);
+    }
+    /// Peak microphone RMS (0–1) since the previous call. Level only; the
+    /// samples themselves stay on the worker.
+    pub fn take_level(&self) -> f32 {
+        f32::from_bits(self.level.swap(0, Ordering::Relaxed))
+    }
+}
+impl Drop for Session {
+    fn drop(&mut self) {
+        self.cancel.store(true, Ordering::Release);
+    }
+}
+pub fn busy() -> bool {
+    BUSY.load(Ordering::Acquire)
+}
+
+/// Retire cached weights on the worker, never on the UI thread.
+pub fn unload() {
+    if let Some(worker) = WORKER.get() {
+        let _ = worker.try_send(Command::Unload);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cpal::Sample;
+    #[test]
+    fn native_sample_formats_preserve_levels_and_downmix_channels() {
+        fn check<T: cpal::Sample + cpal::FromSample<f32>>()
+        where
+            f32: cpal::FromSample<T>,
+        {
+            let audio = Audio::with_capacity(0);
+            let input: Vec<T> = [-0.5_f32, 0.5, 0.25, 0.75, 0.0, 0.0]
+                .into_iter()
+                .map(|s| s.to_sample::<T>())
+                .collect();
+            append(&input, 2, 16_000, &audio);
+            assert_eq!(*audio.samples.lock().unwrap(), vec![0.0, 0.5, 0.0]);
+            let level = AtomicU32::new(0);
+            meter(&input, 2, &level);
+            let rms = f32::from_bits(level.load(Ordering::Relaxed));
+            assert!((rms - (0.25_f32 / 3.0).sqrt()).abs() < 0.01, "{rms}");
+            meter(&input[4..], 2, &level);
+            assert_eq!(f32::from_bits(level.load(Ordering::Relaxed)), rms);
+        }
+        check::<i8>();
+        check::<i16>();
+        check::<cpal::I24>();
+        check::<i32>();
+        check::<i64>();
+        check::<u8>();
+        check::<u16>();
+        check::<cpal::U24>();
+        check::<u32>();
+        check::<u64>();
+        check::<f32>();
+        check::<f64>();
+    }
+    #[test]
+    fn manifest_pins_only_v3_artifacts_and_exact_size() {
+        let m = manifest();
+        assert_eq!(m.revision.len(), 40);
+        assert_eq!(m.files.len(), 3);
+        assert_eq!(download_size(), 670479942);
+        assert!(
+            m.files
+                .iter()
+                .all(|f| f.sha256.len() == 64 && !f.name.contains('/'))
+        );
+    }
+    #[test]
+    fn cancelled_download_never_establishes_readiness() {
+        let dir = tempfile::tempdir().unwrap();
+        assert!(
+            download(dir.path(), &AtomicBool::new(true), |_| panic!(
+                "no progress after cancellation"
+            ))
+            .is_err()
+        );
+        assert!(!installed(dir.path()));
+        assert_eq!(std::fs::read_dir(dir.path()).unwrap().count(), 0);
+    }
+    #[test]
+    fn partial_or_corrupt_model_cannot_load() {
+        let dir = tempfile::tempdir().unwrap();
+        let f = &manifest().files[0];
+        std::fs::write(dir.path().join(&f.name), b"corrupt").unwrap();
+        assert!(!installed(dir.path()));
+        assert!(Recognizer::load(dir.path()).is_err());
+    }
+}
+
+#[cfg(test)]
+mod session_tests;
diff --git a/crates/voice/src/resample.rs b/crates/voice/src/resample.rs
new file mode 100644
index 0000000000..c483c6550c
--- /dev/null
+++ b/crates/voice/src/resample.rs
@@ -0,0 +1,81 @@
+//! Convert device-rate mono capture to the model's 16 kHz input on the worker.
+use anyhow::{Result, ensure};
+use rubato::{FftFixedInOut, Resampler};
+
+pub(crate) const MODEL_RATE: u32 = 16_000;
+
+pub(crate) fn for_model(samples: Vec<f32>, rate: u32) -> Result<Vec<f32>> {
+    ensure!(
+        (8_000..=192_000).contains(&rate),
+        "Unsupported microphone sample rate"
+    );
+    if rate == MODEL_RATE || samples.is_empty() {
+        return Ok(samples);
+    }
+    let length = (samples.len() as u64 * MODEL_RATE as u64 / rate as u64) as usize;
+    let mut resampler = FftFixedInOut::<f32>::new(rate as usize, MODEL_RATE as usize, 1024, 1)?;
+    let delay = resampler.output_delay();
+    let chunk = resampler.input_frames_next();
+    let mut input = vec![vec![0.0; chunk]];
+    let mut output = resampler.output_buffer_allocate(true);
+    let mut converted = Vec::with_capacity(length + delay + resampler.output_frames_max());
+    let mut offset = 0;
+    // Zero padding also flushes the filter tail. Remove its delay so short
+    // utterances keep both their beginning and end and retain their duration.
+    while converted.len() < length + delay {
+        input[0].fill(0.0);
+        let end = (offset + chunk).min(samples.len());
+        if offset < end {
+            input[0][..end - offset].copy_from_slice(&samples[offset..end]);
+        }
+        let (_, written) = resampler.process_into_buffer(&input, &mut output, None)?;
+        converted.extend_from_slice(&output[0][..written]);
+        offset = end;
+    }
+    converted.drain(..delay);
+    converted.truncate(length);
+    Ok(converted)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn tone(rate: u32, hz: f32) -> Vec<f32> {
+        (0..rate)
+            .map(|i| (std::f32::consts::TAU * hz * i as f32 / rate as f32).sin())
+            .collect()
+    }
+    fn rms(samples: &[f32]) -> f32 {
+        (samples.iter().map(|s| s * s).sum::<f32>() / samples.len() as f32).sqrt()
+    }
+    #[test]
+    fn device_rates_preserve_duration_and_speech_band() {
+        for rate in [8_000, 16_000, 24_000, 44_100, 48_000, 96_000] {
+            let converted = for_model(tone(rate, 1_000.0), rate).unwrap();
+            assert_eq!(converted.len(), MODEL_RATE as usize, "{rate}");
+            // FFT filtering can leave a fractional-sample phase offset at
+            // noninteger ratios. Assert frequency and amplitude, not phase.
+            let steady = &converted[1000..15000];
+            let cycles = steady
+                .windows(2)
+                .filter(|w| w[0] <= 0.0 && w[1] > 0.0)
+                .count();
+            assert!((874..=876).contains(&cycles), "{rate}: {cycles}");
+            assert!(
+                (rms(steady) - std::f32::consts::FRAC_1_SQRT_2).abs() < 0.01,
+                "{rate}"
+            );
+        }
+    }
+    #[test]
+    fn downsampling_filters_frequencies_above_model_nyquist() {
+        let converted = for_model(tone(48_000, 12_000.0), 48_000).unwrap();
+        assert!(rms(&converted[1000..15000]) < 0.01);
+    }
+    #[test]
+    fn short_capture_and_invalid_rates_are_bounded() {
+        assert_eq!(for_model(vec![0.0; 147], 44_100).unwrap().len(), 53);
+        assert!(for_model(Vec::new(), 48_000).unwrap().is_empty());
+        assert!(for_model(vec![1.0], 0).is_err());
+    }
+}
diff --git a/crates/voice/src/session_tests.rs b/crates/voice/src/session_tests.rs
new file mode 100644
index 0000000000..a2c239b758
--- /dev/null
+++ b/crates/voice/src/session_tests.rs
@@ -0,0 +1,298 @@
+//! Deterministic barriers exercise the production capture/loading coordinator.
+use super::*;
+use std::{
+    sync::mpsc::{self, Receiver, SyncSender},
+    thread::JoinHandle,
+    time::Duration,
+};
+
+const WAIT: Duration = Duration::from_secs(5);
+
+struct FakeCapture {
+    closed: SyncSender<()>,
+    ended: Arc<AtomicBool>,
+}
+impl Recording for FakeCapture {
+    fn ended(&self) -> bool {
+        self.ended.load(Ordering::Acquire)
+    }
+    fn finish(self) -> Result<(Vec<f32>, u32)> {
+        Ok((vec![0.25; 3200], 16_000))
+    }
+}
+impl Drop for FakeCapture {
+    fn drop(&mut self) {
+        self.closed.try_send(()).unwrap();
+    }
+}
+
+struct Fixture {
+    session: Session,
+    load: SyncSender<Result<()>>,
+    closed: Receiver<()>,
+    ended: Arc<AtomicBool>,
+    result: Receiver<Result<Option<String>>>,
+    worker: JoinHandle<()>,
+}
+impl Fixture {
+    fn new(open: Option<(Receiver<()>, SyncSender<()>)>) -> Self {
+        Self::with_admission(open, None)
+    }
+    fn with_admission(
+        open: Option<(Receiver<()>, SyncSender<()>)>,
+        admission: Option<BusyGuard>,
+    ) -> Self {
+        let (events_tx, events) = mpsc::sync_channel(4);
+        let stop = Arc::new(AtomicBool::new(false));
+        let cancel = Arc::new(AtomicBool::new(false));
+        let level = Arc::new(AtomicU32::new(0));
+        let job = Job {
+            dir: Default::default(),
+            stop: stop.clone(),
+            cancel: cancel.clone(),
+            level: level.clone(),
+            device: None,
+            events: events_tx,
+        };
+        let (load, ready) = mpsc::sync_channel::<Result<()>>(1);
+        let (loading, started) = mpsc::sync_channel(1);
+        let (closed_tx, closed) = mpsc::sync_channel(1);
+        let (result_tx, result) = mpsc::sync_channel(1);
+        let ended = Arc::new(AtomicBool::new(false));
+        let end_capture = ended.clone();
+        let worker = std::thread::spawn(move || {
+            let _admission = admission;
+            let outcome = run_job(
+                &job,
+                || {
+                    if let Some((open, opening)) = open {
+                        opening.send(()).unwrap();
+                        open.recv_timeout(WAIT).unwrap();
+                    }
+                    Ok(FakeCapture {
+                        closed: closed_tx,
+                        ended: end_capture,
+                    })
+                },
+                || {
+                    loading.send(()).unwrap();
+                    ready.recv_timeout(WAIT).unwrap()?;
+                    Ok(|samples, rate| {
+                        // Stop during load must retain the exact recording.
+                        assert_eq!(samples, vec![0.25; 3200]);
+                        assert_eq!(rate, 16_000);
+                        Ok("retained speech".into())
+                    })
+                },
+            );
+            result_tx.send(outcome).unwrap();
+        });
+        started.recv_timeout(WAIT).unwrap();
+        Self {
+            session: Session {
+                stop,
+                cancel,
+                level,
+                events,
+            },
+            load,
+            closed,
+            ended,
+            result,
+            worker,
+        }
+    }
+    fn listening(&self) {
+        assert!(matches!(
+            self.session.events.recv_timeout(WAIT).unwrap(),
+            Event::Listening
+        ));
+    }
+    fn release(self, result: Result<()>) -> Result<Option<String>> {
+        self.load.send(result).unwrap();
+        let result = self.result.recv_timeout(WAIT).unwrap();
+        self.worker.join().unwrap();
+        result
+    }
+}
+
+#[test]
+fn listening_and_stop_do_not_wait_for_model_and_audio_is_retained() {
+    let mut f = Fixture::new(None);
+    f.listening();
+    assert!(f.result.try_recv().is_err());
+    f.session.finish();
+    f.session.finish(); // Repeated Stop is idempotent.
+    f.closed.recv_timeout(WAIT).unwrap();
+    assert!(matches!(
+        f.session.events.recv_timeout(WAIT).unwrap(),
+        Event::Finalizing
+    ));
+    assert!(f.result.try_recv().is_err());
+    assert_eq!(
+        f.release(Ok(())).unwrap().as_deref(),
+        Some("retained speech")
+    );
+}
+
+#[test]
+fn cancel_during_load_closes_microphone_without_waiting_for_model() {
+    let f = Fixture::new(None);
+    f.listening();
+    // Exercise the real Session destructor, including after Stop.
+    let Fixture {
+        session,
+        load,
+        closed,
+        result,
+        worker,
+        ..
+    } = f;
+    drop(session);
+    closed.recv_timeout(WAIT).unwrap();
+    assert!(result.try_recv().is_err());
+    load.send(Ok(())).unwrap();
+    assert_eq!(result.recv_timeout(WAIT).unwrap().unwrap(), None);
+    worker.join().unwrap();
+}
+
+#[test]
+fn cancel_after_stop_during_load_discards_retained_audio() {
+    let mut f = Fixture::new(None);
+    f.listening();
+    f.session.finish();
+    f.closed.recv_timeout(WAIT).unwrap();
+    f.session.cancel.store(true, Ordering::Release);
+    assert_eq!(f.release(Ok(())).unwrap(), None);
+}
+
+#[test]
+fn load_failure_closes_live_microphone_before_returning_error() {
+    let f = Fixture::new(None);
+    f.listening();
+    f.load
+        .send(Err(anyhow::anyhow!("model removed or corrupt")))
+        .unwrap();
+    assert!(f.result.recv_timeout(WAIT).unwrap().is_err());
+    // Closure is guaranteed before the caller can report Failed/release BUSY.
+    f.closed.try_recv().unwrap();
+    f.worker.join().unwrap();
+}
+
+#[test]
+fn listening_is_not_emitted_until_device_opens_and_stop_during_open_is_safe() {
+    let (open, opened) = mpsc::sync_channel(1);
+    let (opening, started) = mpsc::sync_channel(1);
+    let mut f = Fixture::new(Some((opened, opening)));
+    started.recv_timeout(WAIT).unwrap();
+    assert!(f.session.poll().is_none());
+    f.session.finish();
+    open.send(()).unwrap();
+    f.closed.recv_timeout(WAIT).unwrap();
+    assert!(matches!(
+        f.session.events.recv_timeout(WAIT).unwrap(),
+        Event::Finalizing
+    ));
+    assert!(f.session.poll().is_none());
+    assert_eq!(
+        f.release(Ok(())).unwrap().as_deref(),
+        Some("retained speech")
+    );
+}
+
+#[test]
+fn recording_limit_closes_capture_while_model_is_still_loading() {
+    let f = Fixture::new(None);
+    f.listening();
+    f.ended.store(true, Ordering::Release);
+    f.closed.recv_timeout(WAIT).unwrap();
+    assert!(matches!(
+        f.session.events.recv_timeout(WAIT).unwrap(),
+        Event::Finalizing
+    ));
+    assert!(f.result.try_recv().is_err());
+    assert_eq!(
+        f.release(Ok(())).unwrap().as_deref(),
+        Some("retained speech")
+    );
+}
+
+#[test]
+fn cancelled_load_keeps_start_and_model_removal_guarded_until_native_work_returns() {
+    let f = Fixture::with_admission(None, Some(BusyGuard::acquire().unwrap()));
+    f.listening();
+    f.session.cancel.store(true, Ordering::Release);
+    f.closed.recv_timeout(WAIT).unwrap();
+    assert!(busy(), "Settings must refuse model removal during loading");
+    assert!(Session::start(Default::default(), None).is_err());
+    assert_eq!(f.release(Ok(())).unwrap(), None);
+    assert!(!busy());
+    // Admission is reusable and releases even when a queued command is dropped.
+    let (tx, rx) = mpsc::sync_channel(1);
+    tx.send(BusyGuard::acquire().unwrap()).unwrap();
+    drop(rx);
+    assert!(!busy());
+}
+
+#[test]
+fn stop_before_capture_start_never_opens_the_microphone() {
+    let (events, _) = mpsc::sync_channel(4);
+    let job = Job {
+        dir: Default::default(),
+        stop: Arc::new(AtomicBool::new(true)),
+        cancel: Arc::new(AtomicBool::new(false)),
+        level: Arc::new(AtomicU32::new(0)),
+        device: None,
+        events,
+    };
+    let result = run_job::<FakeCapture, _>(
+        &job,
+        || panic!("microphone must not open"),
+        || Ok(|_, _| -> Result<String> { panic!("no audio to transcribe") }),
+    )
+    .unwrap();
+    assert_eq!(result.as_deref(), Some(""));
+}
+
+#[test]
+fn cancel_during_device_open_does_not_emit_listening_or_transcribe() {
+    let (open, opened) = mpsc::sync_channel(1);
+    let (opening, started) = mpsc::sync_channel(1);
+    let mut f = Fixture::new(Some((opened, opening)));
+    started.recv_timeout(WAIT).unwrap();
+    f.session.cancel.store(true, Ordering::Release);
+    open.send(()).unwrap();
+    f.closed.recv_timeout(WAIT).unwrap();
+    assert!(f.session.poll().is_none());
+    assert_eq!(f.release(Ok(())).unwrap(), None);
+}
+
+#[test]
+fn ready_model_waits_for_stop_and_transcribes_only_once() {
+    let mut f = Fixture::new(None);
+    f.listening();
+    f.load.send(Ok(())).unwrap();
+    assert!(f.result.try_recv().is_err());
+    f.session.finish();
+    f.session.finish();
+    assert_eq!(
+        f.result.recv_timeout(WAIT).unwrap().unwrap().as_deref(),
+        Some("retained speech")
+    );
+    f.closed.try_recv().unwrap();
+    f.worker.join().unwrap();
+}
+
+#[test]
+fn audio_buffer_still_caps_recording_at_sixty_seconds() {
+    let audio = Audio::with_capacity(0);
+    let rate = 8_000;
+    append(
+        &vec![0.25_f32; rate as usize * MAX_SECONDS + 1],
+        1,
+        rate,
+        &audio,
+    );
+    assert_eq!(audio.samples.lock().unwrap().len(), rate as usize * 60);
+    assert!(audio.full.load(Ordering::Acquire));
+}
diff --git a/dist/macos/Dictation.entitlements b/dist/macos/Dictation.entitlements
new file mode 100644
index 0000000000..b196d6ac6e
--- /dev/null
+++ b/dist/macos/Dictation.entitlements
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict><key>com.apple.security.device.audio-input</key><true/></dict></plist>
diff --git a/dist/macos/Info-dev.plist b/dist/macos/Info-dev.plist
index e660ad9911..8a01666242 100644
--- a/dist/macos/Info-dev.plist
+++ b/dist/macos/Info-dev.plist
@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+  <key>NSMicrophoneUsageDescription</key>
+  <string>Dictate into your draft using on-device Parakeet transcription.</string>
     <key>CFBundleDevelopmentRegion</key>
     <string>en</string>
     <key>CFBundleDisplayName</key>
diff --git a/dist/macos/Info.plist b/dist/macos/Info.plist
index 692231fce8..62b4052bda 100644
--- a/dist/macos/Info.plist
+++ b/dist/macos/Info.plist
@@ -4,6 +4,8 @@
      bundling steps. Replace __VERSION__ before packaging. -->
 <plist version="1.0">
 <dict>
+  <key>NSMicrophoneUsageDescription</key>
+  <string>Dictate into your draft using on-device Parakeet transcription.</string>
     <key>CFBundleDevelopmentRegion</key>
     <string>en</string>
     <key>CFBundleDisplayName</key>
diff --git a/docs/design/desktop-parakeet-v3.md b/docs/design/desktop-parakeet-v3.md
new file mode 100644
index 0000000000..0b2ba1ef17
--- /dev/null
+++ b/docs/design/desktop-parakeet-v3.md
@@ -0,0 +1,17 @@
+# Desktop Parakeet v3 dictation
+
+Authorized implementation brief: `/Users/gaelcado/zeron/evidence/voice/desktop-parakeet-v3-handoff-2026-09-27.md`.
+
+Dictation is device-local and opt-in. Settings → Voice provides the optional model download, microphone selection, privacy notice and lifecycle actions; supported languages are documented in the desktop dictation reference. A microphone beside the composer utilities starts/stops recording; a rebindable composer shortcut uses the existing keymap. Stop inserts an editable transcription; only explicit Send/Queue can submit.
+
+Use a pinned native Rust ONNX adapter for NVIDIA Parakeet TDT 0.6B v3, with a checksummed, pinned upstream conversion downloaded separately. CPU execution provides a common desktop baseline. Capture and inference remain outside the engine, RPC, documents and sync. Audio is bounded and transient. Model downloads use staging and checksum verification before activation. Cancellation invalidates work; only one inference owner may run at a time.
+
+Reuse the historical editor lifecycle design selectively: the input owns a generation and selected UTF-8 range; a changed draft, IME, undo, navigation or focus transition invalidates it. Inference never mutates a different draft. Finalization is bounded, and failure/timeout never submits. Submission intent must retain normal versus modified Send semantics.
+
+Parakeet TDT is an offline model. Start with final transcription on Stop; investigate previews without promising native streaming. Preserve text on errors and empty recognition. Match existing GPUI settings widgets, semantic theme colors, accessible buttons, and composer density.
+
+Implementation sequence:
+1. Verify runtime/model APIs, pin manifest and attribution; implement model lifecycle and bounded native transcription/capture.
+2. Adapt input lifecycle and deterministic tests to current composer, including Send/Queue and shortcut configuration.
+3. Add settings lifecycle and composer recording/finalizing/error presentation with production widgets.
+4. Run formatting, focused checks/tests, actual English/French runtime samples and packaged native UI verification in an isolated development profile. Record performance and limitations; prepare a local PR description. No publishing.
diff --git a/docs/reference/desktop-dictation.md b/docs/reference/desktop-dictation.md
new file mode 100644
index 0000000000..82aefcc7c0
--- /dev/null
+++ b/docs/reference/desktop-dictation.md
@@ -0,0 +1,35 @@
+# Desktop dictation
+
+Settings → Voice downloads NVIDIA Parakeet TDT 0.6B v3 for this device and enables the composer microphone. The optional INT8 ONNX download is **670,479,942 bytes**, derived from the pinned manifest, and is independent of the chat's engine host. Turn off hides dictation without deleting the model; Remove model disables it and removes the local cache.
+
+Dictation is hold to talk: hold the microphone (or Enter/Space while it is focused) or the **Hold to dictate** shortcut, rebindable in Settings → Voice (default Cmd/Ctrl+D), and release to transcribe. Releasing outside the microphone still counts; for the shortcut, letting go of its key or any of its modifiers ends the hold, since macOS does not deliver key-up for Command chords. A release within 300 ms is treated as a tap and explains hold to talk instead of transcribing. Assistive-technology Click cannot hold, so it starts and then finishes. Recording is limited to one minute. Release transcribes locally into the selected draft range. It never invokes an agent or submits on its own. Explicit Send waits for finalization, then follows the normal Send/Queue path once. If no speech is recognized, the composer explains this and preserves the draft without sending. Esc cancels; cancelling or a failed/timed-out finalization never sends. Microphone permission is requested on first use; if the permission dialog takes focus, retry after granting permission.
+
+The model detects the spoken language automatically and does not translate. Supported languages: Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Spanish, Swedish, Ukrainian. Technical names may need correction, especially in mixed-language speech.
+
+No audio files are created by production dictation. Audio stays in a bounded, transient buffer on the desktop running the UI; it is not attached, logged, synchronized or sent to the coding-agent host. Dictated text is an ordinary editable draft and is handled like typed text. Model downloads contact Hugging Face; transcription does not use the network.
+
+## Implementation and limits
+
+`zeron-voice` owns downloads, model integrity, CPAL capture, anti-aliased conversion of device-rate audio to 16 kHz, a capture thread, and a single background Parakeet worker. `zeron-ui::dictation` owns permissions, local settings and the small transcription event interface. Composer inputs own draft-range/generation protection and grouped undo. A manual edit, selection move, IME update, focus leaving the composer, chat switch or queue-draft replacement invalidates the session. Attachments retain their existing behavior.
+
+Capture starts as soon as permission and the audio device allow, independently of background model verification/loading. “Listening” is emitted only after the microphone stream starts; there is no hover prewarming. Stop closes capture and retains the bounded audio buffer until the model is ready, within the existing finalization deadline. A load failure closes capture before reporting failure. The production adapter performs offline final transcription on Stop. No live partials or native streaming are advertised. Editor partial-result behavior is tested through a deterministic adapter. Audio is capped at 60 seconds; UI finalization has a 30-second deadline. An in-flight native ONNX call cannot be forcibly interrupted safely: cancellation signals capture to stop independently of model loading (the capture loop checks every 10 ms) and invalidates results; one worker keeps native work bounded and rejects overlapping sessions until it returns. Cached weights unload after 30 idle seconds or model removal. Settings refuses removal while capture, loading, or inference is still active; after cancelling uninterruptible native work, retry removal once it returns.
+
+Pinned runtime: `parakeet-rs = 0.3.8`, `ort/ort-sys = 2.0.0-rc.13`, ONNX Runtime **1.28.0**, CPU execution; `cpal = 0.17.3`, `rubato = 0.16.2`. The download manifest and conversion attribution are in `crates/voice/model.json` and `crates/voice/NOTICE.md`. The conversion pins immutable bytes but its publisher does not provide the source-weight revision or exact INT8 conversion tool version; this provenance limitation is explicit.
+
+Release targets are macOS arm64, Linux x86_64/aarch64 and Windows x86_64. Linux CI installs ALSA headers. macOS uses AVFoundation only for permission, and its bundle includes microphone usage text and the hardened-runtime audio-input entitlement. The selected ONNX binary distribution has no Intel macOS build; Intel development requires an independently built matching ONNX Runtime. Windows' prebuilt ONNX archive links the system DirectML/DX12 libraries even though the chosen execution provider is CPU. Real-model inference, desktop UI, packaging and physical-microphone validation are separate checks; the PR records the platform evidence. iOS does not depend on this crate.
+
+On Windows, microphone access for desktop apps must be enabled in the system privacy settings. On Linux, the selected ALSA input must be available to the user and the audio server. Settings → Voice lists available inputs and refreshes while visible; a disconnected selection falls back to the system default. Test built-in, USB and Bluetooth microphones on the target OS: a synthetic WAV test cannot establish permission, device routing or capture behavior.
+
+Linux releases dynamically link the system ALSA runtime (`libasound.so.2`). It is required even with dictation disabled or in headless mode; no audio device or microphone permission is needed to run the engine. Both Linux installers check executable startup before activating an installation. The updater also checks a staged binary before replacing the active version.
+
+## Verification
+
+Deterministic editor fixtures cover partial replacement, Unicode, undo/redo, failure, stale events, cancellation, Send finalization, queue editing, navigation, focus and input-request takeover. `cargo test -p zeron-voice` covers pinned manifest shape/size, cancellation, corrupt cache rejection, and deterministic capture/load barriers for Stop, cancellation, failure, device startup, recording limits, and busy admission. The `verify` example runs explicitly supplied synthetic/public PCM16 WAV files and prints transcripts/timings for development only; production never prints transcripts.
+
+For native startup timing, launch a development bundle with `RUST_LOG=info,zeron_ui::dictation=debug`. The `activation_to_listening_ms` field measures from composer dictation activation to the UI entering Listening, including permission waiting and the 40 ms event polling cadence. It contains no audio or transcript; display presentation may follow on the next frame. Measure cold and cached model runs separately.
+
+Real-model verification is an explicit development check using the `verify` example and external synthetic/public WAV files. Routine CI does not download the model or retain speech fixtures in the repository.
+
+Future mobile implementation is scoped in the [PR #591 handoff](https://github.com/zeronsh/zeron/pull/591#issuecomment-5869764738), including native capture, lifecycle cancellation, mobile inference benchmarks, UTF-16/UTF-8 selection handling and preservation of iOS delivery modes.
+
+See the task evidence under `/Users/gaelcado/zeron/evidence/voice/` for actual runtime transcripts, hardware measurements and native build captures. Standalone synthetic model accuracy is distinct from a live microphone test.
diff --git a/edge/src/install.sh b/edge/src/install.sh
index 7046b9d267..3e329464fa 100644
--- a/edge/src/install.sh
+++ b/edge/src/install.sh
@@ -3,7 +3,7 @@
 #
 #   curl -fsSL https://zeron.sh/install.sh | sh
 #
-# Installs the self-contained native binary (no runtime deps) to
+# Installs the native binary (requires the system ALSA runtime) to
 # ~/.zeron/app, puts `zeron` on PATH, adds a launcher entry and icon under
 # $XDG_DATA_HOME (default ~/.local/share), and runs it as a local-only
 # systemd user service that survives reboots. Signing in is optional and
@@ -59,6 +59,14 @@ else
   tar -xzf "$tmp/$file" -C "$dest" --strip-components=1
 fi
 
+# Probe before changing a working installation or starting its service. The
+# desktop and headless modes share one binary, including CPAL's ALSA linkage.
+if ! "$dest/zeron" --version >/dev/null; then
+  echo "zeron install: the downloaded executable could not start; see the loader error above." >&2
+  echo "Install the missing runtime libraries (including ALSA, libasound.so.2), then rerun this installer." >&2
+  exit 1
+fi
+
 ln -sfn "$dest" "$app_root/current"
 mkdir -p "$HOME/.local/bin"
 ln -sf "$app_root/current/zeron" "$HOME/.local/bin/zeron"
diff --git a/scripts/package-linux.sh b/scripts/package-linux.sh
index 8d607e8300..8fe6ba27b2 100755
--- a/scripts/package-linux.sh
+++ b/scripts/package-linux.sh
@@ -35,6 +35,7 @@ install -m 644 "$ROOT/dist/zeron.desktop" "$STAGE/zeron.desktop"
 install -m 644 "$ROOT/dist/zeron.png" "$STAGE/zeron.png"
 mkdir -p "$STAGE/licenses/fonts"
 cp "$ROOT/crates/ui/assets/fonts/licenses/"* "$STAGE/licenses/fonts/"
+cp "$ROOT/crates/voice/NOTICE.md" "$STAGE/licenses/parakeet-v3.txt"
 
 cat >"$STAGE/install.sh" <<'INSTALL'
 #!/usr/bin/env bash
@@ -56,6 +57,10 @@ if [ ! -x "$DEST/zeron" ]; then
   rm -rf "$DEST"
   mv "$STAGE" "$DEST"
 fi
+if ! "$DEST/zeron" --version >/dev/null; then
+  echo "Zeron could not start; see the loader error above. Install the missing runtime libraries (including ALSA, libasound.so.2), then retry." >&2
+  exit 1
+fi
 ln -sfn "$DEST" "$APP_ROOT/current"
 mkdir -p "$HOME/.local/bin"
 ln -sfn "$APP_ROOT/current/zeron" "$HOME/.local/bin/zeron"
diff --git a/scripts/package-macos.sh b/scripts/package-macos.sh
index a5d50484c8..8adec844c1 100755
--- a/scripts/package-macos.sh
+++ b/scripts/package-macos.sh
@@ -31,6 +31,9 @@ sed "s/__VERSION__/$VERSION/" "$ROOT/dist/macos/Info.plist" >"$APP/Contents/Info
 mkdir -p "$APP/Contents/Resources/licenses/fonts"
 cp "$ROOT/crates/ui/assets/fonts/licenses/"* "$APP/Contents/Resources/licenses/fonts/"
 
+mkdir -p "$APP/Contents/Resources/licenses"
+cp "$ROOT/crates/voice/NOTICE.md" "$APP/Contents/Resources/licenses"/parakeet-v3.txt
+
 # Icon: iconset from the pre-masked macOS icon (squircle + margins + shadow
 # baked into dist/macos/icon-1024.png — sips can't alpha-mask, so the mask is
 # applied ahead of time; dist/zeron.png stays the full-bleed shared artwork).
@@ -47,7 +50,7 @@ rm -rf "$ICONSET"
 if [[ -n "${CODESIGN_IDENTITY:-}" ]]; then
   # Hardened runtime + secure timestamp are both notarization requirements.
   # (No --deep: Apple deprecated it; the bundle is a single Mach-O anyway.)
-  codesign --force --options runtime --timestamp --sign "$CODESIGN_IDENTITY" "$APP"
+  codesign --entitlements "$ROOT/dist/macos/Dictation.entitlements" --force --options runtime --timestamp --sign "$CODESIGN_IDENTITY" "$APP"
 else
   # Ad-hoc signature so the app launches on Apple silicon (Gatekeeper still
   # requires right-click → Open on first launch without notarization).
diff --git a/scripts/package-windows.ps1 b/scripts/package-windows.ps1
index 7efb9a78fc..77b40b4364 100644
--- a/scripts/package-windows.ps1
+++ b/scripts/package-windows.ps1
@@ -77,6 +77,7 @@ try {
     $licenses = Join-Path $stage 'licenses/fonts'
     New-Item -ItemType Directory -Force -Path $licenses | Out-Null
     Copy-Item -Path 'crates/ui/assets/fonts/licenses/*' -Destination $licenses
+    Copy-Item -LiteralPath 'crates/voice/NOTICE.md' -Destination (Join-Path $stage 'licenses/parakeet-v3.txt')
     Compress-Archive -Path "$stage/*" -DestinationPath "$stage.zip" -Force
     Copy-Item -LiteralPath './target/release/zeron.exe' -Destination "$stage.exe"
     # The per-user installer wraps the same staged directory (zeron-update.json
diff --git a/scripts/run-macos-dev.sh b/scripts/run-macos-dev.sh
index 3722841d40..a5048c209f 100755
--- a/scripts/run-macos-dev.sh
+++ b/scripts/run-macos-dev.sh
@@ -13,6 +13,7 @@ APP="$DEV_ROOT/Zeron Dev.app"
 CONTENTS="$APP/Contents"
 DATA_DIR="${ZERON_DEV_DATA_DIR:-$DEV_ROOT/data}"
 IPC_PORT="${ZERON_DEV_IPC_PORT:-49777}"
+BUNDLE_ID="${ZERON_DEV_BUNDLE_ID:-sh.zeron.app.dev}"
 
 if pgrep -f -x "$CONTENTS/MacOS/zeron" >/dev/null 2>&1; then
   echo "Zeron Dev is already running. Quit it before rebuilding the signed bundle." >&2
@@ -23,11 +24,16 @@ cd "$ROOT"
 cargo build -p zeron
 
 mkdir -p "$CONTENTS/MacOS" "$CONTENTS/Resources" "$DATA_DIR"
-install -m 755 "$ROOT/target/debug/zeron" "$CONTENTS/MacOS/zeron"
+TARGET_DIR="$(cargo metadata --no-deps --format-version 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["target_directory"])')"
+install -m 755 "$TARGET_DIR/debug/zeron" "$CONTENTS/MacOS/zeron"
 sed "s/__VERSION__/$VERSION/g" "$ROOT/dist/macos/Info-dev.plist" >"$CONTENTS/Info.plist"
+plutil -replace CFBundleIdentifier -string "$BUNDLE_ID" "$CONTENTS/Info.plist"
 plutil -replace LSEnvironment.ZERON_DATA_DIR -string "$DATA_DIR" "$CONTENTS/Info.plist"
 plutil -replace LSEnvironment.ZERON_IPC_PORT -string "$IPC_PORT" "$CONTENTS/Info.plist"
 
+mkdir -p "$CONTENTS/Resources/licenses"
+cp "$ROOT/crates/voice/NOTICE.md" "$CONTENTS/Resources/licenses"/parakeet-v3.txt
+
 if [[ ! -f "$CONTENTS/Resources/zeron.icns" ]]; then
   ICONSET="$DEV_ROOT/zeron-dev.iconset"
   mkdir -p "$ICONSET"
@@ -47,13 +53,13 @@ if [[ -z "$IDENTITY" ]]; then
   IDENTITY="$(security find-identity -v -p codesigning 2>/dev/null | sed -n 's/.*"\(Apple Development:[^"]*\)".*/\1/p' | head -1)"
 fi
 if [[ -n "$IDENTITY" ]]; then
-  codesign --force --sign "$IDENTITY" --identifier sh.zeron.app.dev "$APP"
+  codesign --entitlements "$ROOT/dist/macos/Dictation.entitlements" --force --sign "$IDENTITY" --identifier "$BUNDLE_ID" "$APP"
 else
-  codesign --force --sign - --identifier sh.zeron.app.dev "$APP"
+  codesign --entitlements "$ROOT/dist/macos/Dictation.entitlements" --force --sign - --identifier "$BUNDLE_ID" "$APP"
   echo "warning: no Apple Development signing identity found; macOS may ask for permissions again after a rebuild" >&2
 fi
 
-echo "running Zeron Dev (bundle sh.zeron.app.dev, data $DATA_DIR, IPC $IPC_PORT)" >&2
+echo "running Zeron Dev (bundle $BUNDLE_ID, data $DATA_DIR, IPC $IPC_PORT)" >&2
 # LaunchServices must own the process. Launching Contents/MacOS/zeron directly
 # makes TCC attribute Screen Recording to the terminal (Warp, Terminal, etc.).
 # -W keeps the script attached until the app exits. Runtime logs remain in the

From ae4181f517001ae151191d7bcab64c5651ea6320 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Fri, 2 Oct 2026 01:56:52 -0700
Subject: [PATCH 27/74] Fix the compact panel's model name; test settings
 survive navigation (#721)

The compact panel and composer chip now name the selected model through one resolver, so the panel no longer reads "Select model" while the chip names the pick. Adds a regression test for settings toggles surviving navigation saves (fixed in #591).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/pickers.rs         | 121 ++++++++++++++++++++++++++++---
 crates/ui/src/pickers/compact.rs |  29 ++++++--
 crates/ui/src/shell.rs           |  68 +++++++++++++++++
 3 files changed, 200 insertions(+), 18 deletions(-)

diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index df67c24519..97d64d480e 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -360,6 +360,20 @@ pub fn browser_rows(listing: &FolderListing) -> Vec<&zeron_proto::FolderEntry> {
 /// the first Down lands on row 0.
 const NO_ACTIVE_ROW: usize = usize::MAX;
 
+/// What names the selected model, shared by the composer chip and the
+/// compact panel so the two never disagree about it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum ModelName {
+    /// The catalog row's label, else the remembered pick's, else the id.
+    Named(SharedString),
+    /// Nothing names it yet, but the harness or model catalog that would
+    /// is still on its way.
+    Loading,
+    /// Nothing offers a model: no agents at all, or a provider whose
+    /// catalog came back empty or failed with no pick remembered.
+    None { no_agents: bool },
+}
+
 /// Which pane the harness/model picker's icon rail is showing (t3code
 /// ModelPickerContent `selectedInstanceId | "favorites"`). `Harness` means
 /// "the effective harness's list" — the rail has no browse-without-commit
@@ -986,6 +1000,27 @@ impl Pickers {
         selected_catalog_model(models, selected)
     }
 
+    fn model_name(&self, cx: &App) -> ModelName {
+        if self.no_agents_available() && self.effective_harness(cx).is_none() {
+            return ModelName::None { no_agents: true };
+        }
+        if let Some(label) = self.selected_model_label(cx) {
+            return ModelName::Named(label.into());
+        }
+        let catalog_loading = matches!(self.harnesses, Loadable::Idle | Loadable::Loading);
+        let models_loading = self.effective_harness(cx).is_some_and(|harness| {
+            !matches!(
+                self.models.get(&harness),
+                Some(Loadable::Ready(_)) | Some(Loadable::Error(_))
+            )
+        });
+        if catalog_loading || models_loading {
+            ModelName::Loading
+        } else {
+            ModelName::None { no_agents: false }
+        }
+    }
+
     fn selected_model_label(&self, cx: &App) -> Option<String> {
         self.selected_model(cx)
             .map(|model| model.label.clone())
@@ -5740,6 +5775,7 @@ impl Render for Pickers {
         // loaded, so that's a conclusion, not a loading gap) — the chip says
         // so instead of wearing a brand mark for an agent that can't run.
         let no_agents = self.no_agents_available() && self.effective_harness(cx).is_none();
+        let model_name = self.model_name(cx);
         let model_label: SharedString = if let Some(title) = &self.title {
             // The saved choice, not the tab being browsed.
             match (title.harness, title.model.as_deref()) {
@@ -5755,19 +5791,14 @@ impl Render for Pickers {
                     .unwrap_or_else(|| id.to_owned())
                     .into(),
             }
-        } else if no_agents {
-            SharedString::from("No agents available")
         } else {
-            let label = self.selected_model_label(cx);
-            label.map(SharedString::from).unwrap_or_default()
+            match &model_name {
+                ModelName::Named(label) => label.clone(),
+                ModelName::None { no_agents: true } => "No agents available".into(),
+                ModelName::Loading | ModelName::None { .. } => SharedString::default(),
+            }
         };
         let catalog_loading = matches!(self.harnesses, Loadable::Idle | Loadable::Loading);
-        let models_loading = self.effective_harness(cx).is_some_and(|harness| {
-            !matches!(
-                self.models.get(&harness),
-                Some(Loadable::Ready(_)) | Some(Loadable::Error(_))
-            )
-        });
         // Harness unknown while the catalog resolves: the pixel-glyph loader
         // instead of guessing a brand mark.
         let chip_icon_loading = self.title.is_none()
@@ -5776,8 +5807,7 @@ impl Render for Pickers {
             && catalog_loading;
         // Harness known but nothing names the model yet (fresh install, no
         // remembered pick): a ghost label instead of a bare icon.
-        let chip_label_loading =
-            !no_agents && model_label.is_empty() && (catalog_loading || models_loading);
+        let chip_label_loading = self.title.is_none() && model_name == ModelName::Loading;
         let chip_harness = match &self.title {
             Some(title) => title.harness,
             None => self.effective_harness(cx),
@@ -7713,6 +7743,73 @@ mod tests {
             supports_steering: false,
         }
     }
+    #[gpui::test]
+    fn model_name_never_reads_select_model_while_anything_can_still_name_it(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            cx.set_global(Theme::dark());
+            let mut settings = crate::settings::UiSettings::default();
+            settings.compact_model_picker = true;
+            crate::settings::init(settings, dir.path(), cx);
+        });
+        let handle = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Pickers::new(state, cx)
+        });
+        let named = |label: &str| ModelName::Named(label.into());
+        handle
+            .update(cx, |picker, _, cx| {
+                // Harness catalog still loading, a pick remembered: named.
+                picker.config.harness = Some(HarnessId::Codex);
+                picker.defaults.remember_model(
+                    HarnessId::Codex,
+                    "gpt-6-luna".into(),
+                    "GPT-6-Luna".into(),
+                );
+                assert_eq!(picker.model_name(cx), named("GPT-6-Luna"));
+                // Model catalog loading, pick remembered: still named.
+                picker.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Codex, "Codex")]);
+                picker.models.insert(HarnessId::Codex, Loadable::Loading);
+                assert_eq!(picker.model_name(cx), named("GPT-6-Luna"));
+                // A draft id the catalog never learned keeps its id.
+                picker.config.model = Some("gpt-7".into());
+                assert_eq!(picker.model_name(cx), named("gpt-7"));
+                // Nothing picked or remembered while loading: loading, not
+                // "Select model".
+                picker.config.model = None;
+                picker.defaults.model_by_harness.clear();
+                assert_eq!(picker.model_name(cx), ModelName::Loading);
+                picker.harnesses = Loadable::Loading;
+                assert_eq!(picker.model_name(cx), ModelName::Loading);
+                // Catalog in, nothing remembered: its default model.
+                picker.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Codex, "Codex")]);
+                picker.models.insert(
+                    HarnessId::Codex,
+                    Loadable::Ready(vec![bare_model("gpt-a", "A"), bare_model("gpt-b", "B")]),
+                );
+                assert_eq!(picker.model_name(cx), named("A"));
+                // Only a provider with nothing to offer is unnamed.
+                picker
+                    .models
+                    .insert(HarnessId::Codex, Loadable::Ready(Vec::new()));
+                assert_eq!(picker.model_name(cx), ModelName::None { no_agents: false });
+                picker
+                    .models
+                    .insert(HarnessId::Codex, Loadable::Error("offline".into()));
+                assert_eq!(picker.model_name(cx), ModelName::None { no_agents: false });
+                // ...and a remembered pick names it even then.
+                picker.defaults.remember_model(
+                    HarnessId::Codex,
+                    "gpt-6-luna".into(),
+                    "GPT-6-Luna".into(),
+                );
+                assert_eq!(picker.model_name(cx), named("GPT-6-Luna"));
+            })
+            .unwrap();
+    }
+
     #[gpui::test]
     fn compact_panel_shortcuts_drive_models_providers_and_effort(cx: &mut gpui::TestAppContext) {
         let dir = tempfile::tempdir().unwrap();
diff --git a/crates/ui/src/pickers/compact.rs b/crates/ui/src/pickers/compact.rs
index c242be2e69..9cbfeb46ed 100644
--- a/crates/ui/src/pickers/compact.rs
+++ b/crates/ui/src/pickers/compact.rs
@@ -624,6 +624,17 @@ impl Pickers {
             .map(|o| o.id.clone())
     }
 
+    /// The panel's title for a [`ModelName`]. Loading also draws a ghost
+    /// bar in the name's place, as the composer chip does.
+    fn compact_title_text(name: &ModelName) -> SharedString {
+        match name {
+            ModelName::Named(label) => label.clone(),
+            ModelName::Loading => "Loading models…".into(),
+            ModelName::None { no_agents: true } => "No agents available".into(),
+            ModelName::None { .. } => "Select model".into(),
+        }
+    }
+
     /// The slider's stops: the model's reasoning ladder, else an option
     /// shaped like one (Cursor's `effort`/`reasoning` choices), so every
     /// model with an effort gets the same slider.
@@ -883,11 +894,17 @@ impl Pickers {
         let (levels, selected) = self
             .compact_effort(cx)
             .map_or((Vec::new(), 0), |e| (e.labels, e.selected));
-        let label: SharedString = self
-            .selected_model(cx)
-            .map(|m| m.label.clone())
-            .unwrap_or_else(|| "Select model".into())
-            .into();
+        let name = self.model_name(cx);
+        let label = Self::compact_title_text(&name);
+        let name_element: AnyElement = if name == ModelName::Loading {
+            popover::skeleton_bar(72.0, cx.entity_id(), cx)
+        } else {
+            div()
+                .min_w_0()
+                .truncate()
+                .child(label.clone())
+                .into_any_element()
+        };
         let effort: SharedString = levels
             .get(selected)
             .cloned()
@@ -985,7 +1002,7 @@ impl Pickers {
                                 .text_color(motion::mix(theme.text_muted, theme.text, hover))
                         }
                     })
-                    .child(div().min_w_0().truncate().child(label.clone()))
+                    .child(name_element)
                     .child(
                         // Leans 3pt toward the list and firms up on hover.
                         div()
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index ed2749e2e9..54e0070761 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -14583,6 +14583,74 @@ mod exit_regressions {
         }
     }
 
+    #[gpui::test]
+    fn shell_saves_never_revert_settings_written_outside_the_shell(cx: &mut TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            crate::history::init(
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                cx,
+            );
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let window = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Shell::new(
+                state,
+                EngineBootConfig {
+                    data_dir: dir.path().into(),
+                    ipc_port: 0,
+                    edge_url: "http://127.0.0.1:1".into(),
+                    edge_token: None,
+                    org_id: None,
+                    workos_client_id: None,
+                    default_harness: zeron_proto::HarnessId::Mock,
+                },
+                cx,
+            )
+        });
+        let before = cx.update(|cx| settings::current(cx));
+        window
+            .update(cx, |shell, _, cx| {
+                // Toggles that write the store directly (the General page's
+                // Compact mode, notification and sidebar switches, ...).
+                settings::set_transcript_compact_mode(!before.transcript_compact_mode, cx);
+                settings::update(SavePolicy::Immediate, cx, |s| {
+                    s.notifications_enabled = !before.notifications_enabled;
+                    s.sidebar_show_branch = !before.sidebar_show_branch;
+                    s.escape_stops_active_agent = !before.escape_stops_active_agent;
+                });
+                // Navigating away saves the shell's own working copy.
+                shell.remember_settings_section(SettingsSection::Notifications, cx);
+                // The shell's own writes still land.
+                shell.settings.sidebar_width += 10.0;
+                shell.schedule_save(cx);
+            })
+            .unwrap();
+        let after = cx.update(|cx| settings::current(cx));
+        assert_eq!(
+            after.transcript_compact_mode,
+            !before.transcript_compact_mode
+        );
+        assert_eq!(after.notifications_enabled, !before.notifications_enabled);
+        assert_eq!(after.sidebar_show_branch, !before.sidebar_show_branch);
+        assert_eq!(
+            after.escape_stops_active_agent,
+            !before.escape_stops_active_agent
+        );
+        assert_eq!(
+            after.settings_section,
+            SettingsSection::Notifications.canonical()
+        );
+        assert_eq!(after.sidebar_width, before.sidebar_width + 10.0);
+    }
+
     #[gpui::test]
     fn workspace_slash_commands_open_existing_zeron_surfaces(cx: &mut TestAppContext) {
         use crate::composer::WorkspaceCommand;

From 64ad6f6ef03a8282c1847329804542f014c97d54 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Fri, 2 Oct 2026 01:58:10 -0700
Subject: [PATCH 28/74] Bump version to v0.2.102

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 36 ++++++++++++++++++------------------
 Cargo.toml |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8cdd5d1839..eeae99d7a8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12797,7 +12797,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "clap",
@@ -12819,7 +12819,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "async-trait",
  "chrono",
@@ -12843,7 +12843,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "chrono",
  "loro",
@@ -12857,7 +12857,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12897,7 +12897,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12924,14 +12924,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12949,7 +12949,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "serde",
  "serde_json",
@@ -12966,7 +12966,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12994,7 +12994,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -13005,7 +13005,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13024,7 +13024,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -13047,7 +13047,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -13081,7 +13081,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -13098,7 +13098,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "clap",
@@ -13113,7 +13113,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -13181,7 +13181,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "futures",
@@ -13197,7 +13197,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice"
-version = "0.2.101"
+version = "0.2.102"
 dependencies = [
  "anyhow",
  "cpal",
diff --git a/Cargo.toml b/Cargo.toml
index 5532ceaee7..5d25994ffe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.101"
+version = "0.2.102"
 edition = "2024"
 license = "MIT"
 publish = false

From 9782693b8561ff2764c8e38c16644d65a1b5bb31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Fri, 2 Oct 2026 13:56:08 -0300
Subject: [PATCH 29/74] Scope composer mic and attach hover fades per instance
 (#740)

The hover fade store is keyed by string, and both the main and sidechat
composers used the literal keys "composer-dictation" and
"composer-attach". Hovering either button lit the same button in the
other composer. Key both fades by the composer's entity id, as the
compact picker already does.
---
 crates/ui/src/composer.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 29a6cd49ca..9341bb64a2 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -9374,6 +9374,9 @@ impl Composer {
             || (!active && frame.is_some_and(|f| f.mode != Mode::Live));
         let tooltip = label.clone();
         let composer = cx.entity().downgrade();
+        // Per-composer key: the main and sidechat composers share this
+        // render, and the hover fade store is keyed by string.
+        let hover_key: SharedString = format!("composer-dictation-{}", cx.entity_id()).into();
         let centered = || {
             div()
                 .absolute()
@@ -9400,10 +9403,10 @@ impl Composer {
             .cursor_pointer()
             // At rest it is a sibling of the paperclip: the same eased ink
             // wash. Live, it is the accent plate and dims like Send.
-            .on_hover(motion::hover_listener("composer-dictation"))
+            .on_hover(motion::hover_listener(hover_key.clone()))
             .when(t <= 0.0, |el| {
                 el.bg(motion::hover_blend(
-                    "composer-dictation",
+                    &hover_key,
                     gpui::transparent_black(),
                     crate::theme::ink(0.10),
                 ))
@@ -10318,6 +10321,7 @@ impl Render for Composer {
         let dictating = self.input.read(cx).dictation.phase.active();
         let microphone = self.render_dictation_button(voice_t, voice_frame.as_ref(), cx);
         let attach_action = cx.entity().downgrade();
+        let attach_hover_key: SharedString = format!("composer-attach-{}", cx.entity_id()).into();
         // Attach button — opens the native image picker (the original's hidden
         // `<input type=file accept="image/*" multiple>`); paste/drop also feed
         // the same strip. The leading utility group owns the spacing between
@@ -10333,11 +10337,11 @@ impl Render for Composer {
             .cursor_pointer()
             // zeron composer-actions.tsx attach: `transition-colors`.
             .bg(motion::hover_blend(
-                "composer-attach",
+                &attach_hover_key,
                 gpui::transparent_black(),
                 crate::theme::ink(0.10),
             ))
-            .on_hover(motion::hover_listener("composer-attach"))
+            .on_hover(motion::hover_listener(attach_hover_key))
             .relative()
             // While dictating, the attachment slot becomes Cancel: the
             // paperclip and the cross swap with a scale and fade. The action

From 01832f2cac72af4818bf0dcd9c6525c5dde5c4a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Fri, 2 Oct 2026 17:02:48 -0300
Subject: [PATCH 30/74] MCP: create standalone sessions on a selected device
 and project (#706)

* feat(mcp): create standalone sessions on selected hosts

Add chat/side kinds with compatible defaults, resolve projects within the selected device, and validate that host's harness and model catalogs before writing. Route transcript reads to the chat host and preserve send baselines across waits so missing session rows and delayed replies cannot return an old response.

Cover invalid requests, remote catalogs, mixed batches, wait races, two-engine execution and interrupt delivery. Add an isolated MCP stdio smoke fixture.

* docs(mcp): document standalone and remote session workflows

* fix(mcp): match turn replies by message id, not host timestamps

Replies were filtered by createdAt >= the caller's send time, but
createdAt is stamped on the chat host's clock. A remote host running
behind the caller hid the reply to the send, and the wait spun until
timeout with no replies. send_message already snapshots the transcript's
message ids before sending, and a new chat has none, so the id baseline
alone identifies new replies.

The test transcript no longer gives a brand-new chat an earlier reply;
the existing chat's earlier reply shares the send's timestamp, so only
its id can exclude it.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock                                    |   1 +
 crates/engine/Cargo.toml                      |   1 +
 .../engine/examples/mcp_standalone_smoke.rs   | 103 ++
 crates/engine/tests/device_routing.rs         | 191 +++-
 crates/mcp/src/jsonrpc.rs                     |  12 +-
 crates/mcp/src/tools.rs                       | 900 +++++++++++++++---
 crates/mcp/src/zeron.rs                       | 137 ++-
 docs/mcp.md                                   | 121 ++-
 8 files changed, 1301 insertions(+), 165 deletions(-)
 create mode 100644 crates/engine/examples/mcp_standalone_smoke.rs

diff --git a/Cargo.lock b/Cargo.lock
index eeae99d7a8..d8d345cb28 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12887,6 +12887,7 @@ dependencies = [
  "windows-sys 0.61.2",
  "zeron-doc",
  "zeron-harness",
+ "zeron-mcp",
  "zeron-preview",
  "zeron-proto",
  "zeron-rpc",
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index ce891260bf..1a685d2554 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -43,6 +43,7 @@ tempfile.workspace = true
 windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_Pipes", "Win32_System_Threading"] }
 
 [dev-dependencies]
+zeron-mcp.workspace = true
 zeron-harness = { workspace = true, features = ["installer-fixture"] }
 zip.workspace = true
 tokio-tungstenite.workspace = true
diff --git a/crates/engine/examples/mcp_standalone_smoke.rs b/crates/engine/examples/mcp_standalone_smoke.rs
new file mode 100644
index 0000000000..1ab1294c9c
--- /dev/null
+++ b/crates/engine/examples/mcp_standalone_smoke.rs
@@ -0,0 +1,103 @@
+//! Isolated MCP stdio instance for manual discovery/create/converse smoke tests.
+//! Run with `cargo run -p zeron-engine --example mcp_standalone_smoke`.
+//! Uses a temporary profile and scripted harness, never the user's workspace.
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use futures::stream::BoxStream;
+use zeron_engine::{EngineCore, HarnessRegistry};
+use zeron_harness::{Harness, HarnessError, RunControls, mock::MockHarness};
+use zeron_mcp::{Origin, Tools, Zeron};
+use zeron_proto::{
+    AgentEvent, DoneStatus, HarnessId, Model, ReasoningLevel, RunRequest, SteeringMode,
+};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let dir = tempfile::tempdir()?;
+    std::fs::write(dir.path().join("device-id"), "smoke-device")?;
+    let registry = HarnessRegistry::new();
+    registry.register(Arc::new(SmokeHarness));
+    let core = EngineCore::assemble(dir.path(), Arc::new(registry), HarnessId::Codex, None)?;
+    core.workspace.create_space(
+        "smoke-project",
+        "smoke-device",
+        dir.path().to_str().unwrap(),
+        Some("Smoke project".into()),
+        false,
+    )?;
+    core.workspace
+        .create_chat("smoke-origin", Some("smoke-project"), None, None, None)?;
+    core.workspace.rename_chat("smoke-origin", "Coordinator")?;
+    let tools = Tools::new(Arc::new(Zeron::with_client(
+        zeron_rpc::memory_client(core.rpc_service()),
+        Origin {
+            chat_id: Some("smoke-origin".into()),
+            device_id: Some("smoke-device".into()),
+        },
+    )));
+    zeron_mcp::serve_stdio(Arc::new(tools)).await?;
+    core.shutdown().await;
+    Ok(())
+}
+
+/// A scripted, installed Codex adapter: the production catalog excludes Mock.
+struct SmokeHarness;
+
+#[async_trait]
+impl Harness for SmokeHarness {
+    fn id(&self) -> HarnessId {
+        HarnessId::Codex
+    }
+    fn display_name(&self) -> &str {
+        "Scripted Codex (smoke only)"
+    }
+    fn supports_steering(&self) -> bool {
+        false
+    }
+    fn steering_mode(&self) -> SteeringMode {
+        SteeringMode::TurnBoundary
+    }
+    fn reasoning_levels(&self) -> &[ReasoningLevel] {
+        &[]
+    }
+    async fn models(&self) -> Result<Vec<Model>, HarnessError> {
+        Ok(vec![Model {
+            id: "smoke-1".into(),
+            label: "Smoke 1".into(),
+            description: None,
+            reasoning_levels: vec![],
+            options: vec![],
+        }])
+    }
+    async fn run(
+        &self,
+        request: RunRequest,
+        controls: RunControls,
+    ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
+        let session_id = uuid::Uuid::new_v4().to_string();
+        let mock = MockHarness {
+            script: vec![
+                AgentEvent::SessionStarted {
+                    harness: HarnessId::Codex,
+                    model: "smoke-1".into(),
+                    tools: vec![],
+                    cwd: request.cwd.clone(),
+                    session_id: session_id.clone(),
+                    assistant_message_id: uuid::Uuid::new_v4().to_string(),
+                },
+                AgentEvent::TextDelta {
+                    text: "pong".into(),
+                },
+                AgentEvent::Done {
+                    status: DoneStatus::Completed,
+                    result: None,
+                    error: None,
+                    session_id: Some(session_id),
+                },
+            ],
+        };
+        mock.run(request, controls).await
+    }
+}
diff --git a/crates/engine/tests/device_routing.rs b/crates/engine/tests/device_routing.rs
index eb232df2c2..142f71c4c1 100644
--- a/crates/engine/tests/device_routing.rs
+++ b/crates/engine/tests/device_routing.rs
@@ -132,12 +132,12 @@ async fn fake_device_room() -> (String, tokio::task::JoinHandle<()>) {
 // ---------------------------------------------------------------------------
 
 /// Instant mock harness so a forwarded QueueCommand fully executes on the target.
-struct InstantHarness;
+struct InstantHarness(HarnessId);
 
 #[async_trait]
 impl Harness for InstantHarness {
     fn id(&self) -> HarnessId {
-        HarnessId::Mock
+        self.0
     }
     fn display_name(&self) -> &str {
         "Instant"
@@ -161,7 +161,7 @@ impl Harness for InstantHarness {
     ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
         Ok(futures::stream::iter([
             Ok(AgentEvent::SessionStarted {
-                harness: HarnessId::Mock,
+                harness: self.0,
                 model: "instant-1".into(),
                 tools: vec![],
                 cwd: "/tmp".into(),
@@ -183,8 +183,12 @@ impl Harness for InstantHarness {
 }
 
 fn registry() -> Arc<HarnessRegistry> {
+    registry_for(HarnessId::Mock)
+}
+
+fn registry_for(harness: HarnessId) -> Arc<HarnessRegistry> {
     let registry = HarnessRegistry::new();
-    registry.register(Arc::new(InstantHarness));
+    registry.register(Arc::new(InstantHarness(harness)));
     Arc::new(registry)
 }
 
@@ -1896,3 +1900,182 @@ async fn workspace_entry_mutations_are_forwarded_to_the_owning_plain_folder() {
     viewer.shutdown().await;
     host.shutdown().await;
 }
+
+/// Full MCP discovery/create/converse flow over two real engines, a shared
+/// registry and the same device relay used by the routing tests above.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn mcp_standalone_session_executes_on_the_selected_device() {
+    use serde_json::json;
+    use zeron_mcp::{Origin, Tools, Zeron};
+
+    let (relay_url, relay) = fake_device_room().await;
+    let dirs = tempfile::tempdir().unwrap();
+    let a = assemble(&dirs.path().join("a"), "device-a");
+    // Mock is deliberately disabled in production catalogs. Offer a scripted
+    // Codex adapter on B so MCP exercises normal availability validation.
+    let remote_dir = dirs.path().join("b");
+    std::fs::create_dir_all(&remote_dir).unwrap();
+    std::fs::write(remote_dir.join("device-id"), "device-b").unwrap();
+    let profile = zeron_engine::EngineProfile::development(&remote_dir, "dev-org", "dev-user");
+    let remote_store = zeron_sync::DocsStore::open(profile.store_root()).unwrap();
+    let b = EngineCore::assemble_with_profile(
+        profile,
+        registry_for(HarnessId::Codex),
+        HarnessId::Codex,
+        None,
+    )
+    .unwrap();
+    let registry = zeron_sync::registry::mock_server::MockRegistryServer::start().await;
+    a.workspace.connect_registry_url(&registry.url());
+    b.workspace.connect_registry_url(&registry.url());
+    let host = b.start_host_relay(&relay_url);
+    let mut config = LinkCacheConfig::new(relay_url, Arc::new(StaticToken("test-user".into())));
+    config.probe_timeout = Duration::from_secs(5);
+    a.set_links(LinkCache::new(config));
+    let client = zeron_rpc::memory_client(a.rpc_service());
+    let tools = Tools::new(Arc::new(Zeron::with_client(
+        client,
+        Origin {
+            chat_id: Some("coordinator".into()),
+            device_id: Some("device-a".into()),
+        },
+    )));
+    a.workspace
+        .create_chat("coordinator", None, Some("device-a"), None, None)
+        .unwrap();
+    let folder = dirs.path().join("remote-project");
+    std::fs::create_dir_all(&folder).unwrap();
+    b.workspace
+        .create_space(
+            "remote-project",
+            "device-b",
+            folder.to_str().unwrap(),
+            None,
+            false,
+        )
+        .unwrap();
+
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(15);
+    loop {
+        let devices = tools.call("list_devices", json!({})).await.unwrap();
+        let projects = tools
+            .call("list_projects", json!({"device":"device-b"}))
+            .await;
+        if devices["devices"].as_array().unwrap().len() == 2
+            && projects
+                .as_ref()
+                .is_ok_and(|p| p["projects"].as_array().unwrap().len() == 1)
+            && tools
+                .call("list_harnesses", json!({"device":"device-b"}))
+                .await
+                .is_ok()
+        {
+            break;
+        }
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "discovery did not converge"
+        );
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+    let projects = tools
+        .call("list_projects", json!({"device":"device-b"}))
+        .await
+        .unwrap();
+    let project = projects["projects"][0]["id"].as_str().unwrap();
+    tools
+        .call(
+            "list_models",
+            json!({"device":"device-b", "harness":"codex"}),
+        )
+        .await
+        .unwrap();
+    let created = tools
+        .call(
+            "create_chat",
+            json!({
+                "kind":"chat", "device":"device-b", "project":project,
+                "harness":"codex", "title":"Remote MCP session", "prompt":"execute on B",
+                "wait":true, "timeout_secs":30
+            }),
+        )
+        .await
+        .unwrap();
+    let chat_id = created["chatId"].as_str().unwrap();
+    assert_eq!(created["kind"], "chat");
+    assert!(created["parentChatId"].is_null());
+    assert_eq!(created["deviceId"], "device-b");
+    assert_eq!(created["turn"]["outcome"], "completed", "{created}");
+    assert_eq!(created["turn"]["replies"][0]["text"], "remote reply");
+    assert_eq!(created["turn"]["replies"][0]["deviceId"], "device-b");
+    let chat = b.workspace.chat(chat_id).unwrap().unwrap();
+    assert_eq!(chat.space_id.as_deref(), Some(project));
+    assert!(
+        chat.parent_chat_id.is_none(),
+        "eligible for Sessions on every client"
+    );
+    assert!(
+        a.sessions.session_status(chat_id).is_none(),
+        "A must not execute the prompt"
+    );
+    assert!(
+        b.sessions.session_status(chat_id).is_some(),
+        "B actually ran the harness"
+    );
+    let read = tools
+        .call("read_chat", json!({"chat":chat_id}))
+        .await
+        .unwrap();
+    assert!(
+        read["messages"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|m| m["role"] == "assistant"
+                && m["text"] == "remote reply"
+                && m["deviceId"] == "device-b")
+    );
+    let sent = tools
+        .call(
+            "send_message",
+            json!({
+                "chat":chat_id, "text":"a second remote turn", "wait":true, "timeout_secs":30
+            }),
+        )
+        .await
+        .unwrap();
+    assert_eq!(sent["turn"]["outcome"], "completed", "{sent}");
+    assert_eq!(
+        sent["turn"]["replies"].as_array().unwrap().len(),
+        1,
+        "only the new turn"
+    );
+    assert_eq!(sent["turn"]["replies"][0]["deviceId"], "device-b");
+    let waited = tools
+        .call("wait_for_turn", json!({"chat":chat_id,"timeout_secs":2}))
+        .await
+        .unwrap();
+    assert_eq!(waited["turn"]["outcome"], "completed");
+    let interrupted = tools
+        .call("interrupt_chat", json!({"chat":chat_id}))
+        .await
+        .unwrap();
+    let interrupt_id = interrupted["commandId"].as_str().unwrap();
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(15);
+    loop {
+        // Peer-relay delivery marks the processed-command ledger directly;
+        // the command row itself arrives separately through session-doc sync.
+        if remote_store.is_processed(interrupt_id).unwrap() {
+            break;
+        }
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "interrupt must reach B's command ledger"
+        );
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+    a.shutdown().await;
+    b.shutdown().await;
+    drop(host);
+    relay.abort();
+}
diff --git a/crates/mcp/src/jsonrpc.rs b/crates/mcp/src/jsonrpc.rs
index d43963d285..86cdd751ec 100644
--- a/crates/mcp/src/jsonrpc.rs
+++ b/crates/mcp/src/jsonrpc.rs
@@ -21,8 +21,8 @@ const PROTOCOL_VERSIONS: [&str; 3] = ["2025-06-18", "2025-03-26", "2024-11-05"];
 const LATEST_PROTOCOL: &str = "2025-06-18";
 
 const INSTRUCTIONS: &str = "\
-Zeron runs coding agents in chats, each hosted on a device inside a project \
-(a folder on that device). These tools operate the local Zeron engine: \
+Zeron runs coding agents in chats, each hosted on a device, optionally in a project \
+(a folder on that specific device). These tools operate the local Zeron engine: \
 discover devices/projects/chats, create chats with a chosen harness and \
 model, read transcripts, and send messages between chats.\n\
 \n\
@@ -35,6 +35,14 @@ For parallel delegation, use `create_chats` with a prompt for each chat or \
 even if your harness executes tool calls sequentially. Alternatively, launch ALL \
 chats/messages with `wait: false` first, then use `wait_for_turn` to collect replies. \
 Do not wait for one worker before launching the next independent worker. \
+Use `kind: chat` in `create_chat` or each `create_chats` request for a standalone \
+session visible in Sessions; it cannot have a parent. Use `kind: side` for a child \
+with an explicit parent or your origin chat. Omitted kind keeps legacy defaults: \
+side with an origin/parent, standalone otherwise. Side chats cannot create chats. \
+Discover hosts with `list_devices`, then `list_projects {device}`, \
+`list_harnesses {device}` and `list_models {device, harness}`. A project fixes \
+its host; with both project and device it must belong to that device. Use listed \
+ids when names/paths repeat. Without project or device, creation uses the local engine. \
 If a chat is `awaitingInput`, answer it with `respond_to_input`.";
 
 const PARSE_ERROR: i64 = -32700;
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index 4cfbd8bf9a..e83e88bcf2 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -6,9 +6,11 @@
 //! deliver a message to a chat in this state" choice the composer makes
 //! for humans.
 
+use std::collections::HashMap;
 use std::sync::Arc;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{Duration, Instant};
 
+use anyhow::Context;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use zeron_doc::SessionCommandPayload;
@@ -38,6 +40,9 @@ pub struct ToolDef {
 
 pub struct Tools {
     zeron: Arc<Zeron>,
+    // Remember successful sends on this MCP connection so wait_for_turn after
+    // wait:false also waits for a newly created chat with no session row yet.
+    pending_turns: tokio::sync::Mutex<HashMap<String, Arc<PendingTurn>>>,
 }
 
 fn chat_key_schema(extra: Value) -> Value {
@@ -55,6 +60,10 @@ fn chat_key_schema(extra: Value) -> Value {
     json!({ "type": "object", "properties": properties, "required": ["chat"] })
 }
 
+fn device_schema() -> Value {
+    json!({ "type": "string", "description": "Host device id or exact name. Omit for the local engine." })
+}
+
 fn catalog() -> Vec<ToolDef> {
     let mut tools = vec![
         ToolDef {
@@ -69,21 +78,22 @@ fn catalog() -> Vec<ToolDef> {
         },
         ToolDef {
             name: "list_projects",
-            description: "Projects: a folder on a device. Each chat belongs to one project, which fixes its host device and working directory.",
-            input_schema: json!({ "type": "object", "properties": {} }),
+            description: "Projects: folders on specific devices. Filter by device (id or name); omit for all projects. Use ids when names or paths repeat.",
+            input_schema: json!({ "type": "object", "properties": { "device": device_schema() } }),
         },
         ToolDef {
             name: "list_harnesses",
-            description: "Agent harnesses (claude-code, codex, cursor, …) and whether each is available on this device.",
-            input_schema: json!({ "type": "object", "properties": {} }),
+            description: "Agent harnesses (claude-code, codex, cursor, …) available on the chosen device. Omit device for the local engine.",
+            input_schema: json!({ "type": "object", "properties": { "device": device_schema() } }),
         },
         ToolDef {
             name: "list_models",
-            description: "Models a harness offers on this device. Model ids are harness-specific strings; pass one to create_chat.",
+            description: "Models a harness offers on the chosen device (local engine when omitted). Model ids are harness-specific strings; pass one to create_chat.",
             input_schema: json!({
                 "type": "object",
                 "properties": {
-                    "harness": { "type": "string", "description": "Harness id, e.g. claude-code or codex." }
+                    "harness": { "type": "string", "description": "Harness id, e.g. claude-code or codex." },
+                    "device": device_schema()
                 },
                 "required": ["harness"]
             }),
@@ -109,15 +119,16 @@ fn catalog() -> Vec<ToolDef> {
         },
         ToolDef {
             name: "create_chat",
-            description: "Create a chat in a project (or project-less on a device) with a harness and model. The new chat records your chat as its parent (parentChatId). Optionally send a first prompt and wait for the reply. Returns the new chat id. For parallel delegation use create_chats, or leave wait=false on every launch and wait only after all chats have been started.",
+            description: "Create a standalone session visible in Sessions with kind chat, or a child with kind side. Omitted kind preserves the default: side with an origin/parent, standalone otherwise. A side chat cannot create chats. Select a project and/or device; catalogs are validated on that host. Optionally send a first prompt and wait for the reply. Returns the new chat id. For parallel delegation use create_chats, or leave wait=false on every launch and wait only after all chats have been started.",
             input_schema: json!({
                 "type": "object",
                 "properties": {
-                    "project": { "type": "string", "description": "Project id, path, or name. Required unless device is given." },
-                    "device": { "type": "string", "description": "Host device (id or name) for a project-less chat; defaults to this device." },
+                    "kind": { "type": "string", "enum": ["chat", "side"], "description": "chat: standalone, no parent allowed. side: requires parent or origin. Omit for legacy defaults." },
+                    "project": { "type": "string", "description": "Project id, path, or name. Belongs to a specific device; when device is supplied, search only there. Optional." },
+                    "device": { "type": "string", "description": "Host device (id or name). With project, it must own that project. Without either, use the local engine." },
                     "parent": { "type": "string", "description": "Parent chat to record (id, prefix, or title). Defaults to the chat you are speaking from." },
-                    "harness": { "type": "string", "description": "Harness id (see list_harnesses). Defaults to claude-code when available." },
-                    "model": { "type": "string", "description": "Model id from list_models. Omit for the harness default." },
+                    "harness": { "type": "string", "description": "Harness id (see list_harnesses with the chosen device). Defaults to claude-code when available." },
+                    "model": { "type": "string", "description": "Model id from list_models on the chosen device. Omit for the harness default." },
                     "reasoning": { "type": "string", "description": "Reasoning level the model supports (e.g. low, medium, high, max)." },
                     "sandbox": { "type": "string", "enum": ["read-only", "workspace-write", "danger-full-access"], "default": "workspace-write" },
                     "title": { "type": "string", "description": "Sidebar title. Otherwise the engine titles it from the first exchange." },
@@ -191,7 +202,7 @@ fn catalog() -> Vec<ToolDef> {
         (
             "create_chats",
             "create_chat",
-            "Create multiple independent side chats concurrently. Put each chat's prompt in its request to start all work together. Prefer this for parallel delegation, including harnesses that execute tool calls sequentially. Each request has create_chat arguments; wait defaults to false. Results preserve request order and include per-request errors; successful requests are not rolled back.",
+            "Create multiple standalone or side chats concurrently (kind per request). Put each chat's prompt in its request to start all work together. Prefer this for parallel delegation, including harnesses that execute tool calls sequentially. Each request has create_chat arguments; wait defaults to false. Results preserve request order and include per-request errors; successful requests are not rolled back.",
         ),
         (
             "send_messages",
@@ -232,6 +243,7 @@ struct ChatArgs {
 #[derive(Deserialize)]
 struct ListModelsArgs {
     harness: String,
+    device: Option<String>,
 }
 
 #[derive(Deserialize, Default)]
@@ -244,8 +256,35 @@ struct ListChatsArgs {
     limit: Option<usize>,
 }
 
+#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+enum ChatKind {
+    Chat,
+    Side,
+}
+
+#[derive(Deserialize, Default)]
+struct DeviceArgs {
+    device: Option<String>,
+}
+
+/// Messages already in the transcript before a send. Replies are matched by
+/// id, not by time: `createdAt` is stamped on the host's clock, which can run
+/// behind the caller's when the chat lives on another device.
+#[derive(Clone, Default)]
+struct TurnStart {
+    message_ids: Vec<String>,
+}
+
+#[derive(Clone)]
+struct PendingTurn {
+    baseline: Option<Session>,
+    start: TurnStart,
+}
+
 #[derive(Deserialize, Default)]
 struct CreateChatArgs {
+    kind: Option<ChatKind>,
     project: Option<String>,
     device: Option<String>,
     parent: Option<String>,
@@ -319,9 +358,10 @@ fn wait_duration(secs: Option<u64>) -> Duration {
         .min(MAX_WAIT)
 }
 
+#[cfg(test)]
 fn now_millis() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
         .map(|d| d.as_millis() as i64)
         .unwrap_or_default()
 }
@@ -389,7 +429,10 @@ fn last_pending_input(messages: &[RenderedMessage]) -> Option<Value> {
 
 impl Tools {
     pub fn new(zeron: Arc<Zeron>) -> Self {
-        Self { zeron }
+        Self {
+            zeron,
+            pending_turns: Default::default(),
+        }
     }
 
     pub fn list(&self) -> Vec<ToolDef> {
@@ -406,8 +449,8 @@ impl Tools {
         let result = match name {
             "whoami" => self.whoami().await,
             "list_devices" => self.list_devices().await,
-            "list_projects" => self.list_projects().await,
-            "list_harnesses" => self.list_harnesses().await,
+            "list_projects" => self.list_projects(parse(args)?).await,
+            "list_harnesses" => self.list_harnesses(parse(args)?).await,
             "list_models" => self.list_models(parse(args)?).await,
             "list_chats" => self.list_chats(parse(args)?).await,
             "get_chat" => self.get_chat(parse(args)?).await,
@@ -422,7 +465,7 @@ impl Tools {
             "archive_chat" => self.archive_chat(parse(args)?).await,
             other => return Err(format!("unknown tool: {other}")),
         };
-        result.map_err(|e| e.to_string())
+        result.map_err(|e| format!("{e:#}"))
     }
 
     /// Poll every request together, including its optional wait. A waiting
@@ -500,8 +543,12 @@ impl Tools {
         }))
     }
 
-    async fn list_projects(&self) -> anyhow::Result<Value> {
-        let (spaces, devices) = tokio::try_join!(self.zeron.spaces(), self.zeron.devices())?;
+    async fn list_projects(&self, args: DeviceArgs) -> anyhow::Result<Value> {
+        let (mut spaces, devices) = tokio::try_join!(self.zeron.spaces(), self.zeron.devices())?;
+        if let Some(device) = args.device.as_deref() {
+            let device = self.zeron.resolve_device_id(Some(device)).await?;
+            spaces.retain(|s| s.device_id == device);
+        }
         let device_name = |id: &str| devices.iter().find(|d| d.id == id).map(|d| d.name.clone());
         Ok(json!({
             "projects": spaces.iter().map(|s| json!({
@@ -515,8 +562,12 @@ impl Tools {
         }))
     }
 
-    async fn list_harnesses(&self) -> anyhow::Result<Value> {
-        let harnesses = self.zeron.harnesses().await?;
+    async fn list_harnesses(&self, args: DeviceArgs) -> anyhow::Result<Value> {
+        let device = match args.device.as_deref() {
+            Some(key) => Some(self.zeron.resolve_device_id(Some(key)).await?),
+            None => None,
+        };
+        let harnesses = self.zeron.harnesses_on(device.as_deref()).await?;
         Ok(json!({
             "harnesses": harnesses.iter().map(|h| json!({
                 "id": h.id,
@@ -532,7 +583,11 @@ impl Tools {
     async fn list_models(&self, args: ListModelsArgs) -> anyhow::Result<Value> {
         let harness: HarnessId =
             parse_enum("harness", &args.harness).map_err(anyhow::Error::msg)?;
-        let models = self.zeron.models(harness).await?;
+        let device = match args.device.as_deref() {
+            Some(key) => Some(self.zeron.resolve_device_id(Some(key)).await?),
+            None => None,
+        };
+        let models = self.zeron.models_on(harness, device.as_deref()).await?;
         Ok(json!({
             "harness": harness,
             "models": models.iter().map(|m| json!({
@@ -551,7 +606,11 @@ impl Tools {
             self.zeron.sessions()
         )?;
         if let Some(project) = args.project.as_deref() {
-            let space = self.zeron.resolve_space(project).await?;
+            let (space, _) = self
+                .zeron
+                .resolve_target(Some(project), args.device.as_deref())
+                .await?;
+            let space = space.expect("project provided");
             chats.retain(|c| c.space_id.as_deref() == Some(space.id.as_str()));
         }
         if args.device.is_some() {
@@ -585,7 +644,7 @@ impl Tools {
         let (spaces, sessions, entries) = tokio::try_join!(
             self.zeron.spaces(),
             self.zeron.sessions(),
-            self.zeron.transcript(&chat.id)
+            self.zeron.transcript_on(&chat.id, Some(&chat.device_id))
         )?;
         let rendered = render_entries(&entries, RenderOptions::default());
         let mut summary = summarize_chat(&chat, &spaces, &sessions);
@@ -603,28 +662,63 @@ impl Tools {
                 "Side chats cannot create chats. Ask your parent chat to create another side chat."
             );
         }
-        let harnesses = self.zeron.harnesses().await?;
+        // Parent: the explicit `parent` argument, else the chat this server
+        // speaks for. Resolved so a prefix/title works and a typo fails loud.
+        let explicit_parent = args
+            .parent
+            .as_deref()
+            .map(str::trim)
+            .filter(|p| !p.is_empty());
+        anyhow::ensure!(
+            args.kind != Some(ChatKind::Chat) || explicit_parent.is_none(),
+            "kind chat cannot have a parent"
+        );
+        let parent_chat_id = if args.kind == Some(ChatKind::Chat) {
+            None
+        } else {
+            match explicit_parent {
+                Some(key) => Some(self.zeron.resolve_chat(key).await?.id),
+                None => self.zeron.origin().chat_id.clone(),
+            }
+        };
+        anyhow::ensure!(
+            args.kind != Some(ChatKind::Side) || parent_chat_id.is_some(),
+            "kind side requires a parent or origin chat"
+        );
+        let kind = if parent_chat_id.is_some() {
+            ChatKind::Side
+        } else {
+            ChatKind::Chat
+        };
+
+        if let Some(parent) = parent_chat_id.as_deref() {
+            let chat = self.zeron.resolve_chat(parent).await?;
+            anyhow::ensure!(
+                chat.parent_chat_id.is_none(),
+                "Cannot create a child of a side chat. Choose a top-level parent chat."
+            );
+        }
+        let (space, device_id) = self
+            .zeron
+            .resolve_target(args.project.as_deref(), args.device.as_deref())
+            .await?;
+        let harnesses = self.zeron.harnesses_on(Some(&device_id)).await?;
         let harness = match args.harness.as_deref() {
             Some(raw) => {
                 let id: HarnessId = parse_enum("harness", raw).map_err(anyhow::Error::msg)?;
-                if let Some(info) = harnesses.iter().find(|h| h.id == id)
-                    && !info.available()
-                {
-                    anyhow::bail!(
-                        "harness {raw} is not available on this device (see list_harnesses)"
-                    );
-                }
+                anyhow::ensure!(
+                    harnesses.iter().any(|h| h.id == id && h.available()),
+                    "harness {raw} is not available on device {device_id} (see list_harnesses with device)"
+                );
                 id
             }
-            None => default_harness(&harnesses)?,
+            None => default_harness(&harnesses).with_context(|| format!("device {device_id}"))?,
         };
-        if let Some(model) = args.model.as_deref()
-            && let Ok(models) = self.zeron.models(harness).await
-            && !models.is_empty()
-            && !models.iter().any(|m| m.id == model)
-        {
-            anyhow::bail!(
-                "model {model:?} is not offered by {harness:?}; available: {}",
+        if let Some(model) = args.model.as_deref() {
+            let models = self.zeron.models_on(harness, Some(&device_id)).await?;
+            anyhow::ensure!(
+                models.iter().any(|m| m.id == model),
+                "model {model:?} is not offered by {harness:?} on device {device_id}; available: {}",
                 models
                     .iter()
                     .map(|m| m.id.as_str())
@@ -648,37 +742,6 @@ impl Tools {
             sandbox,
         };
 
-        let (space, device_id) = match args.project.as_deref() {
-            Some(project) => {
-                let space = self.zeron.resolve_space(project).await?;
-                let device_id = space.device_id.clone();
-                (Some(space), device_id)
-            }
-            None => (
-                None,
-                self.zeron.resolve_device_id(args.device.as_deref()).await?,
-            ),
-        };
-
-        // Parent: the explicit `parent` argument, else the chat this server
-        // speaks for. Resolved so a prefix/title works and a typo fails loud.
-        let parent_chat_id = match args
-            .parent
-            .as_deref()
-            .map(str::trim)
-            .filter(|p| !p.is_empty())
-        {
-            Some(key) => Some(self.zeron.resolve_chat(key).await?.id),
-            None => self.zeron.origin().chat_id.clone(),
-        };
-
-        if let Some(parent) = parent_chat_id.as_deref() {
-            let chat = self.zeron.resolve_chat(parent).await?;
-            anyhow::ensure!(
-                chat.parent_chat_id.is_none(),
-                "Cannot create a child of a side chat. Choose a top-level parent chat."
-            );
-        }
         let chat_id = uuid::Uuid::new_v4().to_string();
         let mut mutate = json!({
             "op": "createChat",
@@ -717,6 +780,7 @@ impl Tools {
 
         let mut result = json!({
             "chatId": chat_id,
+            "kind": kind,
             "deviceId": device_id,
             "project": space.as_ref().map(|s| json!({ "id": s.id, "name": s.display_name(), "path": s.path })),
             "harness": harness,
@@ -752,15 +816,18 @@ impl Tools {
                 .deliver(&chat, space.as_ref(), &harnesses, None, prompt, "run")
                 .await?;
             result["sent"] = sent;
+            let pending = Arc::new(PendingTurn {
+                baseline: None,
+                // A new chat has no earlier messages.
+                start: TurnStart::default(),
+            });
+            self.pending_turns
+                .lock()
+                .await
+                .insert(chat.id.clone(), pending.clone());
             if args.wait {
                 result["turn"] = self
-                    .await_turn(
-                        &chat,
-                        None,
-                        true,
-                        wait_duration(args.timeout_secs),
-                        now_millis(),
-                    )
+                    .await_pending_turn(&chat, pending, wait_duration(args.timeout_secs))
                     .await?;
             }
         }
@@ -769,7 +836,10 @@ impl Tools {
 
     async fn read_chat(&self, args: ReadChatArgs) -> anyhow::Result<Value> {
         let chat = self.zeron.resolve_chat(&args.chat).await?;
-        let entries = self.zeron.transcript(&chat.id).await?;
+        let entries = self
+            .zeron
+            .transcript_on(&chat.id, Some(&chat.device_id))
+            .await?;
         let rendered = render_entries(
             &entries,
             RenderOptions {
@@ -809,7 +879,7 @@ impl Tools {
         let (spaces, sessions, harnesses) = tokio::try_join!(
             self.zeron.spaces(),
             self.zeron.sessions(),
-            self.zeron.harnesses()
+            self.zeron.harnesses_on(Some(&chat.device_id))
         )?;
         let space = chat
             .space_id
@@ -817,7 +887,13 @@ impl Tools {
             .and_then(|id| spaces.iter().find(|s| s.id == id));
         let baseline = session_for(&sessions, &chat);
         let mode = args.mode.as_deref().unwrap_or("auto");
-        let sent_at = now_millis();
+        let message_ids = self
+            .zeron
+            .transcript_on(&chat.id, Some(&chat.device_id))
+            .await?
+            .into_iter()
+            .map(|m| m.id)
+            .collect();
         let body = self.attribute(&chat, text).await;
         let mut result = json!({
             "chatId": chat.id,
@@ -826,15 +902,17 @@ impl Tools {
         result["sent"] = self
             .deliver(&chat, space, &harnesses, baseline.as_ref(), body, mode)
             .await?;
+        let pending = Arc::new(PendingTurn {
+            baseline,
+            start: TurnStart { message_ids },
+        });
+        self.pending_turns
+            .lock()
+            .await
+            .insert(chat.id.clone(), pending.clone());
         if args.wait {
             result["turn"] = self
-                .await_turn(
-                    &chat,
-                    baseline.as_ref(),
-                    true,
-                    wait_duration(args.timeout_secs),
-                    sent_at,
-                )
+                .await_pending_turn(&chat, pending, wait_duration(args.timeout_secs))
                 .await?;
         }
         Ok(result)
@@ -842,9 +920,23 @@ impl Tools {
 
     async fn wait_for_turn(&self, args: WaitArgs) -> anyhow::Result<Value> {
         let chat = self.zeron.resolve_chat(&args.chat).await?;
-        let turn = self
-            .await_turn(&chat, None, false, wait_duration(args.timeout_secs), 0)
-            .await?;
+        let pending = self.pending_turns.lock().await.get(&chat.id).cloned();
+        let turn = match pending {
+            Some(pending) => {
+                self.await_pending_turn(&chat, pending, wait_duration(args.timeout_secs))
+                    .await?
+            }
+            None => {
+                self.await_turn(
+                    &chat,
+                    None,
+                    false,
+                    wait_duration(args.timeout_secs),
+                    TurnStart::default(),
+                )
+                .await?
+            }
+        };
         Ok(json!({ "chatId": chat.id, "title": chat.title, "turn": turn }))
     }
 
@@ -871,7 +963,10 @@ impl Tools {
         let request_id = match args.request_id {
             Some(id) => id,
             None => {
-                let entries = self.zeron.transcript(&chat.id).await?;
+                let entries = self
+                    .zeron
+                    .transcript_on(&chat.id, Some(&chat.device_id))
+                    .await?;
                 let rendered = render_entries(&entries, RenderOptions::default());
                 last_pending_input(&rendered)
                     .and_then(|p| {
@@ -1025,37 +1120,90 @@ impl Tools {
         }))
     }
 
+    async fn await_pending_turn(
+        &self,
+        chat: &Chat,
+        pending: Arc<PendingTurn>,
+        timeout: Duration,
+    ) -> anyhow::Result<Value> {
+        let turn = self
+            .await_turn(
+                chat,
+                pending.baseline.as_ref(),
+                true,
+                timeout,
+                pending.start.clone(),
+            )
+            .await?;
+        if turn["timedOut"] == false {
+            let mut turns = self.pending_turns.lock().await;
+            // A concurrent send may already have installed a newer baseline.
+            if turns
+                .get(&chat.id)
+                .is_some_and(|p| Arc::ptr_eq(p, &pending))
+            {
+                turns.remove(&chat.id);
+            }
+        }
+        Ok(turn)
+    }
+
     /// Wait, then report the outcome with the assistant messages that
-    /// landed since `since_millis`.
+    /// are not in `start`'s baseline.
     async fn await_turn(
         &self,
         chat: &Chat,
         baseline: Option<&Session>,
         expect_turn: bool,
         timeout: Duration,
-        since_millis: i64,
+        start: TurnStart,
     ) -> anyhow::Result<Value> {
-        let (outcome, session) = self
+        let deadline = Instant::now() + timeout;
+        let (mut outcome, session) = self
             .zeron
             .wait_for_turn(chat, baseline, expect_turn, timeout)
             .await?;
-        let entries = self.zeron.transcript(&chat.id).await.unwrap_or_default();
-        let rendered = render_entries(&entries, RenderOptions::default());
-        let replies: Vec<&RenderedMessage> = rendered
-            .iter()
-            .filter(|m| m.role == zeron_doc::MessageRole::Assistant)
-            .filter(|m| m.created_at >= since_millis.saturating_sub(2_000))
-            .collect();
-        let replies: Vec<&RenderedMessage> = if replies.is_empty() {
-            rendered
+        // Registry session updates can arrive before the separate transcript doc.
+        // Keep the same deadline while waiting for a response to this send.
+        let mut rendered = Vec::new();
+        let mut replies = Vec::new();
+        loop {
+            let remaining = deadline.saturating_duration_since(Instant::now());
+            if remaining.is_zero() {
+                if outcome == TurnOutcome::Completed && expect_turn {
+                    outcome = TurnOutcome::TimedOut;
+                }
+                break;
+            }
+            let entries = match tokio::time::timeout(
+                remaining,
+                self.zeron.transcript_on(&chat.id, Some(&chat.device_id)),
+            )
+            .await
+            {
+                Ok(entries) => entries?,
+                Err(_) => {
+                    outcome = TurnOutcome::TimedOut;
+                    break;
+                }
+            };
+            rendered = render_entries(&entries, RenderOptions::default());
+            replies = rendered
                 .iter()
-                .rev()
-                .find(|m| m.role == zeron_doc::MessageRole::Assistant)
-                .into_iter()
-                .collect()
-        } else {
-            replies
-        };
+                .filter(|m| m.role == zeron_doc::MessageRole::Assistant)
+                .filter(|m| !start.message_ids.contains(&m.id))
+                .cloned()
+                .collect();
+            if !expect_turn
+                || outcome != TurnOutcome::Completed
+                || replies
+                    .iter()
+                    .any(|m| m.status != Some(zeron_doc::MessageStatus::Streaming))
+            {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(100).min(remaining)).await;
+        }
         let (status, _) = status_of(session.as_ref());
         Ok(json!({
             "outcome": outcome,
@@ -1069,9 +1217,6 @@ impl Tools {
 
 /// claude-code when it is offered here, else the first available harness.
 fn default_harness(harnesses: &[HarnessInfo]) -> anyhow::Result<HarnessId> {
-    if harnesses.is_empty() {
-        return Ok(HarnessId::ClaudeCode);
-    }
     harnesses
         .iter()
         .find(|h| h.id == HarnessId::ClaudeCode && h.available())
@@ -1095,13 +1240,16 @@ mod tests {
     use std::sync::Mutex;
     use zeron_rpc::{RpcError, RpcReply, RpcService, memory_client, methods};
 
-    /// A fixed little workspace: one device, one project, one chat with a
-    /// two-message transcript. Writes are recorded for assertions.
+    /// Two devices with distinct catalogs and repeated project paths, plus
+    /// two chats with a two-message transcript. Writes are recorded for assertions.
     #[derive(Default)]
     struct World {
         writes: Mutex<Vec<(String, Value)>>,
         dispatch_barrier: Option<tokio::sync::Barrier>,
         beta_parent: Option<String>,
+        beta_remote: bool,
+        catalog_error: Option<&'static str>,
+        reads: Mutex<Vec<(String, Value)>>,
     }
 
     fn stream(item: Value) -> RpcReply {
@@ -1111,6 +1259,16 @@ mod tests {
     #[async_trait]
     impl RpcService for World {
         async fn handle(&self, method: &str, params: Value) -> Result<RpcReply, RpcError> {
+            if matches!(method, methods::LIST_HARNESSES | methods::LIST_MODELS) {
+                self.reads
+                    .lock()
+                    .unwrap()
+                    .push((method.into(), params.clone()));
+                if self.catalog_error == Some(method) {
+                    return Err(RpcError::Failed("catalog unavailable".into()));
+                }
+            }
+            let remote = params["targetDeviceId"] == "dev-remote";
             Ok(match method {
                 methods::LOCAL_DEVICE => RpcReply::Value(json!({ "deviceId": "dev-local" })),
                 methods::ENGINE_INFO => RpcReply::Value(json!({
@@ -1119,10 +1277,16 @@ mod tests {
                 methods::WATCH_DEVICES => stream(json!([{
                     "id": "dev-local", "name": "Laptop", "platform": "linux",
                     "lastSeenAt": null
-                }])),
+                }, {"id": "dev-remote", "name": "Worker", "platform": "linux", "lastSeenAt": null}])),
                 methods::WATCH_SPACES => stream(json!([{
                     "id": "space-1", "deviceId": "dev-local", "path": "/repo/comet",
                     "gitDetected": true, "createdAt": "2026-09-01T00:00:00Z"
+                }, {
+                    "id": "space-remote", "deviceId": "dev-remote", "path": "/repo/comet",
+                    "gitDetected": true, "createdAt": "2026-09-01T00:00:00Z"
+                }, {
+                    "id": "space-unique", "deviceId": "dev-remote", "path": "/repo/unique",
+                    "gitDetected": true, "createdAt": "2026-09-01T00:00:00Z"
                 }])),
                 methods::WATCH_CHATS => stream(json!([
                     {
@@ -1132,19 +1296,26 @@ mod tests {
                         "createdAt": "2026-09-01T00:00:00Z"
                     },
                     {
-                        "id": "chat-beta-2", "deviceId": "dev-local", "title": "Beta",
+                        "id": "chat-beta-2", "deviceId": if self.beta_remote { "dev-remote" } else { "dev-local" }, "title": "Beta",
                         "parentChatId": self.beta_parent,
                         "archived": false, "spaceId": "space-1",
                         "createdAt": "2026-09-02T00:00:00Z"
                     }
                 ])),
                 methods::WATCH_SESSIONS => stream(json!([])),
+                methods::LIST_HARNESSES if remote => RpcReply::Value(json!([
+                    {"id":"codex", "name":"Remote Codex", "installed":true},
+                    {"id":"cursor", "name":"Disabled Cursor", "installed":true, "enabled":false}
+                ])),
                 methods::LIST_HARNESSES => RpcReply::Value(json!([
                     { "id": "claude-code", "name": "Claude Code", "supportsSteering": true,
                       "steeringMode": "step-boundary", "reasoningLevels": [], "installed": true, "enabled": true },
                     { "id": "codex", "name": "Codex", "supportsSteering": true,
                       "steeringMode": "turn-boundary", "reasoningLevels": [], "installed": false, "enabled": true }
                 ])),
+                methods::LIST_MODELS if remote => RpcReply::Value(json!([
+                    {"id":"remote-model", "label":"Remote model"}
+                ])),
                 methods::LIST_MODELS => RpcReply::Value(json!([
                     { "id": "opus", "label": "Opus" }, { "id": "sonnet", "label": "Sonnet" }
                 ])),
@@ -1298,7 +1469,7 @@ mod tests {
         let err = tools
             .call(
                 "create_chat",
-                json!({ "project": "comet", "model": "nope" }),
+                json!({ "project": "space-1", "model": "nope" }),
             )
             .await
             .unwrap_err();
@@ -1307,7 +1478,7 @@ mod tests {
         let created = tools
             .call(
                 "create_chat",
-                json!({ "project": "/repo/comet", "model": "sonnet", "title": "Review", "prompt": "go" }),
+                json!({ "project": "space-1", "model": "sonnet", "title": "Review", "prompt": "go" }),
             )
             .await
             .unwrap();
@@ -1339,7 +1510,7 @@ mod tests {
             },
         );
         let created = tools
-            .call("create_chat", json!({ "project": "/repo/comet" }))
+            .call("create_chat", json!({ "project": "space-1" }))
             .await
             .unwrap();
         assert_eq!(created["parentChatId"], "chat-beta-2");
@@ -1352,7 +1523,7 @@ mod tests {
         let created = tools
             .call(
                 "create_chat",
-                json!({ "project": "/repo/comet", "parent": "Alpha" }),
+                json!({ "project": "space-1", "parent": "Alpha" }),
             )
             .await
             .unwrap();
@@ -1360,7 +1531,7 @@ mod tests {
         let err = tools
             .call(
                 "create_chat",
-                json!({ "project": "/repo/comet", "parent": "nope" }),
+                json!({ "project": "space-1", "parent": "nope" }),
             )
             .await
             .unwrap_err();
@@ -1485,7 +1656,7 @@ mod tests {
                 device_id: None,
             },
         );
-        for args in [json!({}), json!({"parent":"Alpha"})] {
+        for args in [json!({}), json!({"parent":"Alpha"}), json!({"kind":"chat"})] {
             assert!(
                 side.call("create_chat", args)
                     .await
@@ -1494,7 +1665,10 @@ mod tests {
             );
         }
         let batch = side
-            .call("create_chats", json!({"requests":[{}, {"parent":"Alpha"}]}))
+            .call(
+                "create_chats",
+                json!({"requests":[{}, {"parent":"Alpha"}, {"kind":"chat"}]}),
+            )
             .await
             .unwrap();
         assert!(
@@ -1514,6 +1688,478 @@ mod tests {
         assert!(world.writes.lock().unwrap().is_empty());
     }
 
+    #[tokio::test]
+    async fn kinds_preserve_defaults_and_reject_invalid_arguments_before_writing() {
+        let world = Arc::new(World::default());
+        let root = tools(world.clone(), Origin::default());
+        for args in [
+            json!({"kind":"side"}),
+            json!({"kind":"unknown"}),
+            json!({"kind":"chat", "parent":"Alpha", "title":"must not write"}),
+        ] {
+            assert!(root.call("create_chat", args).await.is_err());
+        }
+        assert!(world.writes.lock().unwrap().is_empty());
+        let from_chat = tools(
+            world.clone(),
+            Origin {
+                chat_id: Some("chat-alpha-1".into()),
+                device_id: None,
+            },
+        );
+        for (args, kind, parent) in [
+            (json!({"kind":"chat"}), "chat", Value::Null),
+            (json!({"kind":"chat", "parent":"  "}), "chat", Value::Null),
+            (json!({"kind":"side"}), "side", json!("chat-alpha-1")),
+            (json!({}), "side", json!("chat-alpha-1")),
+            (json!({"parent":"Beta"}), "side", json!("chat-beta-2")),
+        ] {
+            let created = from_chat.call("create_chat", args).await.unwrap();
+            assert_eq!(created["kind"], kind);
+            assert_eq!(created["parentChatId"], parent);
+            let writes = world.writes.lock().unwrap();
+            let row = &writes.last().unwrap().1;
+            if kind == "chat" {
+                assert!(row.get("parentChatId").is_none());
+            } else {
+                assert_eq!(row["parentChatId"], parent);
+            }
+        }
+        assert_eq!(
+            root.call("create_chat", json!({})).await.unwrap()["kind"],
+            "chat"
+        );
+        assert_eq!(
+            root.call("create_chat", json!({"kind":"side", "parent":"Alpha"}))
+                .await
+                .unwrap()["kind"],
+            "side"
+        );
+    }
+
+    #[tokio::test]
+    async fn project_and_device_resolution_scopes_names_and_exact_paths() {
+        let world = Arc::new(World::default());
+        let tools = tools(world.clone(), Origin::default());
+        for args in [
+            json!({"project":"comet"}),
+            json!({"project":"/repo/comet"}),
+            json!({"project":"space-1", "device":"Worker"}),
+            json!({"project":"missing", "device":"Worker"}),
+            json!({"device":"missing"}),
+        ] {
+            let error = tools.call("create_chat", args).await.unwrap_err();
+            assert!(world.writes.lock().unwrap().is_empty(), "{error}");
+        }
+        let error = tools
+            .call("create_chat", json!({"project":"/repo/comet"}))
+            .await
+            .unwrap_err();
+        for candidate in ["space-1", "space-remote", "dev-local", "dev-remote"] {
+            assert!(error.contains(candidate), "{error}");
+        }
+        for project in ["comet", "/repo/comet", "space-remote"] {
+            let created = tools
+                .call("create_chat", json!({"project":project,"device":"Worker"}))
+                .await
+                .unwrap();
+            assert_eq!(created["deviceId"], "dev-remote");
+            assert_eq!(created["project"]["id"], "space-remote");
+            assert_eq!(created["harness"], "codex");
+        }
+        let created = tools
+            .call("create_chat", json!({"project":"unique"}))
+            .await
+            .unwrap();
+        assert_eq!(created["deviceId"], "dev-remote");
+        let created = tools
+            .call("create_chat", json!({"device":"dev-remote"}))
+            .await
+            .unwrap();
+        assert!(created["project"].is_null());
+        assert_eq!(created["deviceId"], "dev-remote");
+        let created = tools.call("create_chat", json!({})).await.unwrap();
+        assert_eq!(created["deviceId"], "dev-local");
+    }
+
+    #[tokio::test]
+    async fn discovery_and_creation_use_the_selected_hosts_catalogs() {
+        let world = Arc::new(World::default());
+        let tools = tools(world.clone(), Origin::default());
+        assert_eq!(
+            tools.call("list_projects", json!({})).await.unwrap()["projects"]
+                .as_array()
+                .unwrap()
+                .len(),
+            3
+        );
+        let projects = tools
+            .call("list_projects", json!({"device":"Worker"}))
+            .await
+            .unwrap();
+        assert_eq!(projects["projects"].as_array().unwrap().len(), 2);
+        assert!(
+            projects["projects"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .all(|p| p["deviceId"] == "dev-remote")
+        );
+        assert_eq!(
+            tools.call("list_harnesses", json!({})).await.unwrap()["harnesses"][0]["id"],
+            "claude-code"
+        );
+        assert_eq!(
+            tools
+                .call("list_harnesses", json!({"device":"Worker"}))
+                .await
+                .unwrap()["harnesses"][0]["id"],
+            "codex"
+        );
+        assert_eq!(
+            tools
+                .call("list_models", json!({"harness":"codex", "device":"Worker"}))
+                .await
+                .unwrap()["models"][0]["id"],
+            "remote-model"
+        );
+        assert_eq!(
+            tools
+                .call("list_models", json!({"harness":"claude-code"}))
+                .await
+                .unwrap()["models"][0]["id"],
+            "opus"
+        );
+        for args in [
+            json!({"device":"Worker", "harness":"claude-code"}),
+            json!({"device":"Worker", "harness":"cursor"}),
+            json!({"device":"Laptop", "harness":"codex"}),
+            json!({"device":"Laptop", "harness":"mock"}),
+            json!({"device":"Worker", "harness":"codex", "model":"opus"}),
+        ] {
+            assert!(tools.call("create_chat", args).await.is_err());
+            assert!(world.writes.lock().unwrap().is_empty());
+        }
+        let created = tools
+            .call(
+                "create_chat",
+                json!({"device":"Worker", "harness":"codex", "model":"remote-model"}),
+            )
+            .await
+            .unwrap();
+        assert_eq!(created["harness"], "codex");
+        assert_eq!(created["model"], "remote-model");
+        for method in [methods::LIST_HARNESSES, methods::LIST_MODELS] {
+            let broken = Arc::new(World {
+                catalog_error: Some(method),
+                ..Default::default()
+            });
+            let tools = self::tools(broken.clone(), Origin::default());
+            let error = tools
+                .call(
+                    "create_chat",
+                    json!({"device":"Worker", "model":"remote-model"}),
+                )
+                .await
+                .unwrap_err();
+            assert!(
+                error.contains("dev-remote") && error.contains("catalog unavailable"),
+                "{error}"
+            );
+            assert!(broken.writes.lock().unwrap().is_empty());
+        }
+    }
+
+    #[tokio::test]
+    async fn remote_send_selects_the_remote_default_harness() {
+        let world = Arc::new(World {
+            beta_remote: true,
+            ..Default::default()
+        });
+        let tools = tools(world.clone(), Origin::default());
+        tools
+            .call("send_message", json!({"chat":"Beta", "text":"go"}))
+            .await
+            .unwrap();
+        assert_eq!(
+            world.reads.lock().unwrap().last().unwrap().1["targetDeviceId"],
+            "dev-remote"
+        );
+        assert_eq!(
+            world.writes.lock().unwrap().last().unwrap().1["command"]["request"]["harness"],
+            "codex"
+        );
+    }
+
+    #[tokio::test]
+    async fn mixed_batch_preserves_order_and_errors_per_request() {
+        let world = Arc::new(World::default());
+        let tools = tools(
+            world.clone(),
+            Origin {
+                chat_id: Some("chat-alpha-1".into()),
+                device_id: None,
+            },
+        );
+        let result = tools
+            .call(
+                "create_chats",
+                json!({"requests":[
+                    {"kind":"chat", "device":"Worker", "project":"comet"},
+                    {"kind":"chat", "parent":"Alpha"},
+                    {"kind":"side", "project":"space-1"},
+                    {"kind":"bogus"}
+                ]}),
+            )
+            .await
+            .unwrap();
+        let results = &result["results"];
+        assert_eq!(results[0]["result"]["kind"], "chat");
+        assert_eq!(results[0]["result"]["deviceId"], "dev-remote");
+        assert_eq!(results[1]["isError"], true);
+        assert_eq!(results[2]["result"]["kind"], "side");
+        assert_eq!(results[2]["result"]["parentChatId"], "chat-alpha-1");
+        assert_eq!(results[3]["isError"], true);
+        for i in 0..4 {
+            assert_eq!(results[i]["index"], i);
+        }
+        assert_eq!(world.writes.lock().unwrap().len(), 2);
+    }
+
+    /// Sessions and transcripts are independently delivered. The command reply
+    /// is deliberately slow, so the assistant starts before QueueCommand returns.
+    struct DelayedTurn {
+        world: World,
+        sent: Mutex<Option<(i64, Instant, String)>>,
+        reply_delay: Duration,
+        never_reply: bool,
+        /// Host clock offset: a remote engine stamps createdAt on its own clock.
+        host_skew_millis: i64,
+    }
+
+    #[async_trait]
+    impl RpcService for DelayedTurn {
+        async fn handle(&self, method: &str, params: Value) -> Result<RpcReply, RpcError> {
+            match method {
+                methods::WATCH_CHATS => {
+                    let reply = self.world.handle(method, params).await?;
+                    let RpcReply::Stream(mut rows) = reply else {
+                        unreachable!()
+                    };
+                    let mut rows = rows.next().await.unwrap();
+                    if let Some((_, _, chat)) = self.sent.lock().unwrap().as_ref()
+                        && chat != "chat-beta-2"
+                    {
+                        rows.as_array_mut().unwrap().push(json!({
+                            "id": chat, "deviceId":"dev-remote", "archived":false,
+                            "createdAt":chrono::Utc::now(), "config":{"harness":"codex", "sandbox":"workspace-write"}
+                        }));
+                    }
+                    Ok(stream(rows))
+                }
+                methods::QUEUE_COMMAND => {
+                    let reply = self.world.handle(method, params.clone()).await?;
+                    *self.sent.lock().unwrap() = Some((
+                        now_millis(),
+                        Instant::now(),
+                        params["chatId"].as_str().unwrap().into(),
+                    ));
+                    tokio::time::sleep(Duration::from_millis(150)).await;
+                    Ok(reply)
+                }
+                methods::WATCH_SESSIONS => {
+                    let sent = self.sent.lock().unwrap().clone();
+                    let Some((_, _, chat)) = sent else {
+                        return Ok(stream(json!([])));
+                    };
+                    Ok(RpcReply::Stream(
+                        futures::stream::once(async { json!([]) })
+                            .chain(futures::stream::once(async move {
+                                tokio::time::sleep(Duration::from_millis(50)).await;
+                                json!([{"chatId":chat, "deviceId":"dev-remote", "status":"idle",
+                                "updatedAt":chrono::Utc::now(), "lastCompletedTurn":"new-turn"}])
+                            }))
+                            .boxed(),
+                    ))
+                }
+                methods::WATCH_DOC_MESSAGES => {
+                    let sent = self.sent.lock().unwrap().clone();
+                    // Only the existing chat has history. Its previous reply
+                    // shares the send's timestamp, so only its id tells them apart.
+                    let mut messages = json!([]);
+                    if params["chatId"] == "chat-beta-2" {
+                        let created_at = sent.as_ref().map_or_else(now_millis, |(t, _, _)| *t);
+                        messages.as_array_mut().unwrap().push(json!({
+                            "id":"previous-reply", "role":"assistant", "createdAt":created_at,
+                            "deviceId":"dev-remote", "status":"complete", "parts":[{"kind":"text", "id":"t", "text":"old reply"}]
+                        }));
+                    }
+                    if let Some((timestamp, started, _)) = sent
+                        && started.elapsed() >= self.reply_delay
+                        && !self.never_reply
+                    {
+                        messages.as_array_mut().unwrap().push(json!({
+                            "id":"new-reply", "role":"assistant", "createdAt":timestamp + self.host_skew_millis,
+                            "deviceId":"dev-remote", "status":"complete", "parts":[{"kind":"text", "id":"t", "text":"new reply"}]
+                        }));
+                    }
+                    Ok(stream(json!({"reset":messages})))
+                }
+                _ => self.world.handle(method, params).await,
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn wait_allows_a_missing_session_and_a_late_remote_transcript() {
+        for create in [true, false] {
+            let service = Arc::new(DelayedTurn {
+                world: World {
+                    beta_remote: true,
+                    ..Default::default()
+                },
+                sent: Mutex::new(None),
+                reply_delay: Duration::from_millis(450),
+                never_reply: false,
+                host_skew_millis: 0,
+            });
+            let tools = Tools::new(Arc::new(Zeron::with_client(
+                memory_client(service),
+                Origin::default(),
+            )));
+            let (name, args) = if create {
+                (
+                    "create_chat",
+                    json!({"kind":"chat", "device":"Worker", "prompt":"go", "wait":true, "timeout_secs":2}),
+                )
+            } else {
+                (
+                    "send_message",
+                    json!({"chat":"Beta", "text":"go", "wait":true, "timeout_secs":2}),
+                )
+            };
+            let result = tools.call(name, args).await.unwrap();
+            assert_eq!(result["turn"]["outcome"], "completed", "{result}");
+            assert_eq!(
+                result["turn"]["replies"].as_array().unwrap().len(),
+                1,
+                "{result}"
+            );
+            assert_eq!(result["turn"]["replies"][0]["text"], "new reply");
+        }
+    }
+
+    #[tokio::test]
+    async fn standalone_wait_after_nonblocking_send_keeps_the_send_baseline() {
+        for create in [true, false] {
+            let service = Arc::new(DelayedTurn {
+                world: World {
+                    beta_remote: true,
+                    ..Default::default()
+                },
+                sent: Mutex::new(None),
+                reply_delay: Duration::from_millis(450),
+                never_reply: false,
+                host_skew_millis: 0,
+            });
+            let tools = Tools::new(Arc::new(Zeron::with_client(
+                memory_client(service),
+                Origin::default(),
+            )));
+            let sent = if create {
+                tools
+                    .call(
+                        "create_chat",
+                        json!({"kind":"chat", "device":"Worker", "prompt":"go", "wait":false}),
+                    )
+                    .await
+                    .unwrap()
+            } else {
+                tools
+                    .call(
+                        "send_message",
+                        json!({"chat":"Beta", "text":"go", "wait":false}),
+                    )
+                    .await
+                    .unwrap()
+            };
+            let result = tools
+                .call(
+                    "wait_for_turn",
+                    json!({"chat":sent["chatId"], "timeout_secs":2}),
+                )
+                .await
+                .unwrap();
+            assert_eq!(result["turn"]["outcome"], "completed", "{result}");
+            assert_eq!(result["turn"]["replies"].as_array().unwrap().len(), 1);
+            assert_eq!(result["turn"]["replies"][0]["text"], "new reply");
+        }
+    }
+
+    /// A remote host stamps replies on its own clock. One running behind the
+    /// caller must not hide the reply to this send.
+    #[tokio::test]
+    async fn wait_returns_the_reply_from_a_host_whose_clock_is_behind() {
+        for create in [true, false] {
+            let service = Arc::new(DelayedTurn {
+                world: World {
+                    beta_remote: true,
+                    ..Default::default()
+                },
+                sent: Mutex::new(None),
+                reply_delay: Duration::from_millis(100),
+                never_reply: false,
+                host_skew_millis: -30_000,
+            });
+            let tools = Tools::new(Arc::new(Zeron::with_client(
+                memory_client(service),
+                Origin::default(),
+            )));
+            let (name, args) = if create {
+                (
+                    "create_chat",
+                    json!({"kind":"chat", "device":"Worker", "prompt":"go", "wait":true, "timeout_secs":2}),
+                )
+            } else {
+                (
+                    "send_message",
+                    json!({"chat":"Beta", "text":"go", "wait":true, "timeout_secs":2}),
+                )
+            };
+            let result = tools.call(name, args).await.unwrap();
+            assert_eq!(result["turn"]["outcome"], "completed", "{result}");
+            let replies = result["turn"]["replies"].as_array().unwrap();
+            assert!(replies.iter().any(|r| r["text"] == "new reply"), "{result}");
+        }
+    }
+
+    #[tokio::test]
+    async fn completed_session_without_new_transcript_times_out_without_old_reply() {
+        let service = Arc::new(DelayedTurn {
+            world: World {
+                beta_remote: true,
+                ..Default::default()
+            },
+            sent: Mutex::new(None),
+            reply_delay: Duration::ZERO,
+            never_reply: true,
+            host_skew_millis: 0,
+        });
+        let tools = Tools::new(Arc::new(Zeron::with_client(
+            memory_client(service),
+            Origin::default(),
+        )));
+        let result = tools
+            .call(
+                "send_message",
+                json!({"chat":"Beta", "text":"go", "wait":true, "timeout_secs":1}),
+            )
+            .await
+            .unwrap();
+        assert_eq!(result["turn"]["outcome"], "timedOut");
+        assert_eq!(result["turn"]["replies"], json!([]));
+    }
+
     #[tokio::test]
     async fn initialize_and_list_over_jsonrpc() {
         let world = Arc::new(World::default());
diff --git a/crates/mcp/src/zeron.rs b/crates/mcp/src/zeron.rs
index d31767d22c..ac75e7ab5c 100644
--- a/crates/mcp/src/zeron.rs
+++ b/crates/mcp/src/zeron.rs
@@ -244,22 +244,66 @@ impl Zeron {
     }
 
     pub async fn harnesses(&self) -> anyhow::Result<Vec<HarnessInfo>> {
-        let value = self.call(methods::LIST_HARNESSES, json!({})).await?;
-        serde_json::from_value(value).context("ListHarnesses: unexpected shape")
+        self.harnesses_on(None).await
+    }
+
+    pub async fn harnesses_on(&self, device: Option<&str>) -> anyhow::Result<Vec<HarnessInfo>> {
+        let mut params = json!({});
+        if let Some(device) = device {
+            params["targetDeviceId"] = json!(device);
+        }
+        let value = self
+            .call(methods::LIST_HARNESSES, params)
+            .await
+            .with_context(|| format!("harness catalog on device {}", device.unwrap_or("local")))?;
+        serde_json::from_value(value).with_context(|| {
+            format!(
+                "ListHarnesses: unexpected catalog on device {}",
+                device.unwrap_or("local")
+            )
+        })
     }
 
     pub async fn models(&self, harness: HarnessId) -> anyhow::Result<Vec<Model>> {
+        self.models_on(harness, None).await
+    }
+
+    pub async fn models_on(
+        &self,
+        harness: HarnessId,
+        device: Option<&str>,
+    ) -> anyhow::Result<Vec<Model>> {
+        let mut params = json!({ "harness": harness });
+        if let Some(device) = device {
+            params["targetDeviceId"] = json!(device);
+        }
         let value = self
-            .call(methods::LIST_MODELS, json!({ "harness": harness }))
-            .await?;
-        serde_json::from_value(value).context("ListModels: unexpected shape")
+            .call(methods::LIST_MODELS, params)
+            .await
+            .with_context(|| format!("model catalog on device {}", device.unwrap_or("local")))?;
+        serde_json::from_value(value).with_context(|| {
+            format!(
+                "ListModels: unexpected catalog on device {}",
+                device.unwrap_or("local")
+            )
+        })
     }
 
     /// The full transcript: attach, take the opening `reset` frame, detach.
     pub async fn transcript(&self, chat_id: &str) -> anyhow::Result<Vec<SessionMessageEntry>> {
-        let mut rx = self
-            .subscribe(methods::WATCH_DOC_MESSAGES, json!({ "chatId": chat_id }))
-            .await?;
+        self.transcript_on(chat_id, None).await
+    }
+
+    pub async fn transcript_on(
+        &self,
+        chat_id: &str,
+        device: Option<&str>,
+    ) -> anyhow::Result<Vec<SessionMessageEntry>> {
+        let mut params = json!({ "chatId": chat_id });
+        if let Some(device) = device {
+            params["targetDeviceId"] = json!(device);
+        }
+        let mut rx = self.subscribe(methods::WATCH_DOC_MESSAGES, params).await?;
         let mut entries = Vec::new();
         let deadline = Instant::now() + SNAPSHOT_TIMEOUT;
         loop {
@@ -348,6 +392,43 @@ impl Zeron {
         resolve_space_in(&spaces, key.trim())
     }
 
+    /// Resolve the host first when specified, so repeated project names/paths
+    /// on other machines cannot influence selection.
+    pub async fn resolve_target(
+        &self,
+        project: Option<&str>,
+        device: Option<&str>,
+    ) -> anyhow::Result<(Option<Space>, String)> {
+        let device = device.map(str::trim).filter(|d| !d.is_empty());
+        let host = match device {
+            Some(key) => Some(self.resolve_device_id(Some(key)).await?),
+            None => None,
+        };
+        if let Some(project) = project {
+            let mut spaces = self.spaces().await?;
+            if let Some(host) = &host {
+                if let Some(space) = spaces.iter().find(|s| s.id == project.trim()) {
+                    anyhow::ensure!(
+                        space.device_id == *host,
+                        "project {} belongs to device {}, not device {host}",
+                        space.id,
+                        space.device_id
+                    );
+                }
+                spaces.retain(|s| s.device_id == *host);
+            }
+            let space = resolve_space_in(&spaces, project.trim())?;
+            return Ok((Some(space.clone()), space.device_id));
+        }
+        Ok((
+            None,
+            match host {
+                Some(host) => host,
+                None => self.local_device_id().await?,
+            },
+        ))
+    }
+
     /// Device id or exact name; `None` means this engine's own device.
     pub async fn resolve_device_id(&self, key: Option<&str>) -> anyhow::Result<String> {
         let Some(key) = key.map(str::trim).filter(|k| !k.is_empty()) else {
@@ -531,17 +612,18 @@ pub fn resolve_space_in(spaces: &[Space], key: &str) -> anyhow::Result<Space> {
     if key.is_empty() {
         bail!("project is required");
     }
-    if let Some(space) = spaces.iter().find(|s| s.id == key || s.path == key) {
+    if let Some(space) = spaces.iter().find(|s| s.id == key) {
         return Ok(space.clone());
     }
     let normalized = key.trim_end_matches(['/', '\\']);
+    let by_path: Vec<&Space> = spaces
+        .iter()
+        .filter(|s| s.path.trim_end_matches(['/', '\\']) == normalized)
+        .collect();
     let by_name: Vec<&Space> = spaces
         .iter()
         .filter(|s| s.display_name().eq_ignore_ascii_case(normalized))
         .collect();
-    if let [one] = by_name.as_slice() {
-        return Ok((*one).clone());
-    }
     let by_suffix: Vec<&Space> = spaces
         .iter()
         .filter(|s| {
@@ -549,21 +631,23 @@ pub fn resolve_space_in(spaces: &[Space], key: &str) -> anyhow::Result<Space> {
             path.ends_with(normalized) || path.contains(normalized)
         })
         .collect();
-    if let [one] = by_suffix.as_slice() {
-        return Ok((*one).clone());
-    }
-    let candidates = if by_name.len() > 1 {
+    let candidates = if !by_path.is_empty() {
+        &by_path
+    } else if !by_name.is_empty() {
         &by_name
     } else {
         &by_suffix
     };
+    if let [one] = candidates.as_slice() {
+        return Ok((*one).clone());
+    }
     if candidates.len() > 1 {
         bail!(
             "{} projects match {key:?}; use an id: {}",
             candidates.len(),
             candidates
                 .iter()
-                .map(|s| format!("{} ({})", s.path, s.id))
+                .map(|s| format!("{} (id {}, device {})", s.path, s.id, s.device_id))
                 .collect::<Vec<_>>()
                 .join(", ")
         );
@@ -692,6 +776,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn repeated_exact_paths_and_names_do_not_select_the_first_project() {
+        let mut remote = space("s2", "/repo/comet", Some("remote"));
+        remote.device_id = "other-device".into();
+        let spaces = [space("s1", "/repo/comet", None), remote];
+        let err = resolve_space_in(&spaces, "/repo/comet/")
+            .unwrap_err()
+            .to_string();
+        for candidate in ["s1", "s2", "dev", "other-device"] {
+            assert!(err.contains(candidate), "{err}");
+        }
+        // A unique path suffix must not override ambiguous display names.
+        let spaces = [
+            space("s1", "/repo/comet", None),
+            space("s2", "/repo/other", Some("comet")),
+        ];
+        assert!(resolve_space_in(&spaces, "comet").is_err());
+    }
+
     #[test]
     fn space_resolution_accepts_id_path_name_or_suffix() {
         let spaces = vec![
diff --git a/docs/mcp.md b/docs/mcp.md
index 12369c9b28..0cf820a675 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -31,18 +31,28 @@ instructions in the stored prompt for agents.
 
 ### Parent links
 
-A chat created through `create_chat` records the creating chat as its parent:
-`Chat.parent_chat_id` (proto) ⇄ `parentChatId` on the registry/workspace chat
-row (`Mutate createChat { parentChatId? }` → `WorkspaceHost::create_chat_with_parent`).
-Chats with a parent cannot create chats through MCP, including batch creation
-or an explicit parent override. A side chat cannot be selected as a parent;
-only one level of side chats is supported.
-
-The default is the origin chat (`ZERON_CHAT_ID`); an explicit `parent` argument
-(id, prefix, or title) overrides it. `list_chats { parent }` returns a chat's
-children, and every chat summary carries `parentChatId`. The field is additive
-and serde-defaulted: rows written by older engines read as parentless, and a
-dangling id (parent deleted) is tolerated rather than cascaded.
+`create_chat` and each request in `create_chats` accept `kind`:
+
+| Input | Placement |
+| --- | --- |
+| `kind: "chat"` | Standalone session, visible in the left **Sessions** sidebar; no `parentChatId` is written. |
+| `kind: "side"` | Child of the explicit `parent` or origin chat. Requires one of those. |
+| Kind omitted, origin or parent supplied | Child, preserving the previous default. |
+| Kind omitted, no origin or parent | Standalone, preserving terminal usage. |
+
+`kind: "chat"` with a nonempty `parent`, `kind: "side"` without an origin/parent,
+and unknown kinds fail before any writes. Empty `parent` uses the default.
+The creation result includes the effective `kind`, `chatId`, `deviceId`,
+`project` and `parentChatId`. Kind is derived from the parent; it is not persisted.
+
+Children record `Chat.parent_chat_id` (proto) ⇄ `parentChatId` on the registry
+row (`Mutate createChat { parentChatId? }`). Chats with a parent cannot create
+chats through MCP, including standalone and batch creation or an explicit parent
+override. A side chat cannot be selected as a parent; only one level is supported.
+
+For children, `parent` (id, prefix, or title) overrides the origin (`ZERON_CHAT_ID`).
+`list_chats { parent }` returns children, and chat summaries carry `parentChatId`.
+Rows from older engines read as parentless; a dangling parent id is tolerated.
 
 The left sidebar hides chats that have a parent: `AppState::visible_chats`
 (the Sessions list, project tabs, jump slots) and the Archived section both
@@ -89,7 +99,7 @@ the transcript draws it as "This chat was forked from <title>". `parentChatId`
 defaults to the source; a side chat's own fork button passes its parent so
 the copy lists as a sibling. The file explorer's footer lists a chat's
 **Subagents** (its spawn chips) and **Chats** (its children: forks and
-`create_chat` spawns) and opens either in the right pane.
+`kind: "side"` spawns) and opens either in the right pane.
 
 ## Tools
 
@@ -102,8 +112,8 @@ name (default: the local engine's device).
 | `whoami`           | `LocalDevice`, `EngineInfo`, origin chat summary          |
 | `list_devices`     | `WatchDevices` snapshot                                   |
 | `list_projects`    | `WatchSpaces` snapshot                                    |
-| `list_harnesses`   | `ListHarnesses`                                           |
-| `list_models`      | `ListModels {harness}`                                    |
+| `list_harnesses`   | `ListHarnesses {targetDeviceId?}`                          |
+| `list_models`      | `ListModels {harness, targetDeviceId?}`                                    |
 | `list_chats`       | `WatchChats` + `WatchSessions` snapshots (status merged)  |
 | `get_chat`         | above + `WatchDocMessages` opening frame (pending input)  |
 | `create_chat`      | `Mutate createChat` (+ `renameChat`; optional first send) |
@@ -156,6 +166,74 @@ edge. A brand-new chat has no session row until the host picks the run up, so
 the wait keeps waiting in that case rather than reporting the unstarted run as
 done (this was the one bug the first live run found).
 
+## Selecting a host and project
+
+`list_projects {device?}` filters by device id or exact name; without arguments
+it lists all projects. `list_harnesses {device?}` and
+`list_models {harness, device?}` query the selected host with `targetDeviceId`;
+without `device` they retain the local engine catalogs.
+
+For creation, project alone determines the host. Device alone creates a session
+without a project on that device. With both, the project is resolved **within**
+the selected device, and a project id belonging to another device is rejected.
+Neither argument means a projectless session on the local engine. Repeated names
+or paths are errors with candidate ids and devices; use ids from discovery.
+
+Before writing, creation checks the chosen engine's harness catalog, chooses
+its available default (Claude Code when available, otherwise the first available
+non-mock harness), and validates any explicit model against that host's catalog.
+An explicit harness must be offered, installed and enabled. Catalog failures,
+including model lookup failures, are returned with the device id; there is no
+fallback to the local catalog. A successful remote query checks reachability;
+`lastSeenAt` alone does not establish that an engine is online.
+
+Discover and launch a standalone session:
+
+```text
+list_devices {}
+list_projects { device: "<device-id>" }
+list_harnesses { device: "<device-id>" }
+list_models { device: "<device-id>", harness: "codex" }
+create_chat {
+  kind: "chat",
+  device: "<device-id>",
+  project: "<project-id>",
+  harness: "codex",
+  model: "<model-id from that host's catalog>",
+  title: "Implement feature",
+  prompt: "Implement the feature...",
+  wait: false
+}
+```
+
+Without a project (the host uses its home directory unless `cwd` is given):
+
+```json
+{"kind":"chat", "device":"<device-id>", "harness":"codex", "prompt":"Reply with pong", "wait":true}
+```
+
+A mixed `create_chats` batch, with an origin chat or explicit top-level parent:
+
+```json
+{
+  "requests": [
+    {"kind":"chat", "device":"<device-id>", "project":"<project-id>", "title":"Feature", "prompt":"Implement the feature"},
+    {"kind":"side", "parent":"<parent-chat-id>", "project":"<project-id>", "prompt":"Review the API"}
+  ]
+}
+```
+
+The first prompt and later sends use durable chat commands drained by the host.
+Transcript reads target the chat's host; session status comes from the shared
+registry. Sends remember the session and existing message ids on the MCP connection before
+sending, so a subsequent `wait_for_turn` after `wait:false` waits for that send,
+even before a session row appears. A separate MCP server has no send baseline
+and reports the chat's current posture. Creation records the send time before dispatching its first
+prompt. If completion arrives before the transcript, the wait allows the new
+assistant response to arrive within the **same timeout**. A previous response
+is never substituted for a missing response to a new send. An unfinished
+transcript or missing response at the deadline returns `timedOut`.
+
 ## Parallel side chats
 
 Use `create_chats` with a `requests` array to launch independent workers in
@@ -195,3 +273,16 @@ BIN=target/debug/zeron
 against a live daemon returns the assistant's `pong` in a few seconds; archive
 the chat afterwards with `archive_chat`. Unit tests (`cargo test -p zeron-mcp`)
 drive the whole tool set against an in-memory stub `RpcService`.
+
+An isolated stdio instance is available with
+`cargo run -p zeron-engine --example mcp_standalone_smoke`. It provides a temporary
+project, an origin coordinator and a scripted `codex` adapter (`smoke-1`) returning
+`pong`. Discover its ids with the list tools, create `kind: "chat"` with a prompt
+and `wait: true`, then check `read_chat`, `send_message` and a mixed batch. The
+profile is removed on exit. This checks MCP dispatch and engine execution without
+changing your running app's sessions or requiring provider credentials.
+
+The `mcp_standalone_session_executes_on_the_selected_device` test in
+`device_routing` additionally runs two engines with a shared registry and device
+relay, verifies execution on the selected host (and absence of execution on the
+caller), and retrieves responses through MCP.

From c14d45796c601763fc902bc6c40e5a2d724f8949 Mon Sep 17 00:00:00 2001
From: "Arman K." <93446465+armans-code@users.noreply.github.com>
Date: Fri, 2 Oct 2026 16:44:53 -0400
Subject: [PATCH 31/74] Let the composer's session branch label use free width
 and fade on overflow (#744)

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 crates/ui/src/pickers.rs | 33 ++++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 97d64d480e..656fc86331 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -3078,13 +3078,31 @@ impl Pickers {
     /// A read-only footer label (locked sessions — t3code's
     /// `resolveLockedWorkspaceLabel` span).
     fn footer_label(icon_path: &'static str, label: SharedString, theme: &Theme) -> gpui::Div {
+        Self::footer_label_shell(icon_path, theme)
+            .max_w(px(160.0))
+            .child(div().min_w_0().truncate().child(label))
+    }
+
+    /// A [`Self::footer_label`] that takes whatever width the row leaves it
+    /// and fades its tail only when that isn't enough.
+    fn footer_faded_label(
+        id: &'static str,
+        icon_path: &'static str,
+        label: SharedString,
+        theme: &Theme,
+    ) -> gpui::Div {
+        Self::footer_label_shell(icon_path, theme).child(crate::shell::sidebar_faded_label(
+            id.into(),
+            false,
+            label,
+        ))
+    }
+
+    fn footer_label_shell(icon_path: &'static str, theme: &Theme) -> gpui::Div {
         div()
             .h(px(20.0))
-            // Four of these share one row now (device, project, checkout,
-            // ref): cap each early and let them SHRINK (`min_w_0`) — without
-            // it the clusters overflowed into each other and the labels
-            // painted overlapped (user report).
-            .max_w(px(160.0))
+            // Labels SHRINK (`min_w_0`) — without it the clusters overflowed
+            // into each other and the labels painted overlapped (user report).
             .min_w_0()
             .flex()
             .flex_row()
@@ -3097,9 +3115,9 @@ impl Pickers {
             .child(
                 crate::icons::icon(icon_path)
                     .size(px(12.0))
+                    .flex_none()
                     .text_color(theme.text_muted.opacity(0.6)),
             )
-            .child(div().min_w_0().truncate().child(label))
     }
 
     /// New-session destination controls. Machine and project form the
@@ -3309,7 +3327,8 @@ impl Pickers {
                 .items_center()
                 .gap(px(4.0))
                 .min_w_0()
-                .child(Self::footer_label(
+                .child(Self::footer_faded_label(
+                    "composer-session-branch",
                     crate::icons::GIT_BRANCH,
                     chat.branch
                         .clone()

From 542febc10b3d944cbd17e315a273a1cedc8c1290 Mon Sep 17 00:00:00 2001
From: "Arman K." <93446465+armans-code@users.noreply.github.com>
Date: Fri, 2 Oct 2026 16:45:24 -0400
Subject: [PATCH 32/74] Toggle fast mode with F in the compact model picker
 (#745)

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 crates/ui/src/pickers.rs         | 15 ++++++++++++++-
 crates/ui/src/pickers/compact.rs |  9 ++++++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 656fc86331..1c796bc5dd 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -8043,7 +8043,7 @@ mod tests {
             Pickers::new(state, cx)
         });
         handle
-            .update(cx, |pickers, _, cx| {
+            .update(cx, |pickers, window, cx| {
                 let mut grok = bare_model("grok-4.6", "Grok 4.6");
                 grok.options = vec![ModelOption {
                     id: "fast".into(),
@@ -8073,6 +8073,19 @@ mod tests {
                 pickers.pick_option(option, next, default, cx);
                 assert!(pickers.compact_fast_choice(cx).unwrap().3);
                 assert!(!pickers.explicit_options(cx).contains_key("fast"));
+                // F on the open panel flips it the same way.
+                pickers.open.open(PickerKind::HarnessModel);
+                let key = |key: &str| KeyDownEvent {
+                    keystroke: gpui::Keystroke::parse(key).unwrap(),
+                    is_held: false,
+                    prefer_character_input: false,
+                };
+                pickers.on_key_down(&key("f"), window, cx);
+                assert!(!pickers.compact_fast_choice(cx).unwrap().3);
+                pickers.on_key_down(&key("cmd-f"), window, cx);
+                assert!(!pickers.compact_fast_choice(cx).unwrap().3);
+                pickers.on_key_down(&key("f"), window, cx);
+                assert!(pickers.compact_fast_choice(cx).unwrap().3);
             })
             .unwrap();
     }
diff --git a/crates/ui/src/pickers/compact.rs b/crates/ui/src/pickers/compact.rs
index 9cbfeb46ed..885e38b240 100644
--- a/crates/ui/src/pickers/compact.rs
+++ b/crates/ui/src/pickers/compact.rs
@@ -827,11 +827,18 @@ impl Pickers {
 
     /// The panel's shortcuts, live only while it is the picker's page: Up
     /// and Down open the model list on the model beside the selected one,
-    /// Tab cycles providers, Left/Right (Home/End) set the effort.
+    /// Tab cycles providers, Left/Right (Home/End) set the effort, F toggles
+    /// fast mode.
     pub(super) fn compact_panel_key(&mut self, event: &KeyDownEvent, cx: &mut Context<Self>) {
         self.compact_keyboard = true;
         match event.keystroke.key.as_str() {
             "escape" => self.animate_close(cx),
+            "f" if !event.keystroke.modifiers.modified() => {
+                let Some((option, choice, default, _)) = self.compact_fast_choice(cx) else {
+                    return;
+                };
+                self.pick_option(option, choice, default, cx);
+            }
             "up" | "down" => {
                 self.show_compact_models(cx);
                 let delta = if event.keystroke.key == "up" { -1 } else { 1 };

From 1f7b74a7fc97b0ca1d0379e77141075d73db8adf Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Fri, 2 Oct 2026 14:39:30 -0700
Subject: [PATCH 33/74] Todo: dedicated panel for the agent's checklist (#707)

* Todo: additive in-progress status on checklist items

Claude TodoWrite, OpenCode, ACP plans and Codex update_plan expose an
in-progress step that TodoItem flattened into done/not-done. Add a serde-
defaulted status (written only for in-progress, so existing docs are byte-
identical and old builds/edge ignore it; unknown values derive from done),
map it in every normalizer, and wire Codex turn/plan/updated into the live
plan chip.

* Todo: dedicated panel above the composer

The agent's checklist is now a tray stacked above the queue/composer: a
collapsed header (Todo 2/5 plus the current item), an expanded list with
check / active / pending glyphs, and a 3-item focus window with N earlier /
N later fold rows for lists over 6. Open state is remembered per chat for the
app run, a finished list tidies itself to a compact done state once the turn
is idle, and every control is keyboard reachable with tooltips. The
transcript chip's detail marks the in-progress item [~].

* Todo: design note, mock checklist knob, screenshots

ZERON_MOCK_TODO walks an 8-item list through every panel state for live
checks; docs/todo-panel.md records the data model, behaviour and limits.

* Todo: let an abandoned list be dismissed while the turn is idle

The dismiss button only appeared once every item was done, so a list that
can never finish stayed pinned: an OpenCode or Cursor item marked
cancelled (read as pending), or a list left mid-way by an interrupted
turn. Offer dismiss whenever the turn is idle; the dismissal still holds
only until the agent writes a different list.

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

---------

Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 CONTRIBUTORS.md                               |    1 +
 crates/client/src/demo/transcripts.rs         |   23 +-
 crates/doc/src/schema.rs                      |   58 +
 crates/harness/src/acp/normalize.rs           |   20 +-
 crates/harness/src/claude/normalize.rs        |   35 +-
 crates/harness/src/codex/mod.rs               |    8 +
 crates/harness/src/codex/normalize.rs         |   74 +-
 crates/harness/src/cursor/mod.rs              |   24 +-
 crates/harness/src/mock.rs                    |   61 +
 crates/harness/src/opencode/mod.rs            |   17 +-
 crates/harness/src/opencode/tests.rs          |   19 +-
 crates/harness/tests/acp.rs                   |   12 +-
 crates/harness/tests/codex.rs                 |   12 +-
 crates/proto/src/agent.rs                     |  132 ++
 crates/ui/src/composer.rs                     |   15 +
 crates/ui/src/lib.rs                          |    1 +
 crates/ui/src/queue.rs                        |    4 +-
 crates/ui/src/todo_panel.rs                   | 1142 +++++++++++++++++
 crates/ui/src/transcript.rs                   |   32 +-
 .../todo-panel/collapsed-headline.png         |  Bin 0 -> 20360 bytes
 docs/screenshots/todo-panel/done-compact.png  |  Bin 0 -> 22586 bytes
 .../todo-panel/expanded-folded.png            |  Bin 0 -> 32338 bytes
 docs/todo-panel.md                            |  100 ++
 edge/src/session-doc/control-types.ts         |   10 +-
 edge/src/session-doc/render-parts.ts          |   15 +-
 edge/src/session-doc/todo-items.test.ts       |   21 +
 26 files changed, 1731 insertions(+), 105 deletions(-)
 create mode 100644 crates/ui/src/todo_panel.rs
 create mode 100644 docs/screenshots/todo-panel/collapsed-headline.png
 create mode 100644 docs/screenshots/todo-panel/done-compact.png
 create mode 100644 docs/screenshots/todo-panel/expanded-folded.png
 create mode 100644 docs/todo-panel.md
 create mode 100644 edge/src/session-doc/todo-items.test.ts

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 00a0a6e56c..80eb6cd94c 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -49,6 +49,7 @@ Useful knobs for exercising the UI without a real agent or account:
 | `ZERON_HARNESS=mock` | Offers the mock harness, which streams canned turns |
 | `ZERON_MOCK_SUBAGENT=1` | Mock turns spawn subagents |
 | `ZERON_MOCK_THINKING=1` | Mock turns include markdown-heavy thinking |
+| `ZERON_MOCK_TODO=1` | Mock turns work through an 8-item checklist (pair with `ZERON_MOCK_DELAY_MS=900` to watch the todo panel) |
 
 ## Tests
 
diff --git a/crates/client/src/demo/transcripts.rs b/crates/client/src/demo/transcripts.rs
index e0f0d5d36e..758c84aace 100644
--- a/crates/client/src/demo/transcripts.rs
+++ b/crates/client/src/demo/transcripts.rs
@@ -5,7 +5,7 @@
 //! for benchmarks, and the scripted streaming reply.
 
 use zeron_doc::{MessagePart, MessageRole, MessageStatus, SessionMessageEntry, ToolDiffStat};
-use zeron_proto::{TodoItem, ToolCall, UserInputQuestion};
+use zeron_proto::{TodoItem, TodoStatus, ToolCall, UserInputQuestion};
 
 pub(crate) const PHONE: &str = "ios-demo";
 
@@ -288,18 +288,15 @@ fn veil(host: &str, now: i64) -> Vec<SessionMessageEntry> {
                     "k3",
                     ToolCall::Todo {
                         items: vec![
-                            TodoItem {
-                                text: "Snap chunk splits to grapheme clusters".into(),
-                                done: true,
-                            },
-                            TodoItem {
-                                text: "Table test for ZWJ sequences".into(),
-                                done: true,
-                            },
-                            TodoItem {
-                                text: "Measure veil cost on 600-turn transcript".into(),
-                                done: false,
-                            },
+                            TodoItem::new(
+                                "Snap chunk splits to grapheme clusters",
+                                TodoStatus::Completed,
+                            ),
+                            TodoItem::new("Table test for ZWJ sequences", TodoStatus::Completed),
+                            TodoItem::new(
+                                "Measure veil cost on 600-turn transcript",
+                                TodoStatus::Pending,
+                            ),
                         ],
                     },
                     false,
diff --git a/crates/doc/src/schema.rs b/crates/doc/src/schema.rs
index 8dc8845809..bc68b3bf8e 100644
--- a/crates/doc/src/schema.rs
+++ b/crates/doc/src/schema.rs
@@ -1552,6 +1552,64 @@ mod tests {
         assert_eq!(doc.chat_id().as_deref(), Some("chat-1"));
     }
 
+    #[test]
+    fn todo_status_survives_the_doc_and_refreshes_in_place() {
+        use zeron_proto::{TodoItem, TodoStatus};
+        let todo = |items: Vec<TodoItem>| MessagePart::Tool {
+            // The ACP/Codex plan reuses one id for every update.
+            id: zeron_proto::LIVE_PLAN_TOOL_ID.into(),
+            call: ToolCall::Todo { items },
+            is_error: false,
+            resolved: true,
+            output: None,
+            diff: None,
+            output_ref: None,
+            output_bytes: None,
+            diff_ref: None,
+            diff_stats: None,
+            subagent_ref: None,
+            subagent_status: None,
+            subagent_tail: None,
+        };
+        let doc = SessionDoc::init("c1").unwrap();
+        let mut w = SegmentWriter::begin(&doc, "e1", "dev", 1).unwrap();
+        let first = todo(vec![
+            TodoItem::new("read", TodoStatus::InProgress),
+            TodoItem::new("fix", TodoStatus::Pending),
+        ]);
+        w.sync(std::slice::from_ref(&first)).unwrap();
+        assert_eq!(doc.read_entries().unwrap()[0].parts, vec![first]);
+        // The next plan update rewrites the same part, in-progress moved on.
+        let second = todo(vec![
+            TodoItem::new("read", TodoStatus::Completed),
+            TodoItem::new("fix", TodoStatus::InProgress),
+        ]);
+        w.sync(std::slice::from_ref(&second)).unwrap();
+        let entries = doc.read_entries().unwrap();
+        assert_eq!(entries[0].parts, vec![second]);
+    }
+
+    #[test]
+    fn legacy_todo_part_without_status_still_reads() {
+        // Written by a build that only knew `done`.
+        let part: DocPartJson = serde_json::from_value(serde_json::json!({
+            "id": "t", "kind": "tool", "isError": false,
+            "call": { "kind": "todo", "items": [
+                { "text": "a", "done": true }, { "text": "b", "done": false }
+            ]}
+        }))
+        .unwrap();
+        let MessagePart::Tool {
+            call: ToolCall::Todo { items },
+            ..
+        } = from_doc_part(part)
+        else {
+            panic!("a legacy todo part must still decode");
+        };
+        assert_eq!(items[0].status(), zeron_proto::TodoStatus::Completed);
+        assert_eq!(items[1].status(), zeron_proto::TodoStatus::Pending);
+    }
+
     #[test]
     fn segment_sync_persists_subagent_chip_fields_on_live_parts() {
         // The eager-done world's OTHER path: the chip mutates while its
diff --git a/crates/harness/src/acp/normalize.rs b/crates/harness/src/acp/normalize.rs
index e828fc897a..c524b727a4 100644
--- a/crates/harness/src/acp/normalize.rs
+++ b/crates/harness/src/acp/normalize.rs
@@ -9,7 +9,7 @@
 //! statuses are snake_case).
 
 use serde_json::Value;
-use zeron_proto::{AgentEvent, SlashCommand, TodoItem, ToolCall, ToolDiff};
+use zeron_proto::{AgentEvent, SlashCommand, TodoItem, TodoStatus, ToolCall, ToolDiff};
 
 /// Byte cap applied to tool output text at the harness boundary. The doc-side
 /// fold applies its own (smaller) cap before anything persists; this one only
@@ -403,9 +403,11 @@ pub(crate) fn map_update(update: &Value) -> Vec<AgentEvent> {
                 .map(|a| a.as_slice())
                 .unwrap_or_default()
                 .iter()
-                .map(|e| TodoItem {
-                    text: str_field(e, "content"),
-                    done: e.get("status").and_then(Value::as_str) == Some("completed"),
+                .map(|e| {
+                    TodoItem::new(
+                        str_field(e, "content"),
+                        TodoStatus::parse(e.get("status").and_then(Value::as_str).unwrap_or("")),
+                    )
                 })
                 .collect();
             // The plan has no wire id; a stable synthetic id makes every
@@ -659,14 +661,8 @@ mod tests {
                 id: zeron_proto::LIVE_PLAN_TOOL_ID.into(),
                 call: ToolCall::Todo {
                     items: vec![
-                        TodoItem {
-                            text: "read code".into(),
-                            done: true
-                        },
-                        TodoItem {
-                            text: "write fix".into(),
-                            done: false
-                        },
+                        TodoItem::new("read code", TodoStatus::Completed),
+                        TodoItem::new("write fix", TodoStatus::InProgress),
                     ]
                 },
             }
diff --git a/crates/harness/src/claude/normalize.rs b/crates/harness/src/claude/normalize.rs
index 2d20c6edd5..da3dfbe521 100644
--- a/crates/harness/src/claude/normalize.rs
+++ b/crates/harness/src/claude/normalize.rs
@@ -2,7 +2,7 @@
 //! decoding, error-code mapping).
 
 use serde_json::Value;
-use zeron_proto::{AgentEvent, DoneStatus, HarnessId, TodoItem, ToolCall};
+use zeron_proto::{AgentEvent, DoneStatus, HarnessId, TodoItem, TodoStatus, ToolCall};
 
 use super::wire::{ContentBlock, Frame};
 
@@ -106,9 +106,11 @@ pub(crate) fn decode_tool_use(name: &str, input: &Value) -> ToolCall {
                 .map(|a| a.as_slice())
                 .unwrap_or_default()
                 .iter()
-                .map(|t| TodoItem {
-                    text: str_field(t, "content"),
-                    done: t.get("status").and_then(Value::as_str) == Some("completed"),
+                .map(|t| {
+                    TodoItem::new(
+                        str_field(t, "content"),
+                        TodoStatus::parse(t.get("status").and_then(Value::as_str).unwrap_or("")),
+                    )
                 })
                 .collect(),
         },
@@ -803,10 +805,27 @@ mod tests {
                 &json!({"todos": [{"content": "t", "status": "completed"}]})
             ),
             ToolCall::Todo {
-                items: vec![TodoItem {
-                    text: "t".into(),
-                    done: true
-                }]
+                items: vec![TodoItem::new("t", TodoStatus::Completed)]
+            }
+        );
+        // Claude's in-progress state survives; unknown/missing reads as pending.
+        assert_eq!(
+            decode_tool_use(
+                "TodoWrite",
+                &json!({"todos": [
+                    {"content": "a", "status": "completed"},
+                    {"content": "b", "status": "in_progress", "activeForm": "Doing b"},
+                    {"content": "c", "status": "pending"},
+                    {"content": "d"},
+                ]})
+            ),
+            ToolCall::Todo {
+                items: vec![
+                    TodoItem::new("a", TodoStatus::Completed),
+                    TodoItem::new("b", TodoStatus::InProgress),
+                    TodoItem::new("c", TodoStatus::Pending),
+                    TodoItem::new("d", TodoStatus::Pending),
+                ]
             }
         );
         assert_eq!(
diff --git a/crates/harness/src/codex/mod.rs b/crates/harness/src/codex/mod.rs
index 93ef7527b8..ea212c46d9 100644
--- a/crates/harness/src/codex/mod.rs
+++ b/crates/harness/src/codex/mod.rs
@@ -1339,6 +1339,14 @@ async fn run_session(session: Session) {
                         }
                     }
 
+                    // Codex's `update_plan` tool: the whole checklist, replaced
+                    // on every call, with an in-progress step.
+                    "turn/plan/updated" => {
+                        for ev in normalize::plan_update_events(&params) {
+                            if !send(&event_tx, ev).await { break 'main; }
+                        }
+                    }
+
                     "turn/completed" => {
                         let id = turn_id(&params);
                         router.note_completed(&id);
diff --git a/crates/harness/src/codex/normalize.rs b/crates/harness/src/codex/normalize.rs
index 9fa31aa9a6..d5ddd10ae1 100644
--- a/crates/harness/src/codex/normalize.rs
+++ b/crates/harness/src/codex/normalize.rs
@@ -6,7 +6,7 @@
 //! types) are accepted, and unknown item types map to nothing.
 
 use serde_json::Value;
-use zeron_proto::{AgentEvent, DoneStatus, TodoItem, ToolCall};
+use zeron_proto::{AgentEvent, DoneStatus, TodoItem, TodoStatus, ToolCall};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Phase {
@@ -201,6 +201,30 @@ fn file_change_call(changes: &[(String, String)]) -> ToolCall {
     }
 }
 
+/// `turn/plan/updated` → the live checklist chip. Steps carry
+/// `pending | inProgress | completed`; like ACP plans the update has no item
+/// id, so it refreshes the singleton [`zeron_proto::LIVE_PLAN_TOOL_ID`] in place.
+pub(crate) fn plan_update_events(params: &Value) -> Vec<AgentEvent> {
+    let Some(plan) = params.get("plan").and_then(Value::as_array) else {
+        return Vec::new();
+    };
+    let items = plan
+        .iter()
+        .map(|step| {
+            TodoItem::new(
+                str_field(step, &["step"]),
+                TodoStatus::parse(&str_field(step, &["status"])),
+            )
+        })
+        .collect();
+    tool_lifecycle(
+        Phase::Completed,
+        zeron_proto::LIVE_PLAN_TOOL_ID.into(),
+        ToolCall::Todo { items },
+        false,
+    )
+}
+
 pub(crate) fn item_type(item: &Value) -> &str {
     item.get("type").and_then(Value::as_str).unwrap_or("")
 }
@@ -378,9 +402,17 @@ pub(crate) fn map_item(phase: Phase, item: &Value) -> Vec<AgentEvent> {
                 .map(|a| a.as_slice())
                 .unwrap_or_default()
                 .iter()
-                .map(|t| TodoItem {
-                    text: str_field(t, &["text"]),
-                    done: field(t, &["completed", "done"]).and_then(Value::as_bool) == Some(true),
+                .map(|t| {
+                    let done =
+                        field(t, &["completed", "done"]).and_then(Value::as_bool) == Some(true);
+                    TodoItem::new(
+                        str_field(t, &["text"]),
+                        if done {
+                            TodoStatus::Completed
+                        } else {
+                            TodoStatus::Pending
+                        },
+                    )
                 })
                 .collect();
             tool_lifecycle(phase, id, ToolCall::Todo { items }, false)
@@ -841,6 +873,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn plan_update_maps_to_the_live_checklist_with_in_progress() {
+        let events = plan_update_events(&json!({
+            "threadId": "t", "turnId": "u", "explanation": null,
+            "plan": [
+                { "step": "read", "status": "completed" },
+                { "step": "fix", "status": "inProgress" },
+                { "step": "test", "status": "pending" },
+            ],
+        }));
+        assert_eq!(
+            events,
+            vec![
+                AgentEvent::ToolCall {
+                    id: zeron_proto::LIVE_PLAN_TOOL_ID.into(),
+                    call: ToolCall::Todo {
+                        items: vec![
+                            TodoItem::new("read", TodoStatus::Completed),
+                            TodoItem::new("fix", TodoStatus::InProgress),
+                            TodoItem::new("test", TodoStatus::Pending),
+                        ]
+                    },
+                },
+                AgentEvent::ToolResult {
+                    id: zeron_proto::LIVE_PLAN_TOOL_ID.into(),
+                    is_error: false,
+                    output: None,
+                    diff: None,
+                },
+            ]
+        );
+        assert!(plan_update_events(&json!({ "threadId": "t" })).is_empty());
+    }
+
     #[test]
     fn usage_reads_last_snapshot_under_both_spellings() {
         assert_eq!(
diff --git a/crates/harness/src/cursor/mod.rs b/crates/harness/src/cursor/mod.rs
index 88088908f6..f4416021f5 100644
--- a/crates/harness/src/cursor/mod.rs
+++ b/crates/harness/src/cursor/mod.rs
@@ -49,7 +49,7 @@ use tokio::sync::mpsc;
 
 use zeron_proto::{
     AgentEvent, DoneStatus, HarnessId, Model, ModelOption, ModelOptionChoice, ReasoningLevel,
-    RunRequest, SteeringMode, TodoItem, ToolCall,
+    RunRequest, SteeringMode, TodoItem, TodoStatus, ToolCall,
 };
 
 use crate::process::{Child, ChildStdin, Command, Stdio};
@@ -767,15 +767,19 @@ fn decode_tool(name: &str, args: &Value) -> ToolCall {
                 .map(|a| a.as_slice())
                 .unwrap_or_default()
                 .iter()
-                .map(|t| TodoItem {
-                    text: t
-                        .get("content")
-                        .or_else(|| t.get("text"))
-                        .and_then(Value::as_str)
-                        .unwrap_or("")
-                        .into(),
-                    done: t.get("status").and_then(Value::as_str) == Some("completed")
-                        || t.get("completed").and_then(Value::as_bool) == Some(true),
+                .map(|t| {
+                    let status = if t.get("completed").and_then(Value::as_bool) == Some(true) {
+                        TodoStatus::Completed
+                    } else {
+                        TodoStatus::parse(t.get("status").and_then(Value::as_str).unwrap_or(""))
+                    };
+                    TodoItem::new(
+                        t.get("content")
+                            .or_else(|| t.get("text"))
+                            .and_then(Value::as_str)
+                            .unwrap_or(""),
+                        status,
+                    )
                 })
                 .collect(),
         },
diff --git a/crates/harness/src/mock.rs b/crates/harness/src/mock.rs
index 590154b794..e6d99e276e 100644
--- a/crates/harness/src/mock.rs
+++ b/crates/harness/src/mock.rs
@@ -505,6 +505,66 @@ impl Harness for MockHarness {
             })
             .into_iter()
             .flatten();
+        // Dev/testing knob: `ZERON_MOCK_TODO=1` appends a checklist the agent
+        // works through — one `Todo` call rewritten in place per step, the way
+        // TodoWrite does — so the todo panel's open / fold / finished states
+        // can be watched live (pace it with `ZERON_MOCK_DELAY_MS`).
+        let mock_todo = std::env::var("ZERON_MOCK_TODO")
+            .ok()
+            .is_some_and(|v| !v.is_empty() && v != "0");
+        let todo_events = mock_todo
+            .then(|| {
+                const STEPS: [&str; 8] = [
+                    "Read the fold path in crates/doc",
+                    "Add the status field to TodoItem",
+                    "Map in-progress in every normalizer",
+                    "Write the fold-window view model",
+                    "Render the todo tray above the composer",
+                    "Persist open state per chat",
+                    "Run the unit tests",
+                    "Write the design note",
+                ];
+                let list = |active: usize| zeron_proto::ToolCall::Todo {
+                    items: STEPS
+                        .iter()
+                        .enumerate()
+                        .map(|(ix, text)| {
+                            zeron_proto::TodoItem::new(
+                                *text,
+                                match ix.cmp(&active) {
+                                    std::cmp::Ordering::Less => zeron_proto::TodoStatus::Completed,
+                                    std::cmp::Ordering::Equal => {
+                                        zeron_proto::TodoStatus::InProgress
+                                    }
+                                    std::cmp::Ordering::Greater => zeron_proto::TodoStatus::Pending,
+                                },
+                            )
+                        })
+                        .collect(),
+                };
+                let mut events = vec![AgentEvent::TextDelta {
+                    text: "\n### Todo check\n\nWorking through the checklist.\n\n".into(),
+                }];
+                // Steps 0..=8: the last write has every item completed.
+                for active in 0..=STEPS.len() {
+                    events.push(AgentEvent::ToolCall {
+                        id: "mock-todo".into(),
+                        call: list(active),
+                    });
+                    events.push(AgentEvent::ToolResult {
+                        id: "mock-todo".into(),
+                        is_error: false,
+                        output: None,
+                        diff: None,
+                    });
+                    events.push(AgentEvent::TextDelta {
+                        text: format!("Update {} written.\n\n", active + 1),
+                    });
+                }
+                events
+            })
+            .into_iter()
+            .flatten();
         let events: Vec<Result<AgentEvent, HarnessError>> = body
             .iter()
             .cycle()
@@ -513,6 +573,7 @@ impl Harness for MockHarness {
             .chain(thinking_events)
             .chain(code_tool_events)
             .chain(subagent_events)
+            .chain(todo_events)
             .chain(code_event)
             .chain(table_event)
             .chain(mend_event)
diff --git a/crates/harness/src/opencode/mod.rs b/crates/harness/src/opencode/mod.rs
index a288cbe664..35bb507508 100644
--- a/crates/harness/src/opencode/mod.rs
+++ b/crates/harness/src/opencode/mod.rs
@@ -61,7 +61,8 @@ use tokio::sync::mpsc;
 
 use zeron_proto::{
     AgentEvent, DoneStatus, HarnessId, Model, ModelOption, ModelOptionChoice, ReasoningLevel,
-    RunRequest, SlashCommand, SteeringMode, TodoItem, ToolCall, UserInputAnswer, UserInputQuestion,
+    RunRequest, SlashCommand, SteeringMode, TodoItem, TodoStatus, ToolCall, UserInputAnswer,
+    UserInputQuestion,
 };
 
 use crate::process::{Child, Command, Stdio};
@@ -3617,13 +3618,13 @@ fn oc_tool_call(name: &str, input: &Value) -> ToolCall {
                 .map(|a| a.as_slice())
                 .unwrap_or_default()
                 .iter()
-                .map(|t| TodoItem {
-                    text: t
-                        .get("content")
-                        .and_then(Value::as_str)
-                        .unwrap_or_default()
-                        .to_owned(),
-                    done: t.get("status").and_then(Value::as_str) == Some("completed"),
+                .map(|t| {
+                    TodoItem::new(
+                        t.get("content").and_then(Value::as_str).unwrap_or_default(),
+                        TodoStatus::parse(
+                            t.get("status").and_then(Value::as_str).unwrap_or_default(),
+                        ),
+                    )
                 })
                 .collect(),
         },
diff --git a/crates/harness/src/opencode/tests.rs b/crates/harness/src/opencode/tests.rs
index 42b2489644..ee86b61e3b 100644
--- a/crates/harness/src/opencode/tests.rs
+++ b/crates/harness/src/opencode/tests.rs
@@ -1333,13 +1333,22 @@ fn tool_names_type_the_common_calls() {
         "todowrite",
         &json!({"todos": [
             {"content": "step one", "status": "completed"},
-            {"content": "step two", "status": "pending"},
+            {"content": "step two", "status": "in_progress"},
+            {"content": "step three", "status": "pending"},
+            {"content": "step four", "status": "cancelled"},
         ]}),
     );
-    assert!(matches!(
-        &call,
-        ToolCall::Todo { items } if items.len() == 2 && items[0].done && !items[1].done
-    ));
+    assert_eq!(
+        call,
+        ToolCall::Todo {
+            items: vec![
+                TodoItem::new("step one", TodoStatus::Completed),
+                TodoItem::new("step two", TodoStatus::InProgress),
+                TodoItem::new("step three", TodoStatus::Pending),
+                TodoItem::new("step four", TodoStatus::Pending),
+            ]
+        }
+    );
     let call = oc_tool_call("mystery", &json!({"x": 1}));
     assert!(matches!(&call, ToolCall::Unknown { name, input: Some(_) } if name == "mystery"));
     assert!(!call.is_subagent_spawn());
diff --git a/crates/harness/tests/acp.rs b/crates/harness/tests/acp.rs
index af0ee2d2ce..c7596f6d39 100644
--- a/crates/harness/tests/acp.rs
+++ b/crates/harness/tests/acp.rs
@@ -15,7 +15,7 @@ use zeron_harness::{
 };
 use zeron_proto::{
     AgentEvent, DoneStatus, HarnessId, ReasoningLevel, RunRequest, SandboxLevel, SteeringMode,
-    TodoItem, ToolCall, UserInputAnswer,
+    TodoItem, TodoStatus, ToolCall, UserInputAnswer,
 };
 
 fn fixture_path() -> PathBuf {
@@ -199,14 +199,8 @@ async fn happy_path_maps_chunks_tools_diffs_plans_and_commands() {
         id: "acp-plan".into(),
         call: ToolCall::Todo {
             items: vec![
-                TodoItem {
-                    text: "read".into(),
-                    done: true
-                },
-                TodoItem {
-                    text: "fix".into(),
-                    done: false
-                },
+                TodoItem::new("read", TodoStatus::Completed),
+                TodoItem::new("fix", TodoStatus::InProgress),
             ]
         },
     }));
diff --git a/crates/harness/tests/codex.rs b/crates/harness/tests/codex.rs
index 0da11a6aa3..45c443fe4d 100644
--- a/crates/harness/tests/codex.rs
+++ b/crates/harness/tests/codex.rs
@@ -15,7 +15,7 @@ use zeron_harness::{
 };
 use zeron_proto::{
     AgentEvent, DoneStatus, HarnessId, ReasoningLevel, RunRequest, SandboxLevel, TodoItem,
-    ToolCall, UserInputAnswer, UserInputQuestion,
+    TodoStatus, ToolCall, UserInputAnswer, UserInputQuestion,
 };
 
 fn fixture_path() -> PathBuf {
@@ -293,14 +293,8 @@ async fn happy_path_maps_deltas_items_usage_and_done() {
         id: "td1".into(),
         call: ToolCall::Todo {
             items: vec![
-                TodoItem {
-                    text: "a".into(),
-                    done: true
-                },
-                TodoItem {
-                    text: "b".into(),
-                    done: false
-                },
+                TodoItem::new("a", TodoStatus::Completed),
+                TodoItem::new("b", TodoStatus::Pending),
             ]
         },
     }));
diff --git a/crates/proto/src/agent.rs b/crates/proto/src/agent.rs
index 25c750e857..d7973c0355 100644
--- a/crates/proto/src/agent.rs
+++ b/crates/proto/src/agent.rs
@@ -415,11 +415,78 @@ pub const SUBAGENT_INPUT_KEEP: [&str; 5] = [
     "subagent_type",
 ];
 
+/// Where one checklist item stands. Claude's TodoWrite, OpenCode and ACP plans
+/// distinguish the item being worked on from those still waiting; Codex and
+/// Cursor only report done / not done.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TodoStatus {
+    #[default]
+    Pending,
+    InProgress,
+    Completed,
+}
+
+impl TodoStatus {
+    /// Decode a harness status string. Anything unrecognised (including
+    /// `cancelled`) is `Pending`: not finished, not being worked on.
+    pub fn parse(raw: &str) -> Self {
+        match raw {
+            "completed" | "complete" | "done" => Self::Completed,
+            "in_progress" | "inProgress" | "in-progress" | "active" => Self::InProgress,
+            _ => Self::Pending,
+        }
+    }
+}
+
+/// One checklist entry.
+///
+/// `done` is the original wire field and stays authoritative for completion,
+/// so docs written before `status` existed (and readers that ignore it) keep
+/// working. `status` is additive and written only when it adds information —
+/// i.e. for an in-progress item; a missing or unreadable value derives from
+/// `done`. Build items with [`TodoItem::new`] to keep the two consistent.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TodoItem {
     pub text: String,
     pub done: bool,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "lenient_todo_status"
+    )]
+    pub status: Option<TodoStatus>,
+}
+
+impl TodoItem {
+    pub fn new(text: impl Into<String>, status: TodoStatus) -> Self {
+        Self {
+            text: text.into(),
+            done: status == TodoStatus::Completed,
+            status: (status == TodoStatus::InProgress).then_some(status),
+        }
+    }
+
+    /// Effective status: `done` wins, then the explicit status, else pending.
+    pub fn status(&self) -> TodoStatus {
+        if self.done {
+            TodoStatus::Completed
+        } else {
+            self.status.unwrap_or_default()
+        }
+    }
+}
+
+/// A status this build does not know (a future `blocked`, say) must not fail
+/// the whole tool call — the part would vanish from the transcript. Treat it
+/// as absent so the item falls back to `done`.
+fn lenient_todo_status<'de, D>(deserializer: D) -> Result<Option<TodoStatus>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
+    Ok(value.and_then(|v| serde_json::from_value(v).ok()))
 }
 
 /// A slash command advertised by the agent (ACP `availableCommands`): typed as
@@ -811,3 +878,68 @@ mod generated_image_tests {
         assert_eq!(serde_json::from_value::<AgentEvent>(value).unwrap(), event);
     }
 }
+
+#[cfg(test)]
+mod todo_item_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn legacy_items_without_status_derive_from_done() {
+        let done: TodoItem = serde_json::from_value(json!({ "text": "a", "done": true })).unwrap();
+        let open: TodoItem = serde_json::from_value(json!({ "text": "b", "done": false })).unwrap();
+        assert_eq!(done.status(), TodoStatus::Completed);
+        assert_eq!(open.status(), TodoStatus::Pending);
+        assert_eq!(open.status, None);
+    }
+
+    #[test]
+    fn only_in_progress_adds_a_field_so_other_docs_are_unchanged() {
+        let pending = serde_json::to_value(TodoItem::new("a", TodoStatus::Pending)).unwrap();
+        let done = serde_json::to_value(TodoItem::new("b", TodoStatus::Completed)).unwrap();
+        let active = serde_json::to_value(TodoItem::new("c", TodoStatus::InProgress)).unwrap();
+        assert_eq!(pending, json!({ "text": "a", "done": false }));
+        assert_eq!(done, json!({ "text": "b", "done": true }));
+        assert_eq!(
+            active,
+            json!({ "text": "c", "done": false, "status": "inProgress" })
+        );
+    }
+
+    #[test]
+    fn unknown_status_falls_back_to_done_instead_of_failing_the_call() {
+        let call: ToolCall = serde_json::from_value(json!({
+            "kind": "todo",
+            "items": [
+                { "text": "a", "done": false, "status": "blocked" },
+                { "text": "b", "done": true, "status": 7 },
+            ]
+        }))
+        .unwrap();
+        let ToolCall::Todo { items } = call else {
+            panic!("expected a todo call");
+        };
+        assert_eq!(items[0].status(), TodoStatus::Pending);
+        assert_eq!(items[1].status(), TodoStatus::Completed);
+    }
+
+    #[test]
+    fn done_outranks_a_stale_status() {
+        let item = TodoItem {
+            text: "a".into(),
+            done: true,
+            status: Some(TodoStatus::InProgress),
+        };
+        assert_eq!(item.status(), TodoStatus::Completed);
+    }
+
+    #[test]
+    fn harness_status_strings_decode() {
+        assert_eq!(TodoStatus::parse("completed"), TodoStatus::Completed);
+        assert_eq!(TodoStatus::parse("in_progress"), TodoStatus::InProgress);
+        assert_eq!(TodoStatus::parse("inProgress"), TodoStatus::InProgress);
+        assert_eq!(TodoStatus::parse("pending"), TodoStatus::Pending);
+        assert_eq!(TodoStatus::parse("cancelled"), TodoStatus::Pending);
+        assert_eq!(TodoStatus::parse(""), TodoStatus::Pending);
+    }
+}
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 9341bb64a2..c13f38052d 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -5699,6 +5699,11 @@ pub struct Composer {
     /// Rows awaiting a host-authoritative removal acknowledgement. They stay
     /// visible but inert until the host wins the race against queue delivery.
     pub(crate) queue_removing: HashSet<String>,
+    /// The agent's checklist tray: latest list of the selected chat, and the
+    /// per-chat open/fold state (in memory, like the right-pane flags).
+    pub(crate) todo_cache: crate::todo_panel::TodoCache,
+    pub(crate) todo_panels: HashMap<String, crate::todo_panel::TodoPanelState>,
+    pub(crate) todo_scroll: gpui::ScrollHandle,
     /// Whether the modifier overlay should currently reveal the queue hint.
     /// The shell owns modifier tracking and clears this on window deactivation.
     queue_shortcut_revealed: bool,
@@ -5979,6 +5984,9 @@ impl Composer {
             queue_full_preview: None,
             queue_previews: HashMap::new(),
             queue_removing: HashSet::new(),
+            todo_cache: Default::default(),
+            todo_panels: HashMap::new(),
+            todo_scroll: gpui::ScrollHandle::new(),
             queue_shortcut_revealed: false,
             expanded_mode: false,
             flip_epoch: 0,
@@ -10118,6 +10126,13 @@ impl Render for Composer {
                 self.staged().len() + self.staged_appshots().len(),
                 self.staged_comments(cx).len(),
             );
+        // The checklist tray stacks above the queue (or directly above the
+        // composer), one step narrower than what follows it.
+        let has_queue = !self.state.read(cx).queue.is_empty();
+        let container = container.when_some(
+            self.render_todo_panel(has_queue, window, cx),
+            |el, panel| el.child(motion::fade_quick("composer-todo", div().child(panel))),
+        );
         let container = container.when_some(
             self.render_queue_panel(show_queue_latest_shortcut, window, cx),
             |el, panel| {
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index 9abec8dd97..bd30fcdf29 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -60,6 +60,7 @@ pub mod state;
 pub(crate) mod surface_chrome;
 pub mod syntax_cache;
 pub mod terminal;
+mod todo_panel;
 pub mod theme;
 pub mod theme_library;
 pub mod transcript;
diff --git a/crates/ui/src/queue.rs b/crates/ui/src/queue.rs
index db2dfcdcef..b8d11e19fd 100644
--- a/crates/ui/src/queue.rs
+++ b/crates/ui/src/queue.rs
@@ -79,7 +79,7 @@ const ROW_GAP: f32 = 0.0;
 const ROW_SLOT: f32 = ROW_HEIGHT + ROW_GAP;
 const ROW_PAD_X: f32 = 8.0;
 const ROW_RADIUS: f32 = 8.0;
-const PANEL_RADIUS: f32 = 16.0;
+pub(crate) const PANEL_RADIUS: f32 = 16.0;
 const PANEL_PAD_X: f32 = 4.0;
 const PANEL_PAD_TOP: f32 = 4.0;
 /// The custom 24px queue glyphs have quieter geometry than the legacy set, so
@@ -252,7 +252,7 @@ fn queue_hidden_attachments_label(labels: &[String], shown: usize) -> Option<Str
     Some(format!("{} more: {}", hidden.len(), hidden.join(" · ")))
 }
 
-fn queue_panel_surface(theme: &Theme) -> gpui::Div {
+pub(crate) fn queue_panel_surface(theme: &Theme) -> gpui::Div {
     div()
         .occlude()
         .rounded_t(px(PANEL_RADIUS))
diff --git a/crates/ui/src/todo_panel.rs b/crates/ui/src/todo_panel.rs
new file mode 100644
index 0000000000..216f0b78ee
--- /dev/null
+++ b/crates/ui/src/todo_panel.rs
@@ -0,0 +1,1142 @@
+//! The agent's checklist, docked above the composer.
+//!
+//! Every harness that plans (Claude's TodoWrite, OpenCode, ACP and Codex
+//! plans) emits the *whole* list on each update, so the panel simply tracks the
+//! latest `Todo` tool part of the selected chat. It sits in the same tray stack
+//! as the message queue (`queue.rs`), one step narrower, so the two read as one
+//! object emerging from behind the composer.
+//!
+//! The first half of this file is pure — which list is current, what the header
+//! says, which rows a long list folds to — so it is unit-tested without a
+//! window. The second half is the gpui rendering on [`Composer`].
+
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+use std::ops::Range;
+use std::time::Duration;
+
+use gpui::{
+    AnyElement, Context, InteractiveElement as _, IntoElement, ParentElement as _, SharedString,
+    StatefulInteractiveElement as _, Styled, Window, div, prelude::*, px,
+};
+
+use zeron_doc::{MessagePart, MessageRole, SessionMessageEntry};
+use zeron_proto::{TodoItem, TodoStatus, ToolCall};
+
+use crate::composer::{Composer, QUEUE_COMPOSER_OVERLAP};
+use crate::icons::{self, icon};
+use crate::motion::{self, AnimationExt as _};
+use crate::theme::Theme;
+
+/// Lists longer than this fold to a [`FOCUS_WINDOW`] around the current item.
+pub(crate) const FOLD_ABOVE: usize = 6;
+pub(crate) const FOCUS_WINDOW: usize = 3;
+
+/// The checklist the agent most recently wrote, or `None` when there is none
+/// (or the latest write cleared it with an empty list).
+///
+/// `entries` is the selected chat's own transcript; subagent traffic lives in
+/// separate docs and never reaches it. ACP plans reuse one tool id for every
+/// update, so "latest part" — not "first part with this id" — is the contract.
+pub(crate) fn latest_todo(entries: &[SessionMessageEntry]) -> Option<Vec<TodoItem>> {
+    let items = entries
+        .iter()
+        .rev()
+        .filter(|entry| entry.role == MessageRole::Assistant)
+        .flat_map(|entry| entry.parts.iter().rev())
+        .find_map(|part| match part {
+            MessagePart::Tool {
+                call: ToolCall::Todo { items },
+                ..
+            } => Some(items),
+            _ => None,
+        })?;
+    (!items.is_empty()).then(|| items.clone())
+}
+
+/// What the collapsed header reports.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct TodoSummary {
+    pub total: usize,
+    pub done: usize,
+    /// First in-progress item.
+    pub active: Option<usize>,
+    /// First item not yet completed.
+    pub next: Option<usize>,
+}
+
+impl TodoSummary {
+    pub fn of(items: &[TodoItem]) -> Self {
+        let mut summary = Self {
+            total: items.len(),
+            done: 0,
+            active: None,
+            next: None,
+        };
+        for (ix, item) in items.iter().enumerate() {
+            match item.status() {
+                TodoStatus::Completed => summary.done += 1,
+                TodoStatus::InProgress => {
+                    summary.active.get_or_insert(ix);
+                    summary.next.get_or_insert(ix);
+                }
+                TodoStatus::Pending => {
+                    summary.next.get_or_insert(ix);
+                }
+            }
+        }
+        summary
+    }
+
+    pub fn finished(&self) -> bool {
+        self.total > 0 && self.done == self.total
+    }
+
+    /// The item the header names: what is being worked on, else what is next.
+    pub fn headline(&self) -> Option<usize> {
+        self.active.or(self.next)
+    }
+}
+
+/// The slice of a long list that stays visible when folded: three items with
+/// the current one in the middle (one of context before it, one after),
+/// clamped to the list ends. A finished list shows its last three. Lists up to
+/// [`FOLD_ABOVE`] are never folded.
+pub(crate) fn focus_window(items: &[TodoItem]) -> Range<usize> {
+    let total = items.len();
+    if total <= FOLD_ABOVE {
+        return 0..total;
+    }
+    let summary = TodoSummary::of(items);
+    let focus = summary.headline().unwrap_or(total - 1);
+    let start = focus.saturating_sub(1).min(total - FOCUS_WINDOW);
+    start..start + FOCUS_WINDOW
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FoldSide {
+    Earlier,
+    Later,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum TodoRow {
+    /// An item, by its index in the agent's list.
+    Item(usize),
+    /// A fold toggle standing in for `count` hidden items (`open`: they are
+    /// currently revealed, and the row hides them again).
+    Fold {
+        side: FoldSide,
+        count: usize,
+        open: bool,
+    },
+}
+
+/// The rows of the expanded list, top to bottom. Items always keep the
+/// agent's order; folds sit at the edges of the list they stand for.
+pub(crate) fn rows(items: &[TodoItem], show_earlier: bool, show_later: bool) -> Vec<TodoRow> {
+    let window = focus_window(items);
+    let earlier = window.start;
+    let later = items.len() - window.end;
+    let mut out = Vec::with_capacity(items.len() + 2);
+    if earlier > 0 {
+        out.push(TodoRow::Fold {
+            side: FoldSide::Earlier,
+            count: earlier,
+            open: show_earlier,
+        });
+        if show_earlier {
+            out.extend((0..earlier).map(TodoRow::Item));
+        }
+    }
+    out.extend(window.clone().map(TodoRow::Item));
+    if later > 0 {
+        if show_later {
+            out.extend((window.end..items.len()).map(TodoRow::Item));
+        }
+        out.push(TodoRow::Fold {
+            side: FoldSide::Later,
+            count: later,
+            open: show_later,
+        });
+    }
+    out
+}
+
+/// Identity of a finished list, so a dismissal holds until the agent writes a
+/// different one.
+fn signature(items: &[TodoItem]) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    for item in items {
+        item.text.hash(&mut hasher);
+        item.status().hash(&mut hasher);
+    }
+    hasher.finish()
+}
+
+/// Per-chat presentation state. In memory only — like the right-pane flags in
+/// `shell::SessionPanels` it lasts for the app run, not across restarts.
+#[derive(Debug, Default, Clone)]
+pub(crate) struct TodoPanelState {
+    /// The user's explicit choice; `None` follows the automatic rule: open
+    /// while work remains, compact once everything is done.
+    expanded: Option<bool>,
+    show_earlier: bool,
+    show_later: bool,
+    /// Signature of the list the user dismissed.
+    dismissed: Option<u64>,
+    /// Whether the previous frame was settled, to detect the transition.
+    was_settled: bool,
+    /// Bumped on every toggle so the list's fade-in replays.
+    epoch: u32,
+}
+
+impl TodoPanelState {
+    /// Feed the frame's facts in. `settled` is "everything done and the turn
+    /// idle": reaching it drops any explicit choice, so the panel tidies itself
+    /// to the compact state exactly once — a later manual expand is respected.
+    pub fn observe(&mut self, settled: bool) {
+        if settled && !self.was_settled {
+            self.expanded = None;
+        }
+        self.was_settled = settled;
+    }
+
+    /// A finished list is compact by default even while a new turn runs, so
+    /// last turn's checklist does not pop open again each time you send.
+    pub fn is_expanded(&self, finished: bool) -> bool {
+        self.expanded.unwrap_or(!finished)
+    }
+
+    pub fn toggle(&mut self, finished: bool) {
+        self.expanded = Some(!self.is_expanded(finished));
+        self.epoch = self.epoch.wrapping_add(1);
+    }
+
+    pub fn toggle_fold(&mut self, side: FoldSide) {
+        match side {
+            FoldSide::Earlier => self.show_earlier = !self.show_earlier,
+            FoldSide::Later => self.show_later = !self.show_later,
+        }
+    }
+
+    pub fn dismiss(&mut self, items: &[TodoItem]) {
+        self.dismissed = Some(signature(items));
+    }
+
+    /// A dismissal holds until the agent writes a different list. It covers
+    /// unfinished lists too: one the agent abandoned (an interrupted turn, a
+    /// cancelled item that never completes) must not stay pinned forever.
+    pub fn is_dismissed(&self, items: &[TodoItem]) -> bool {
+        self.dismissed == Some(signature(items))
+    }
+}
+
+/// The latest list for the selected chat, recomputed only when its transcript
+/// changes (the scan walks back from the end, but a chat with no todo walks all
+/// of it, and the composer renders far more often than the transcript changes).
+#[derive(Debug, Default)]
+pub(crate) struct TodoCache {
+    key: Option<(String, u64, usize)>,
+    items: Option<Vec<TodoItem>>,
+}
+
+impl TodoCache {
+    pub fn latest(
+        &mut self,
+        chat: &str,
+        revision: u64,
+        entries: &[SessionMessageEntry],
+    ) -> Option<&[TodoItem]> {
+        let key = (chat.to_owned(), revision, entries.len());
+        if self.key.as_ref() != Some(&key) {
+            self.items = latest_todo(entries);
+            self.key = Some(key);
+        }
+        self.items.as_deref()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+
+const HEADER_HEIGHT: f32 = 32.0;
+const ROW_PAD_X: f32 = 8.0;
+const ROW_RADIUS: f32 = 8.0;
+const TEXT_SIZE: f32 = 12.5;
+const TEXT_LINE: f32 = 17.0;
+const GLYPH_SLOT: f32 = 14.0;
+const ACTION_SIZE: f32 = 24.0;
+/// One step narrower than the queue tray, which is itself inset from the
+/// composer; stacked above a queue the todo tray steps in once more.
+const SIDE_INSET: f32 = 16.0;
+
+impl Composer {
+    /// The checklist tray, or `None` when the chat has no todo (or the user
+    /// dismissed a finished one). `below_queue`: a queue tray follows.
+    pub(crate) fn render_todo_panel(
+        &mut self,
+        below_queue: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        let live = self.run_live(cx);
+        let (chat_id, items) = {
+            let state = self.state.read(cx);
+            let chat_id = state.selected_chat.clone()?;
+            let items = self
+                .todo_cache
+                .latest(&chat_id, state.transcript_revision, &state.transcript)?
+                .to_vec();
+            (chat_id, items)
+        };
+        let summary = TodoSummary::of(&items);
+        let settled = summary.finished() && !live;
+
+        let panel = self.todo_panels.entry(chat_id.clone()).or_default();
+        panel.observe(settled);
+        if panel.is_dismissed(&items) {
+            return None;
+        }
+        let expanded = panel.is_expanded(summary.finished());
+        let (show_earlier, show_later, epoch) = (panel.show_earlier, panel.show_later, panel.epoch);
+
+        let theme = Theme::of(cx).clone();
+        let view = cx.entity_id();
+        // Dismissable whenever the turn is idle, finished or not.
+        let header = self.todo_header(&chat_id, &items, summary, expanded, !live, &theme, cx);
+
+        let surface = crate::queue::queue_panel_surface(&theme).child(header);
+        let surface = if expanded {
+            let list = div().flex().flex_col().children(
+                rows(&items, show_earlier, show_later)
+                    .into_iter()
+                    .map(|row| match row {
+                        TodoRow::Item(ix) => todo_item_row(ix, &items[ix], live, &theme, view, cx),
+                        TodoRow::Fold { side, count, open } => {
+                            self.todo_fold_row(&chat_id, side, count, open, &theme, cx)
+                        }
+                    }),
+            );
+            // Same fade-and-scroll treatment as the queue's rows; a long
+            // expanded fold scrolls instead of pushing the transcript up.
+            let rows = crate::edge_fade::edge_faded(
+                Theme::TRANSCRIPT_FADE_BAND,
+                true,
+                true,
+                div()
+                    .id("todo-panel-rows")
+                    .max_h(window.viewport_size().height * 0.3)
+                    .overflow_y_scroll()
+                    .track_scroll(&self.todo_scroll)
+                    .child(list),
+            )
+            .fade_overflow_y(&self.todo_scroll)
+            .outset_bottom(TEXT_SIZE);
+            surface.child(
+                div()
+                    .mt(px(2.0))
+                    // The tray's lowest strip hides behind the composer; keep
+                    // the last row clear of that edge.
+                    .pb(px(6.0))
+                    .child(rows)
+                    .with_animation(
+                        SharedString::from(format!("todo-rows-{epoch}")),
+                        motion::FADE_QUICK.animation(),
+                        |el, t| el.opacity(t),
+                    ),
+            )
+        } else {
+            surface
+        };
+
+        let inset = if below_queue {
+            SIDE_INSET * 2.0
+        } else {
+            SIDE_INSET
+        };
+        Some(
+            div()
+                .mx(px(inset))
+                // Cancel the column gap and tuck the tray behind what follows
+                // (the queue tray, or the composer itself).
+                .mb(px(-(Theme::SPACE_SM + QUEUE_COMPOSER_OVERLAP)))
+                .child(crate::frost::frosted(
+                    crate::queue::PANEL_RADIUS,
+                    crate::frost::MENU_BLUR,
+                    surface,
+                ))
+                .into_any_element(),
+        )
+    }
+
+    /// `Todo · 2/5` and what is being worked on; one button that toggles the
+    /// list, plus a dismiss while the turn is idle.
+    #[allow(clippy::too_many_arguments)]
+    fn todo_header(
+        &self,
+        chat_id: &str,
+        items: &[TodoItem],
+        summary: TodoSummary,
+        expanded: bool,
+        dismissable: bool,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let accent = theme.accent;
+        let label = if expanded {
+            "Collapse todo list"
+        } else {
+            "Expand todo list"
+        };
+        let headline: Option<(SharedString, gpui::Hsla)> = if summary.finished() {
+            Some(("All done".into(), theme.text_faint))
+        } else {
+            summary
+                .headline()
+                .map(|ix| (items[ix].text.clone().into(), theme.text_muted))
+        };
+
+        let finished = summary.finished();
+        let toggle_chat = chat_id.to_owned();
+        let toggle =
+            div()
+                .id("todo-panel-toggle")
+                .role(gpui::Role::Button)
+                .aria_label(label)
+                .flex_1()
+                .min_w_0()
+                .h(px(HEADER_HEIGHT))
+                .px(px(ROW_PAD_X))
+                .rounded(px(ROW_RADIUS))
+                .flex()
+                .items_center()
+                .gap(px(8.0))
+                .cursor_pointer()
+                .hover(|s| s.bg(theme.element_hover))
+                .tab_index(0)
+                .focus_visible(move |s| s.bg(accent.opacity(0.14)))
+                .on_click(cx.listener(move |this, _, _, cx| {
+                    this.todo_panels
+                        .entry(toggle_chat.clone())
+                        .or_default()
+                        .toggle(finished);
+                    cx.notify();
+                }))
+                .tooltip(crate::settings::widgets::text_tooltip(label))
+                .tooltip_show_delay(Duration::from_millis(350))
+                .child(
+                    icon(if summary.finished() {
+                        icons::CHECK
+                    } else {
+                        icons::CHECKLIST
+                    })
+                    .size(px(14.0))
+                    .text_color(if summary.finished() {
+                        theme.success
+                    } else {
+                        theme.text_muted
+                    }),
+                )
+                .child(
+                    div()
+                        .flex_none()
+                        .flex()
+                        .items_baseline()
+                        .gap(px(6.0))
+                        .text_size(px(TEXT_SIZE))
+                        .child(
+                            div()
+                                .font_weight(gpui::FontWeight::MEDIUM)
+                                .text_color(theme.text)
+                                .child("Todo"),
+                        )
+                        .child(div().text_color(theme.text_faint).child(SharedString::from(
+                            format!("{}/{}", summary.done, summary.total),
+                        ))),
+                )
+                // The expanded list already names every item; the headline is the
+                // collapsed state's whole point.
+                .when(!expanded, |el| {
+                    el.when_some(headline, |el, (text, color)| {
+                        el.child(
+                            div()
+                                .flex_1()
+                                .min_w_0()
+                                .truncate()
+                                .text_size(px(TEXT_SIZE))
+                                .text_color(color)
+                                .child(text),
+                        )
+                    })
+                })
+                .when(expanded, |el| el.child(div().flex_1()))
+                .child(
+                    icon(if expanded {
+                        icons::ALT_ARROW_DOWN
+                    } else {
+                        icons::ALT_ARROW_UP
+                    })
+                    .size(px(13.0))
+                    .text_color(theme.text_muted.opacity(0.7)),
+                );
+
+        let dismiss_chat = chat_id.to_owned();
+        let dismiss_items = items.to_vec();
+        div()
+            .flex()
+            .items_center()
+            .gap(px(2.0))
+            .child(toggle)
+            .when(dismissable, |row| {
+                row.child(
+                    div()
+                        .id("todo-panel-dismiss")
+                        .role(gpui::Role::Button)
+                        .aria_label("Dismiss todo list")
+                        .size(px(ACTION_SIZE))
+                        .flex_none()
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .rounded(px(5.0))
+                        .cursor_pointer()
+                        .hover(|s| s.bg(theme.element_hover))
+                        .tab_index(0)
+                        .focus_visible(move |s| s.bg(accent.opacity(0.18)))
+                        .on_click(cx.listener(move |this, _, _, cx| {
+                            this.todo_panels
+                                .entry(dismiss_chat.clone())
+                                .or_default()
+                                .dismiss(&dismiss_items);
+                            cx.notify();
+                        }))
+                        .tooltip(crate::settings::widgets::text_tooltip("Dismiss"))
+                        .tooltip_show_delay(Duration::from_millis(350))
+                        .child(
+                            icon(icons::CLOSE)
+                                .size(px(11.0))
+                                .text_color(theme.text_muted.opacity(0.8)),
+                        ),
+                )
+            })
+            .into_any_element()
+    }
+
+    /// "N earlier" / "N later": stands in for the items folded off one end of a
+    /// long list; clicking reveals them in place, clicking again hides them.
+    fn todo_fold_row(
+        &self,
+        chat_id: &str,
+        side: FoldSide,
+        count: usize,
+        open: bool,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let accent = theme.accent;
+        let noun = match side {
+            FoldSide::Earlier => "earlier",
+            FoldSide::Later => "later",
+        };
+        let text = SharedString::from(format!("{count} {noun}"));
+        let aria = format!(
+            "{} {count} {noun} items",
+            if open { "Hide" } else { "Show" }
+        );
+        // The arrow points to where the hidden items are (or, once revealed,
+        // back to where they fold away).
+        let glyph = match (side, open) {
+            (FoldSide::Earlier, false) | (FoldSide::Later, true) => icons::ALT_ARROW_UP,
+            _ => icons::ALT_ARROW_DOWN,
+        };
+        let chat_id = chat_id.to_owned();
+        div()
+            .id(SharedString::from(format!("todo-fold-{noun}")))
+            .role(gpui::Role::Button)
+            .aria_label(aria)
+            .h(px(24.0))
+            .px(px(ROW_PAD_X))
+            .rounded(px(6.0))
+            .flex()
+            .items_center()
+            .gap(px(8.0))
+            .cursor_pointer()
+            .hover(|s| s.bg(theme.element_hover))
+            .tab_index(0)
+            .focus_visible(move |s| s.bg(accent.opacity(0.14)))
+            .on_click(cx.listener(move |this, _, _, cx| {
+                this.todo_panels
+                    .entry(chat_id.clone())
+                    .or_default()
+                    .toggle_fold(side);
+                cx.notify();
+            }))
+            .child(
+                div()
+                    .w(px(GLYPH_SLOT))
+                    .flex_none()
+                    .flex()
+                    .justify_center()
+                    .child(icon(glyph).size(px(12.0)).text_color(theme.text_faint)),
+            )
+            .child(
+                div()
+                    .text_size(px(11.5))
+                    .text_color(theme.text_faint)
+                    .child(text),
+            )
+            .into_any_element()
+    }
+}
+
+/// One checklist row: status glyph + text. Completed work recedes, the
+/// in-progress item is the brightest thing in the list.
+fn todo_item_row(
+    ix: usize,
+    item: &TodoItem,
+    live: bool,
+    theme: &Theme,
+    view: gpui::EntityId,
+    cx: &mut gpui::App,
+) -> AnyElement {
+    let status = item.status();
+    let (color, weight) = match status {
+        TodoStatus::Completed => (theme.text_faint, gpui::FontWeight::NORMAL),
+        TodoStatus::InProgress => (theme.text, gpui::FontWeight::MEDIUM),
+        TodoStatus::Pending => (theme.text_muted, gpui::FontWeight::NORMAL),
+    };
+    div()
+        .id(SharedString::from(format!("todo-item-{ix}")))
+        .min_h(px(26.0))
+        .px(px(ROW_PAD_X))
+        .py(px(4.0))
+        .flex()
+        .items_start()
+        .gap(px(8.0))
+        .child(
+            div()
+                .w(px(GLYPH_SLOT))
+                .h(px(TEXT_LINE))
+                .flex_none()
+                .flex()
+                .items_center()
+                .justify_center()
+                .child(status_glyph(ix, status, live, theme, view, cx)),
+        )
+        .child(
+            div()
+                .flex_1()
+                .min_w_0()
+                .text_size(px(TEXT_SIZE))
+                .line_height(px(TEXT_LINE))
+                .font_weight(weight)
+                .text_color(color)
+                .child(SharedString::from(item.text.clone())),
+        )
+        .into_any_element()
+}
+
+/// check / active / pending. An in-progress item only animates while the turn
+/// is live; on an idle chat it is a still ring (the agent is not working on
+/// it), so a stopped run does not look busy forever.
+fn status_glyph(
+    ix: usize,
+    status: TodoStatus,
+    live: bool,
+    theme: &Theme,
+    view: gpui::EntityId,
+    cx: &mut gpui::App,
+) -> AnyElement {
+    match status {
+        TodoStatus::Completed => icon(icons::CHECK)
+            .size(px(12.0))
+            .text_color(theme.success)
+            .into_any_element(),
+        TodoStatus::InProgress if live => crate::loaders::mini_glyph_spinner(
+            format!("todo-active-{ix}"),
+            2.5,
+            theme.glyph,
+            view,
+            cx,
+        )
+        .into_any_element(),
+        TodoStatus::InProgress => div()
+            .size(px(10.0))
+            .rounded_full()
+            .border_1()
+            .border_color(theme.accent)
+            .flex()
+            .items_center()
+            .justify_center()
+            .child(div().size(px(4.0)).rounded_full().bg(theme.accent))
+            .into_any_element(),
+        TodoStatus::Pending => div()
+            .size(px(10.0))
+            .rounded_full()
+            .border_1()
+            .border_color(theme.text_faint.opacity(0.7))
+            .into_any_element(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn items(spec: &str) -> Vec<TodoItem> {
+        // x = completed, > = in progress, . = pending
+        spec.chars()
+            .enumerate()
+            .map(|(i, c)| {
+                TodoItem::new(
+                    format!("item {i}"),
+                    match c {
+                        'x' => TodoStatus::Completed,
+                        '>' => TodoStatus::InProgress,
+                        _ => TodoStatus::Pending,
+                    },
+                )
+            })
+            .collect()
+    }
+
+    fn entry(role: MessageRole, parts: Vec<MessagePart>) -> SessionMessageEntry {
+        SessionMessageEntry {
+            id: "m".into(),
+            role,
+            parts,
+            created_at: 0,
+            device_id: "d".into(),
+            status: None,
+            continuation_of: None,
+            duration_ms: None,
+        }
+    }
+
+    fn todo_part(id: &str, list: Vec<TodoItem>) -> MessagePart {
+        MessagePart::Tool {
+            id: id.into(),
+            call: ToolCall::Todo { items: list },
+            is_error: false,
+            resolved: true,
+            output: None,
+            diff: None,
+            output_ref: None,
+            output_bytes: None,
+            diff_ref: None,
+            diff_stats: None,
+            subagent_ref: None,
+            subagent_status: None,
+            subagent_tail: None,
+        }
+    }
+
+    #[test]
+    fn latest_todo_is_the_last_write_across_entries() {
+        let first = entry(MessageRole::Assistant, vec![todo_part("a", items("x.."))]);
+        let second = entry(
+            MessageRole::Assistant,
+            vec![
+                todo_part("b", items("xx.")),
+                MessagePart::Text {
+                    id: "t".into(),
+                    text: "working".into(),
+                },
+                todo_part("c", items("xx>")),
+            ],
+        );
+        assert_eq!(latest_todo(&[first, second]), Some(items("xx>")));
+    }
+
+    #[test]
+    fn acp_plan_reusing_one_id_resolves_to_the_newest_segment() {
+        let plan = zeron_proto::LIVE_PLAN_TOOL_ID;
+        let old = entry(MessageRole::Assistant, vec![todo_part(plan, items(">.."))]);
+        let new = entry(MessageRole::Assistant, vec![todo_part(plan, items("x>."))]);
+        assert_eq!(latest_todo(&[old, new]), Some(items("x>.")));
+    }
+
+    #[test]
+    fn an_empty_write_clears_and_user_rows_are_ignored() {
+        let list = entry(MessageRole::Assistant, vec![todo_part("a", items("x."))]);
+        let cleared = entry(MessageRole::Assistant, vec![todo_part("b", Vec::new())]);
+        assert_eq!(latest_todo(&[list.clone(), cleared]), None);
+        let user = entry(MessageRole::User, vec![todo_part("u", items("."))]);
+        assert_eq!(latest_todo(&[user]), None);
+        assert_eq!(latest_todo(&[list]), Some(items("x.")));
+        assert_eq!(latest_todo(&[]), None);
+    }
+
+    #[test]
+    fn summary_counts_and_names_the_current_item() {
+        let s = TodoSummary::of(&items("xx>.."));
+        assert_eq!(
+            (s.total, s.done, s.active, s.next),
+            (5, 2, Some(2), Some(2))
+        );
+        assert_eq!(s.headline(), Some(2));
+        assert!(!s.finished());
+        // Nothing started: the first unfinished item is the headline.
+        let s = TodoSummary::of(&items("x..."));
+        assert_eq!((s.active, s.headline()), (None, Some(1)));
+        // An in-progress item later in the list still wins over an earlier
+        // pending one: the agent is working on it.
+        assert_eq!(TodoSummary::of(&items(".>.")).headline(), Some(1));
+        let s = TodoSummary::of(&items("xxx"));
+        assert!(s.finished());
+        assert_eq!(s.headline(), None);
+        assert!(!TodoSummary::of(&[]).finished());
+    }
+
+    #[test]
+    fn short_lists_never_fold() {
+        for n in 0..=FOLD_ABOVE {
+            let list = items(&".".repeat(n));
+            assert_eq!(focus_window(&list), 0..n);
+            assert!(
+                rows(&list, false, false)
+                    .iter()
+                    .all(|r| matches!(r, TodoRow::Item(_)))
+            );
+        }
+    }
+
+    #[test]
+    fn long_lists_fold_to_three_around_the_current_item() {
+        // Current item in the middle: one before, it, one after.
+        assert_eq!(focus_window(&items("xxxx>.....")), 3..6);
+        // At the start / end the window clamps instead of shrinking.
+        assert_eq!(focus_window(&items(">.......")), 0..3);
+        assert_eq!(focus_window(&items("xxxxxxx>")), 5..8);
+        // No in-progress item: the first unfinished one is the focus.
+        assert_eq!(focus_window(&items("xxxx.....")), 3..6);
+        // Everything done: the tail.
+        assert_eq!(focus_window(&items("xxxxxxxx")), 5..8);
+        // Always exactly three when folded.
+        for spec in ["xxxxxxx>", ">.......", "xx>.....", "xxxxxxxx", "........"] {
+            assert_eq!(focus_window(&items(spec)).len(), FOCUS_WINDOW, "{spec}");
+        }
+    }
+
+    #[test]
+    fn rows_put_folds_at_the_edges_with_counts() {
+        let list = items("xxxx>.....");
+        assert_eq!(
+            rows(&list, false, false),
+            vec![
+                TodoRow::Fold {
+                    side: FoldSide::Earlier,
+                    count: 3,
+                    open: false
+                },
+                TodoRow::Item(3),
+                TodoRow::Item(4),
+                TodoRow::Item(5),
+                TodoRow::Fold {
+                    side: FoldSide::Later,
+                    count: 4,
+                    open: false
+                },
+            ]
+        );
+        // No fold on a side with nothing hidden.
+        let head = rows(&items(">......."), false, false);
+        assert!(matches!(head.first(), Some(TodoRow::Item(0))));
+        assert!(matches!(
+            head.last(),
+            Some(TodoRow::Fold {
+                side: FoldSide::Later,
+                count: 5,
+                ..
+            })
+        ));
+    }
+
+    #[test]
+    fn expanding_a_fold_reveals_items_without_reordering() {
+        let list = items("xxxx>.....");
+        let order = |rows: &[TodoRow]| -> Vec<usize> {
+            rows.iter()
+                .filter_map(|r| match r {
+                    TodoRow::Item(ix) => Some(*ix),
+                    _ => None,
+                })
+                .collect()
+        };
+        for (earlier, later) in [(false, false), (true, false), (false, true), (true, true)] {
+            let shown = order(&rows(&list, earlier, later));
+            assert!(shown.windows(2).all(|w| w[0] < w[1]), "{earlier} {later}");
+        }
+        // Both open: the whole list, in order, and each toggle still present
+        // so it can be closed again.
+        let all = rows(&list, true, true);
+        assert_eq!(order(&all), (0..list.len()).collect::<Vec<_>>());
+        assert!(matches!(
+            all.first(),
+            Some(TodoRow::Fold { open: true, .. })
+        ));
+        assert!(matches!(all.last(), Some(TodoRow::Fold { open: true, .. })));
+        // Earlier items appear after their fold row, later items before theirs.
+        assert_eq!(all[1], TodoRow::Item(0));
+        assert_eq!(all[all.len() - 2], TodoRow::Item(9));
+    }
+
+    #[test]
+    fn panel_follows_the_work_then_tidies_itself_once() {
+        let mut state = TodoPanelState::default();
+        // Working: open by default.
+        state.observe(false);
+        assert!(state.is_expanded(false));
+        // A finished list stays compact when a new turn starts (not settled,
+        // since the turn is live) instead of popping open again.
+        assert!(!state.is_expanded(true));
+        // User collapses mid-run: respected.
+        state.toggle(false);
+        state.observe(false);
+        assert!(!state.is_expanded(false));
+        // Everything done and idle: compact, and the explicit choice resets.
+        state.toggle(false); // user had re-expanded
+        assert!(state.is_expanded(false));
+        state.observe(true);
+        assert!(!state.is_expanded(true));
+        // Opening the finished list by hand sticks (no re-collapse each frame).
+        state.toggle(true);
+        state.observe(true);
+        assert!(state.is_expanded(true));
+        // New work arrives: back to the automatic open state...
+        state.observe(false);
+        assert!(state.is_expanded(false));
+        // ...and finishing again tidies again.
+        state.observe(true);
+        assert!(!state.is_expanded(true));
+    }
+
+    #[test]
+    fn toggle_replays_the_fade_and_folds_toggle_independently() {
+        let mut state = TodoPanelState::default();
+        let before = state.epoch;
+        state.toggle(false);
+        assert_ne!(state.epoch, before);
+        state.toggle_fold(FoldSide::Later);
+        assert!(state.show_later && !state.show_earlier);
+        state.toggle_fold(FoldSide::Later);
+        assert!(!state.show_later);
+    }
+
+    #[test]
+    fn dismissal_holds_only_for_the_list_it_was_made_on() {
+        let done = items("xxx");
+        let mut state = TodoPanelState::default();
+        assert!(!state.is_dismissed(&done));
+        state.dismiss(&done);
+        assert!(state.is_dismissed(&done));
+        // A changed list (reopened, or a new one) is shown again.
+        assert!(!state.is_dismissed(&items("xx.")));
+        assert!(!state.is_dismissed(&items("xxxx")));
+        // An abandoned list that will never finish (interrupted turn, a
+        // cancelled item) can be dismissed too, until the agent rewrites it.
+        let stuck = items("x..");
+        state.dismiss(&stuck);
+        assert!(state.is_dismissed(&stuck));
+        assert!(!state.is_dismissed(&items("xx.")));
+    }
+
+    #[test]
+    fn cache_rescans_only_when_the_transcript_changes() {
+        let mut cache = TodoCache::default();
+        let one = vec![entry(
+            MessageRole::Assistant,
+            vec![todo_part("a", items("x."))],
+        )];
+        assert_eq!(cache.latest("chat", 1, &one), Some(items("x.").as_slice()));
+        // Same chat, revision and length: served from cache, not rescanned.
+        assert_eq!(cache.latest("chat", 1, &one), Some(items("x.").as_slice()));
+        let two = vec![
+            one[0].clone(),
+            entry(MessageRole::Assistant, vec![todo_part("b", items("xx"))]),
+        ];
+        assert_eq!(cache.latest("chat", 2, &two), Some(items("xx").as_slice()));
+        // Another chat never reuses the first chat's list.
+        assert_eq!(cache.latest("other", 2, &[]), None);
+    }
+}
+
+#[cfg(test)]
+mod composer_tests {
+    use super::*;
+    use crate::state::AppState;
+
+    fn assistant_with_todo(list: Vec<TodoItem>) -> SessionMessageEntry {
+        SessionMessageEntry {
+            id: "m".into(),
+            role: MessageRole::Assistant,
+            parts: vec![MessagePart::Tool {
+                id: "t".into(),
+                call: ToolCall::Todo { items: list },
+                is_error: false,
+                resolved: true,
+                output: None,
+                diff: None,
+                output_ref: None,
+                output_bytes: None,
+                diff_ref: None,
+                diff_stats: None,
+                subagent_ref: None,
+                subagent_status: None,
+                subagent_tail: None,
+            }],
+            created_at: 0,
+            device_id: "d".into(),
+            status: None,
+            continuation_of: None,
+            duration_ms: None,
+        }
+    }
+
+    fn items(done: usize, total: usize) -> Vec<TodoItem> {
+        (0..total)
+            .map(|i| {
+                TodoItem::new(
+                    format!("step {i}"),
+                    if i < done {
+                        TodoStatus::Completed
+                    } else {
+                        TodoStatus::Pending
+                    },
+                )
+            })
+            .collect()
+    }
+
+    fn window(
+        cx: &mut gpui::TestAppContext,
+    ) -> (
+        tempfile::TempDir,
+        gpui::Entity<AppState>,
+        gpui::WindowHandle<Composer>,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            crate::app_menus::init(cx);
+            crate::history::init(
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                cx,
+            );
+            crate::settings::init(crate::settings::UiSettings::default(), dir.path(), cx);
+        });
+        let state = cx.new(|_| AppState::new());
+        let handle = {
+            let state = state.clone();
+            cx.add_window(move |_, cx| Composer::new(state, cx))
+        };
+        (dir, state, handle)
+    }
+
+    fn show_todo(
+        state: &gpui::Entity<AppState>,
+        handle: &gpui::WindowHandle<Composer>,
+        chat: &str,
+        entries: Vec<SessionMessageEntry>,
+        cx: &mut gpui::TestAppContext,
+    ) {
+        state.update(cx, |state, _| {
+            state.selected_chat = Some(chat.into());
+            state.transcript = entries;
+            state.transcript_revision += 1;
+        });
+        handle
+            .update(cx, |composer, _, _| composer.current_key = chat.into())
+            .unwrap();
+    }
+
+    /// Whether the tray is on screen for the selected chat right now.
+    fn rendered(handle: &gpui::WindowHandle<Composer>, cx: &mut gpui::TestAppContext) -> bool {
+        handle
+            .update(cx, |composer, window, cx| {
+                composer.render_todo_panel(false, window, cx).is_some()
+            })
+            .unwrap()
+    }
+
+    #[gpui::test]
+    fn tray_appears_only_when_the_chat_has_a_todo(cx: &mut gpui::TestAppContext) {
+        let (_dir, state, handle) = window(cx);
+        show_todo(&state, &handle, "a", Vec::new(), cx);
+        assert!(!rendered(&handle, cx));
+        show_todo(
+            &state,
+            &handle,
+            "a",
+            vec![assistant_with_todo(items(1, 3))],
+            cx,
+        );
+        assert!(rendered(&handle, cx));
+        // The agent clearing its list (an empty write) takes the tray away.
+        show_todo(
+            &state,
+            &handle,
+            "a",
+            vec![assistant_with_todo(Vec::new())],
+            cx,
+        );
+        assert!(!rendered(&handle, cx));
+    }
+
+    #[gpui::test]
+    fn open_state_is_remembered_per_chat(cx: &mut gpui::TestAppContext) {
+        let (_dir, state, handle) = window(cx);
+        let entries = || vec![assistant_with_todo(items(1, 3))];
+        show_todo(&state, &handle, "a", entries(), cx);
+        assert!(rendered(&handle, cx));
+        handle
+            .update(cx, |composer, _, _| {
+                composer.todo_panels.get_mut("a").unwrap().toggle(false);
+            })
+            .unwrap();
+        // Another chat starts from the automatic state, and A keeps its choice.
+        show_todo(&state, &handle, "b", entries(), cx);
+        assert!(rendered(&handle, cx));
+        show_todo(&state, &handle, "a", entries(), cx);
+        assert!(rendered(&handle, cx));
+        handle
+            .read_with(cx, |composer, _| {
+                assert!(!composer.todo_panels["a"].is_expanded(false));
+                assert!(composer.todo_panels["b"].is_expanded(false));
+            })
+            .unwrap();
+    }
+
+    #[gpui::test]
+    fn a_dismissed_finished_list_stays_gone_until_the_list_changes(cx: &mut gpui::TestAppContext) {
+        let (_dir, state, handle) = window(cx);
+        let finished = || vec![assistant_with_todo(items(3, 3))];
+        show_todo(&state, &handle, "a", finished(), cx);
+        assert!(rendered(&handle, cx));
+        handle
+            .update(cx, |composer, _, _| {
+                composer
+                    .todo_panels
+                    .get_mut("a")
+                    .unwrap()
+                    .dismiss(&items(3, 3));
+            })
+            .unwrap();
+        assert!(!rendered(&handle, cx));
+        // A new list (more work) is shown again.
+        show_todo(
+            &state,
+            &handle,
+            "a",
+            vec![assistant_with_todo(items(3, 5))],
+            cx,
+        );
+        assert!(rendered(&handle, cx));
+    }
+}
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index be8d082944..eb03fc3f7e 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -889,7 +889,14 @@ pub fn call_block(call: &ToolCall) -> Option<ToolDetail> {
         ToolCall::WebSearch { query } => query.clone(),
         ToolCall::Todo { items } => items
             .iter()
-            .map(|i| format!("{} {}", if i.done { "[x]" } else { "[ ]" }, i.text))
+            .map(|i| {
+                let mark = match i.status() {
+                    zeron_proto::TodoStatus::Completed => "[x]",
+                    zeron_proto::TodoStatus::InProgress => "[~]",
+                    zeron_proto::TodoStatus::Pending => "[ ]",
+                };
+                format!("{mark} {}", i.text)
+            })
             .collect::<Vec<_>>()
             .join("\n"),
         ToolCall::Mcp {
@@ -13826,14 +13833,8 @@ mod tests {
         );
         let todo = ToolCall::Todo {
             items: vec![
-                zeron_proto::TodoItem {
-                    text: "a".into(),
-                    done: true,
-                },
-                zeron_proto::TodoItem {
-                    text: "b".into(),
-                    done: false,
-                },
+                zeron_proto::TodoItem::new("a", zeron_proto::TodoStatus::Completed),
+                zeron_proto::TodoItem::new("b", zeron_proto::TodoStatus::Pending),
             ],
         };
         assert_eq!(tool_chip_content(&todo), ("Todo", "1/2 done".to_string()));
@@ -13913,21 +13914,16 @@ mod tests {
         // Todos list one item per line with checkbox state.
         let Some(ToolDetail::Output { lines, .. }) = call_block(&ToolCall::Todo {
             items: vec![
-                zeron_proto::TodoItem {
-                    text: "a".into(),
-                    done: true,
-                },
-                zeron_proto::TodoItem {
-                    text: "b".into(),
-                    done: false,
-                },
+                zeron_proto::TodoItem::new("a", zeron_proto::TodoStatus::Completed),
+                zeron_proto::TodoItem::new("b", zeron_proto::TodoStatus::InProgress),
+                zeron_proto::TodoItem::new("c", zeron_proto::TodoStatus::Pending),
             ],
         }) else {
             panic!("expected an output block")
         };
         assert_eq!(
             lines.iter().map(|l| l.as_ref()).collect::<Vec<_>>(),
-            vec!["[x] a", "[ ] b"]
+            vec!["[x] a", "[~] b", "[ ] c"]
         );
 
         // Blank invocation → no block; the chip stays a plain card.
diff --git a/docs/screenshots/todo-panel/collapsed-headline.png b/docs/screenshots/todo-panel/collapsed-headline.png
new file mode 100644
index 0000000000000000000000000000000000000000..b781c33e5a11749c6ea0f1e5e0c08f6237679e93
GIT binary patch
literal 20360
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%0Am*xbK0xpML*(<2wCHWvi56=_z3^<<m~R
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

literal 0
HcmV?d00001

diff --git a/docs/screenshots/todo-panel/done-compact.png b/docs/screenshots/todo-panel/done-compact.png
new file mode 100644
index 0000000000000000000000000000000000000000..65a6a3d128607e79ed01a7dd3679d7321de5b2ca
GIT binary patch
literal 22586
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
KMNUMnLSTX+vFN4%

literal 0
HcmV?d00001

diff --git a/docs/screenshots/todo-panel/expanded-folded.png b/docs/screenshots/todo-panel/expanded-folded.png
new file mode 100644
index 0000000000000000000000000000000000000000..b8d968b7f4d994cb098591e398f18bb07b434791
GIT binary patch
literal 32338
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
OO6G&2M7fw@!2bX`cw-j;

literal 0
HcmV?d00001

diff --git a/docs/todo-panel.md b/docs/todo-panel.md
new file mode 100644
index 0000000000..08a6e64a5b
--- /dev/null
+++ b/docs/todo-panel.md
@@ -0,0 +1,100 @@
+# Todo panel
+
+The agent's checklist is a tray above the composer, not just a `Todo · 2/5 done`
+chip in the transcript. It follows the latest checklist of the selected chat and
+shows what is being worked on without scrolling.
+
+Screenshots: [`docs/screenshots/todo-panel/`](screenshots/todo-panel/).
+
+## Data
+
+Every harness that plans writes the *whole* list on each update, so the panel
+needs no history, only the latest `ToolCall::Todo` part.
+
+| Harness | Source | In-progress |
+| --- | --- | --- |
+| Claude | `TodoWrite` | `in_progress` |
+| OpenCode | `todowrite` | `in_progress` |
+| ACP (Gemini, Cursor, Devin, ...) | `plan` update, id `LIVE_PLAN_TOOL_ID` | `in_progress` |
+| Codex | `turn/plan/updated` (`update_plan`), id `LIVE_PLAN_TOOL_ID` | `inProgress` |
+| Codex | legacy `todoList` item | not exposed |
+| Cursor | `updateTodos` | `status` string, when present |
+
+`TodoItem` is `{ text, done, status? }` (`crates/proto/src/agent.rs`).
+
+- `done` is unchanged and stays authoritative for completion.
+- `status` (`pending | inProgress | completed`) is additive and serde-defaulted. It
+  is written **only for an in-progress item**, so every other item serializes
+  byte-for-byte as before and old builds, iOS and the TS edge
+  (`edge/src/session-doc`) ignore it. A missing or unrecognised value derives from
+  `done`; an unknown future status never fails the whole tool call.
+- Use `TodoItem::new(text, status)` to keep `done` and `status` consistent and
+  `item.status()` to read the effective value.
+- `cancelled` (OpenCode) decodes as pending: it is not done and not being worked on.
+
+The ACP and Codex plan updates reuse one tool id, so the fold refreshes the same
+part in place within a segment and appends a new one in the next segment. The
+engine's stale-echo filter exempts that id, and "latest part wins" is the panel's
+contract (`latest_todo`). An empty list clears the panel.
+
+## Behaviour
+
+`crates/ui/src/todo_panel.rs`, mounted by the composer above the queue tray (one
+step narrower than it, which is itself narrower than the composer).
+
+- **Scope.** Todo parts of the chat's own transcript only. Subagent traffic lives
+  in separate docs and never reaches it. Hidden when the chat has no todo.
+- **Collapsed.** `Todo · 2/5` plus the in-progress item (else the first unfinished
+  one); a finished list reads `Todo · 5/5 · All done`.
+- **Expanded.** Every item, in the agent's order, with a status glyph: check
+  (success), spinner (in progress and the turn is live; a still ring when idle, so a
+  stopped run does not look busy), empty ring (pending). Completed items recede,
+  the current item is the brightest.
+- **Long lists.** More than 6 items fold to a window of 3 with the current item in
+  the middle (one before, one after; clamped at the ends; a finished list shows its
+  last three). `N earlier` / `N later` rows at the edges reveal the hidden items in
+  place and hide them again. Items are never reordered (`todo_panel::rows`).
+- **Open state.** Per chat, in memory for the app run (like the right-pane flags in
+  `shell::SessionPanels`; the repo keeps no per-chat UI state on disk). Default:
+  open while work remains, compact once everything is done, including when a new
+  turn starts on an old finished list. When the last item completes and the turn
+  is idle, an explicit choice is reset once so the panel tidies itself to the
+  compact done state; opening it by hand afterwards sticks.
+- **Done state.** Offers a dismiss button; a dismissal holds until the agent writes
+  a different list.
+- **No focus stealing.** Nothing here takes focus; updates only re-render.
+- **Accessibility.** The header, dismiss and fold rows are buttons with
+  `aria_label`, tab stops and a focus ring, activated by Enter/Space. The icon-only
+  dismiss button has a tooltip, and the header's tooltip names the action it will
+  take.
+- **Motion.** The list fades in on toggle (`FADE_QUICK`) and the tray fades in on
+  mount. Those, and the shared mini glyph spinner, all follow the global
+  reduce-motion flag, which also covers the pause-in-background setting.
+
+The transcript chip keeps working: `Todo · 2/5 done`, and its expanded detail marks
+the current item `[~]` (`[x]` done, `[ ]` pending).
+
+## Performance
+
+The composer re-renders far more often than the transcript changes, so
+`TodoCache` rescans only when the selected chat, `transcript_revision` or the
+transcript length changes. The scan walks back from the newest entry and stops at
+the first todo.
+
+## Testing
+
+```sh
+cargo test --locked -p zeron-proto todo_item_tests
+cargo test --locked -p zeron-harness            # normalizers: claude, opencode, acp, codex, cursor
+cargo test --locked -p zeron-doc todo
+cargo test --locked -p zeron-ui --lib todo_panel
+```
+
+Live: `ZERON_HARNESS=mock ZERON_MOCK_TODO=1 ZERON_MOCK_DELAY_MS=900` (see
+`CONTRIBUTORS.md`) walks an 8-item list through every state.
+
+## Not done
+
+- Mobile (iOS/Android) panel: a later PR in the stack.
+- The `[x]` / `[ ]` rendering in MCP `read_chat` and the mobile transcript does not
+  yet distinguish in-progress.
diff --git a/edge/src/session-doc/control-types.ts b/edge/src/session-doc/control-types.ts
index c9a2e3dd12..843370b236 100644
--- a/edge/src/session-doc/control-types.ts
+++ b/edge/src/session-doc/control-types.ts
@@ -5,6 +5,14 @@
  * edge package stays dependency-light (no effect).
  */
 
+/** One checklist entry. `done` stays authoritative for completion; `status` is
+ * additive and only present for an in-progress item (absent ⇒ derive from `done`). */
+export interface TodoItem {
+  readonly text: string;
+  readonly done: boolean;
+  readonly status?: "pending" | "inProgress" | "completed";
+}
+
 export type ToolCall =
   | { readonly _tag: "Exec"; readonly command: string; readonly background?: boolean }
   | { readonly _tag: "ReadFile"; readonly path: string }
@@ -29,7 +37,7 @@ export type ToolCall =
   | { readonly _tag: "WebSearch"; readonly query: string }
   | {
       readonly _tag: "Todo";
-      readonly items: ReadonlyArray<{ readonly text: string; readonly done: boolean }>;
+      readonly items: ReadonlyArray<TodoItem>;
     }
   | { readonly _tag: "Mcp"; readonly server?: string; readonly tool: string; readonly input: unknown }
   | { readonly _tag: "Unknown"; readonly name: string; readonly input: unknown };
diff --git a/edge/src/session-doc/render-parts.ts b/edge/src/session-doc/render-parts.ts
index 9f286a39ec..5109e450a0 100644
--- a/edge/src/session-doc/render-parts.ts
+++ b/edge/src/session-doc/render-parts.ts
@@ -14,7 +14,7 @@
  * discarded at the event layer (harness ToolResult carries only `isError`),
  * and ApplyPatch already stores path-only summaries.
  */
-import type { MessagePart, ToolCall, ToolPartDiff } from "./control-types";
+import type { MessagePart, TodoItem, ToolCall, ToolPartDiff } from "./control-types";
 
 /** A tool call reduced to its render surface. Structurally a subset of
  * {@link ToolCall}; every variant here is assignable-from its wire twin after
@@ -37,7 +37,7 @@ export type RenderToolCall =
   | { readonly _tag: "WebSearch"; readonly query: string }
   | {
       readonly _tag: "Todo";
-      readonly items: ReadonlyArray<{ readonly text: string; readonly done: boolean }>;
+      readonly items: ReadonlyArray<TodoItem>;
     }
   | { readonly _tag: "Mcp"; readonly server?: string; readonly tool: string }
   | { readonly _tag: "Unknown"; readonly name: string };
@@ -101,10 +101,13 @@ export const sanitizeToolCall = (call: ToolCall | RenderToolCall): RenderToolCal
     case "Todo":
       return {
         _tag: "Todo",
-        items: (call as Extract<RenderToolCall, { _tag: "Todo" }>).items.map((i) => ({
-          text: i.text,
-          done: i.done
-        }))
+        // `status` rides along when present so an in-progress item survives the
+        // rebuild; dropping it would flatten the checklist to done / not done.
+        items: (call as Extract<RenderToolCall, { _tag: "Todo" }>).items.map((i) =>
+          i.status === undefined
+            ? { text: i.text, done: i.done }
+            : { text: i.text, done: i.done, status: i.status }
+        )
       };
     case "Mcp": {
       const { server, tool } = call as { server?: string; tool: string };
diff --git a/edge/src/session-doc/todo-items.test.ts b/edge/src/session-doc/todo-items.test.ts
new file mode 100644
index 0000000000..9f01166d5b
--- /dev/null
+++ b/edge/src/session-doc/todo-items.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { sanitizeToolCall } from "./render-parts";
+
+describe("todo checklist items", () => {
+  it("keeps an in-progress status through the render-only policy", () => {
+    const call = {
+      _tag: "Todo" as const,
+      items: [
+        { text: "read", done: true },
+        { text: "fix", done: false, status: "inProgress" as const },
+      ],
+    };
+    expect(sanitizeToolCall(call)).toEqual(call);
+  });
+  it("leaves legacy items (no status) byte-for-byte unchanged", () => {
+    const call = { _tag: "Todo" as const, items: [{ text: "a", done: false }] };
+    const out = sanitizeToolCall(call);
+    expect(out).toEqual(call);
+    expect(Object.keys((out as typeof call).items[0]!)).toEqual(["text", "done"]);
+  });
+});

From 55f5ed4c8d14024744d2a9e6e1f8448990740532 Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Fri, 2 Oct 2026 15:17:47 -0700
Subject: [PATCH 34/74] CI(macos): give macos-native the old job's 45 minute
 limit

A cold-cache run on macos-latest builds for about 20 minutes and checks the app
for 9; all 50 tests passed but the job hit 30 minutes in the browser fixture.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/macos.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 23a0898b18..0892abadb9 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -81,7 +81,8 @@ jobs:
   # compiled once (one cargo invocation, so dependencies are built once) and then run.
   macos-native:
     runs-on: macos-latest
-    timeout-minutes: 30
+    # A cold cache (first run, eviction, toolchain bump) takes about 32 minutes; warm is about 10.
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - name: Rust toolchain

From e94c49ad89a85920d8d2c94bb60d8b55a643cebd Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Fri, 2 Oct 2026 15:30:01 -0700
Subject: [PATCH 35/74] Fix compact model picker browsing across providers
 (#749)

---
 crates/ui/src/pickers.rs         | 37 +++++++++++++++++++++++++-------
 crates/ui/src/pickers/compact.rs | 11 ++++++++--
 2 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 1c796bc5dd..259ef8af59 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -8140,13 +8140,16 @@ mod tests {
                     Loadable::Ready(vec![bare_model("claude", "Claude model")]),
                 );
                 picker.catalog_rev += 1;
-                // The list holds one provider's models; the provider page
-                // switches to the newly loaded one.
-                assert_eq!(picker.model_rows_len(cx), 1);
-                picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
+                // A provider's models become directly selectable when its
+                // catalog finishes loading; no provider-page detour is needed.
+                assert_eq!(picker.model_rows_len(cx), 2);
+                assert_eq!(picker.model_rows(cx)[1].harness, HarnessId::ClaudeCode);
+                picker.activate_model_index(1, cx);
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
+                assert_eq!(picker.resolved(cx).model.as_deref(), Some("claude"));
                 picker.show_compact_models(cx);
-                assert_eq!(picker.model_rows_len(cx), 1);
-                assert_eq!(picker.model_rows(cx)[0].harness, HarnessId::ClaudeCode);
+                assert_eq!(picker.model_rows_len(cx), 2);
+                assert_eq!(picker.model_rows(cx)[picker.active].harness, HarnessId::ClaudeCode);
             })
             .unwrap();
     }
@@ -8314,10 +8317,25 @@ mod tests {
             .update(cx, |picker, window, cx| {
                 picker.open_model_menu(window, cx);
                 assert!(!picker.compact_model_list);
-                // The list holds the current provider's models only.
+                // Models from every offered provider are directly selectable.
                 picker.show_compact_models(cx);
-                assert_eq!(picker.model_rows_len(cx), 1);
+                assert_eq!(picker.model_rows_len(cx), 2);
                 assert_eq!(picker.model_rows(cx)[0].harness, HarnessId::Codex);
+                assert_eq!(picker.model_rows(cx)[1].harness, HarnessId::ClaudeCode);
+                // Searching must also find another provider's model.
+                picker.search.update(cx, |input, cx| input.set_text("Claude", cx));
+                assert_eq!(picker.model_rows_len(cx), 1);
+                assert_eq!(picker.model_rows(cx)[0].harness, HarnessId::ClaudeCode);
+                picker.activate_model_index(0, cx);
+                assert!(!picker.compact_model_list);
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
+                assert_eq!(picker.resolved(cx).model.as_deref(), Some("claude-model"));
+                picker.pick_harness(HarnessId::Codex, cx);
+                // Clicking a foreign-provider row works without a search too.
+                picker.show_compact_models(cx);
+                picker.activate_model_index(1, cx);
+                assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
+                picker.pick_harness(HarnessId::Codex, cx);
                 // The provider page lists every provider, highlighting the
                 // current one, and a pick lands back on the panel.
                 picker.show_compact_providers(cx);
@@ -8339,6 +8357,9 @@ mod tests {
                 picker.show_compact_models(cx);
                 assert_eq!(picker.model_rows_len(cx), 1);
                 assert_eq!(picker.rail_descriptors(cx)[0].id, HarnessId::Codex);
+                picker.search.update(cx, |input, cx| input.set_text("Claude", cx));
+                assert_eq!(picker.model_rows_len(cx), 0);
+                picker.search.update(cx, |input, cx| input.set_text("", cx));
                 // A chat's provider is fixed: the provider page stays shut.
                 picker.compact_model_list = false;
                 picker.show_compact_providers(cx);
diff --git a/crates/ui/src/pickers/compact.rs b/crates/ui/src/pickers/compact.rs
index 885e38b240..fca3dbeb27 100644
--- a/crates/ui/src/pickers/compact.rs
+++ b/crates/ui/src/pickers/compact.rs
@@ -322,8 +322,15 @@ impl Pickers {
     }
 
     pub(super) fn show_compact_models(&mut self, cx: &mut Context<Self>) {
-        // The provider button picks the provider; the list holds its models.
-        self.show_compact_list(ModelRail::Harness, "Search models…", cx);
+        // Browse every offered provider, just as the standard picker's rail
+        // allows. rail_descriptors still limits existing chats to their provider.
+        // A foreign-provider row switches the provider before picking its model.
+        let rail = if self.harness_locked(cx) {
+            ModelRail::Harness
+        } else {
+            ModelRail::All
+        };
+        self.show_compact_list(rail, "Search models…", cx);
     }
 
     /// The starred models across providers, opened from the provider page.

From 56dc5ff3a360a4b83f48f7ed134b8c26a2e812fc Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Fri, 2 Oct 2026 16:04:12 -0700
Subject: [PATCH 36/74] CI: pin every action to a commit SHA, keep pins current
 with Dependabot

Tags like @v2 can be moved by whoever controls the action's repository, and
release.yml runs these actions next to the macOS signing and notarization
secrets. Each reference now names the commit its tag points to today (version
in a trailing comment), so CI runs the same code as before. Dependabot opens
one grouped PR a week to move the pins.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/actions/linux-ci/action.yml         |  6 ++---
 .github/actions/windows-ci-setup/action.yml |  2 +-
 .github/dependabot.yml                      | 13 +++++++++
 .github/workflows/cursor-compatibility.yml  |  6 ++---
 .github/workflows/cursor-sdk-update.yml     |  4 +--
 .github/workflows/deploy.yml                | 12 ++++-----
 .github/workflows/linux-installer.yml       |  2 +-
 .github/workflows/macos.yml                 | 30 ++++++++++-----------
 .github/workflows/preview-tests.yml         |  4 +--
 .github/workflows/release-profile-tests.yml |  4 +--
 .github/workflows/release.yml               | 22 +++++++--------
 .github/workflows/testflight.yml            |  4 +--
 .github/workflows/ui-tests.yml              |  8 +++---
 .github/workflows/windows.yml               | 16 +++++------
 14 files changed, 73 insertions(+), 60 deletions(-)
 create mode 100644 .github/dependabot.yml

diff --git a/.github/actions/linux-ci/action.yml b/.github/actions/linux-ci/action.yml
index 0e306e4eb1..19c8837d4d 100644
--- a/.github/actions/linux-ci/action.yml
+++ b/.github/actions/linux-ci/action.yml
@@ -38,7 +38,7 @@ runs:
     - name: Restore apt packages
       id: apt-cache
       if: inputs.apt-packages != ''
-      uses: actions/cache/restore@v4
+      uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
       with:
         path: ~/apt-debs/*.deb
         key: apt-debs-v1-${{ inputs.apt-cache }}-${{ hashFiles('scripts/ci/apt-install.sh') }}
@@ -53,7 +53,7 @@ runs:
         bash scripts/ci/apt-install.sh $APT_PACKAGES
     - name: Save apt packages
       if: inputs.apt-packages != '' && github.ref == 'refs/heads/main' && steps.apt-cache.outputs.cache-hit != 'true'
-      uses: actions/cache/save@v4
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
       with:
         path: ~/apt-debs/*.deb
         key: apt-debs-v1-${{ inputs.apt-cache }}-${{ hashFiles('scripts/ci/apt-install.sh') }}
@@ -65,7 +65,7 @@ runs:
       shell: bash
       run: echo "CARGO_PROFILE_DEV_DEBUG=0" >> "$GITHUB_ENV"
 
-    - uses: Swatinem/rust-cache@v2
+    - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
       with:
         prefix-key: ci-linux-v1
         shared-key: ${{ inputs.rust-cache }}
diff --git a/.github/actions/windows-ci-setup/action.yml b/.github/actions/windows-ci-setup/action.yml
index 74ddc7e28b..5374c07d9b 100644
--- a/.github/actions/windows-ci-setup/action.yml
+++ b/.github/actions/windows-ci-setup/action.yml
@@ -43,7 +43,7 @@ runs:
         $cargoHome = if ($env:CARGO_HOME) { $env:CARGO_HOME } else { Join-Path $env:USERPROFILE '.cargo' }
         Add-Content -LiteralPath (Join-Path $cargoHome 'config.toml') -Value $config
         Write-Host "opt-level 0 for $($members.Count) workspace crates: $($members -join ', ')"
-    - uses: Swatinem/rust-cache@v2
+    - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
       with:
         # Only main writes the cache; PRs restore it.
         save-if: ${{ github.ref == 'refs/heads/main' }}
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..ed2e621091
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,13 @@
+version: 2
+updates:
+  # Workflow actions are pinned to commit SHAs (with the version in a comment);
+  # this keeps the pins current. One grouped PR per week.
+  - package-ecosystem: github-actions
+    directories:
+      - /
+      - /.github/actions/*
+    schedule:
+      interval: weekly
+    groups:
+      github-actions:
+        patterns: ['*']
diff --git a/.github/workflows/cursor-compatibility.yml b/.github/workflows/cursor-compatibility.yml
index a42c7337ff..7120e031cf 100644
--- a/.github/workflows/cursor-compatibility.yml
+++ b/.github/workflows/cursor-compatibility.yml
@@ -28,8 +28,8 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: '22'
       - name: Dependency updater validation
@@ -52,7 +52,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/linux-ci
         with:
           rust-cache: core # saved by core-tests in ui-tests.yml
diff --git a/.github/workflows/cursor-sdk-update.yml b/.github/workflows/cursor-sdk-update.yml
index e0202b8317..3c3de1fc81 100644
--- a/.github/workflows/cursor-sdk-update.yml
+++ b/.github/workflows/cursor-sdk-update.yml
@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: '22'
       - name: Check stable SDK version
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index b9b577f92f..f19512255a 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -25,7 +25,7 @@ jobs:
       # the token through job env and gate on that instead.
       CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
         with:
           # `github.event.before` may precede several commits in a batched push.
           fetch-depth: 0
@@ -43,7 +43,7 @@ jobs:
           else
             echo "changed=false" >> "$GITHUB_OUTPUT"
           fi
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         if: steps.changed.outputs.changed == 'true'
         with:
           node-version: 22
@@ -72,7 +72,7 @@ jobs:
     env:
       CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
         with:
           fetch-depth: 0
       - name: detect landing changes
@@ -89,7 +89,7 @@ jobs:
           else
             echo "changed=false" >> "$GITHUB_OUTPUT"
           fi
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         if: steps.changed.outputs.changed == 'true'
         with:
           node-version: 22
@@ -108,7 +108,7 @@ jobs:
     env:
       CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
         with:
           fetch-depth: 0
       - name: detect www-redirect changes
@@ -125,7 +125,7 @@ jobs:
           else
             echo "changed=false" >> "$GITHUB_OUTPUT"
           fi
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         if: steps.changed.outputs.changed == 'true'
         with:
           node-version: 22
diff --git a/.github/workflows/linux-installer.yml b/.github/workflows/linux-installer.yml
index 62c990069b..54a987c634 100644
--- a/.github/workflows/linux-installer.yml
+++ b/.github/workflows/linux-installer.yml
@@ -34,7 +34,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: Desktop entry validator
         # Skips apt when the runner image already has it; otherwise the install
         # retries and is bounded instead of hanging on a stalled mirror.
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 0892abadb9..01711a1f4a 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -51,7 +51,7 @@ jobs:
     outputs:
       ios: ${{ steps.filter.outputs.result }}
     steps:
-      - uses: actions/github-script@v8
+      - uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         id: filter
         with:
           script: |
@@ -84,12 +84,12 @@ jobs:
     # A cold cache (first run, eviction, toolchain bump) takes about 32 minutes; warm is about 10.
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: Rust toolchain
         run: |
           rustup update stable --no-self-update
           rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
           cache-on-failure: true
@@ -132,12 +132,12 @@ jobs:
           test -f "$RUNNER_TEMP/browser-captures/result.txt"
       - name: Upload browser screenshots
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: browser-macos-captures
           path: ${{ runner.temp }}/browser-captures*
           if-no-files-found: ignore
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 24
       - name: Install preview fixture server
@@ -151,7 +151,7 @@ jobs:
           test -f "$RUNNER_TEMP/preview-captures/result.txt"
       - name: Upload preview screenshots
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: preview-macos-captures
           path: ${{ runner.temp }}/preview-captures*
@@ -162,7 +162,7 @@ jobs:
     runs-on: macos-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: Rust toolchain
         run: |
           rustup update stable --no-self-update
@@ -175,7 +175,7 @@ jobs:
           git -C frame-source-tests remote add origin https://github.com/zeronsh/zui
           git -C frame-source-tests fetch --depth=1 origin "$rev"
           git -C frame-source-tests checkout --detach FETCH_HEAD
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
           cache-on-failure: true
@@ -193,10 +193,10 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: Rust toolchain
         run: rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
           cache-on-failure: true
@@ -213,7 +213,7 @@ jobs:
           mkdir -p "$RUNNER_TEMP/ios-include"
           cp "$RUNNER_TEMP/gen/zeron_coreFFI.h" "$RUNNER_TEMP/ios-include/zeron_coreFFI.h"
           cp "$RUNNER_TEMP/gen/zeron_coreFFI.modulemap" "$RUNNER_TEMP/ios-include/module.modulemap"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: ios-ffi-include
           path: ${{ runner.temp }}/ios-include
@@ -229,7 +229,7 @@ jobs:
     runs-on: macos-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: Select an available iPhone simulator
         run: |
           # The app targets iOS 26: use the newest Xcode 26 and the newest iOS runtime installed.
@@ -252,7 +252,7 @@ jobs:
           rustup update stable --no-self-update
           rustup show active-toolchain || rustup toolchain install
           rustup target add aarch64-apple-ios-sim
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
           cache-on-failure: true
@@ -262,7 +262,7 @@ jobs:
           IPHONEOS_DEPLOYMENT_TARGET=26.0 cargo build --locked -p zeron-mobile --lib --profile mobile --target aarch64-apple-ios-sim
           mkdir -p target/ios-core/iphonesimulator
           cp target/aarch64-apple-ios-sim/mobile/libzeron_mobile.a target/ios-core/iphonesimulator/
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           name: ios-ffi-include
           path: target/ios-core/iphonesimulator/include
@@ -278,7 +278,7 @@ jobs:
             -only-testing:ZeronTests CODE_SIGNING_ALLOWED=NO test
       - name: Upload iOS test results
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: ios-test-results
           path: ${{ runner.temp }}/ios-tests.xcresult
diff --git a/.github/workflows/preview-tests.yml b/.github/workflows/preview-tests.yml
index 75fdc267ee..ccd8363ca8 100644
--- a/.github/workflows/preview-tests.yml
+++ b/.github/workflows/preview-tests.yml
@@ -20,8 +20,8 @@ jobs:
       run:
         working-directory: edge
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 24
           cache: npm
diff --git a/.github/workflows/release-profile-tests.yml b/.github/workflows/release-profile-tests.yml
index 56d1af48b0..12d8dc7d43 100644
--- a/.github/workflows/release-profile-tests.yml
+++ b/.github/workflows/release-profile-tests.yml
@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/linux-ci
         with:
           rust-cache: release-profile-core
@@ -33,7 +33,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/linux-ci
         with:
           rust-cache: release-profile-ui
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 7c9c416338..ad51fa7cd7 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           - runner: ubuntu-24.04-arm # aarch64
     runs-on: ${{ matrix.runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: gpui system deps
         run: |
           sudo apt-get update -qq
@@ -45,10 +45,10 @@ jobs:
             libvulkan-dev pkg-config cmake libwebkit2gtk-4.1-dev libjson-glib-dev
       - name: rust toolchain (rust-toolchain.toml)
         run: rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
       - name: package
         run: scripts/package-linux.sh
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: linux-${{ runner.arch }}
           path: target/package/*.tar.gz
@@ -72,10 +72,10 @@ jobs:
       AC_API_KEY_ID: ${{ secrets.AC_API_KEY_ID }}
       AC_API_ISSUER_ID: ${{ secrets.AC_API_ISSUER_ID }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: rust toolchain (rust-toolchain.toml)
         run: rustup show active-toolchain || rustup toolchain install
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
       - name: import Developer ID certificate
         if: env.MACOS_CERT_P12 != ''
         run: |
@@ -107,7 +107,7 @@ jobs:
           } >>"$GITHUB_ENV"
       - name: package dmg
         run: scripts/package-macos.sh
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: macos-${{ runner.arch }}
           path: |
@@ -122,7 +122,7 @@ jobs:
       run:
         shell: pwsh
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - name: rust toolchain (rust-toolchain.toml)
         run: rustup show active-toolchain || rustup toolchain install
       - name: Locate Windows SDK shader compiler
@@ -131,10 +131,10 @@ jobs:
             Sort-Object FullName -Descending | Select-Object -First 1
           if (-not $fxc) { throw 'Windows SDK fxc.exe is required for GPUI release shaders' }
           "GPUI_FXC_PATH=$($fxc.FullName)" >> $env:GITHUB_ENV
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
       - name: package installer and portable app
         run: ./scripts/package-windows.ps1 -ReleasesUrl "https://github.com/$env:GITHUB_REPOSITORY/releases/latest/download"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: windows-${{ runner.arch }}
           path: |
@@ -152,7 +152,7 @@ jobs:
       CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
       CLOUDFLARE_ACCOUNT_ID: b57dde68ee5964dccc025437b5478a5b
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           path: dist
           merge-multiple: true
@@ -176,7 +176,7 @@ jobs:
               '.files[$name] = {sha256: $sha}' <<<"$manifest")
           done
           printf '%s' "$manifest" > manifest.json
-      - uses: softprops/action-gh-release@v2
+      - uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65 # v2.6.2
         with:
           files: |
             dist/*
diff --git a/.github/workflows/testflight.yml b/.github/workflows/testflight.yml
index f0b425314a..62486aab5f 100644
--- a/.github/workflows/testflight.yml
+++ b/.github/workflows/testflight.yml
@@ -32,7 +32,7 @@ jobs:
       AC_API_ISSUER_ID: ${{ secrets.AC_API_ISSUER_ID }}
       AUDIENCE: ${{ inputs.audience || 'internal' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
 
       - name: Prepare App Store Connect credentials and build number
         shell: bash
@@ -129,7 +129,7 @@ jobs:
         run: |
           rustup show active-toolchain || rustup toolchain install
           rustup target add aarch64-apple-ios aarch64-apple-ios-sim
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           key: ios-core
           cache-on-failure: true
diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 199d33e8a9..75c36c72e6 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -43,7 +43,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/linux-ci
         with:
           rust-cache: core
@@ -55,7 +55,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/linux-ci
         with:
           rust-cache: ui
@@ -73,7 +73,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/linux-ci
         with:
           # Same dependency graph as ui-tests, which saves this cache on main.
@@ -98,7 +98,7 @@ jobs:
           VK_DRIVER_FILES=/dev/null scripts/test-linux-browser.sh "$RUNNER_TEMP/linux-browser/opengl"
       - name: Upload native browser evidence
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: linux-browser
           path: ${{ runner.temp }}/linux-browser
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 24fc44a313..27bde6cf84 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: windows-2022
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/windows-ci-setup
       - name: UI tests
         env:
@@ -69,7 +69,7 @@ jobs:
     runs-on: windows-2022
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/windows-ci-setup
       - name: Native harness security and integration tests
         run: cargo test --release --locked -p zeron-harness --features native-fixture --lib --test codex_availability --test windows_native
@@ -82,7 +82,7 @@ jobs:
     runs-on: windows-2022
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/windows-ci-setup
       - name: Engine unit tests
         run: cargo test --release --locked -p zeron-engine --lib
@@ -95,7 +95,7 @@ jobs:
     runs-on: windows-2022
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
       - uses: ./.github/actions/windows-ci-setup
       - name: Build application
         run: cargo build --release --locked -p zeron
@@ -145,7 +145,7 @@ jobs:
         run: cargo build --release --locked -p zeron-ui --example windows-render-fixture --features windows-render-fixture
       - name: Upload GUI test binaries
         if: ${{ github.event_name == 'workflow_dispatch' && inputs.native_gui }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: windows-gui-binaries
           path: |
@@ -160,8 +160,8 @@ jobs:
     runs-on: windows-2022
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           name: windows-gui-binaries
           path: target/release
@@ -171,7 +171,7 @@ jobs:
         run: ./scripts/test-windows-rendering.ps1
       - name: Upload GUI test results
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: windows-native-probes
           path: |

From c78bb1c106fd5da84b428728a1c807af5e5b29ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Fri, 2 Oct 2026 20:13:47 -0300
Subject: [PATCH 37/74] Rename threads and side chats inline instead of in a
 dialog

Double-clicking a session row in the left sidebar, or a side chat row
under the file tree, now swaps its title for an in-place field with the
name selected. The chat menu's Rename and the /rename command open the
same field. Enter or blur saves a changed, non-empty title; Escape
cancels. The Rename session modal is removed.

A rename started without touching the row first reveals it: the
collapsed Pinned, Sessions, custom section, or device/project group
opens with its usual motion, the Archived shelf opens and pages to the
row, a collapsed sidebar expands, and the list scrolls the row clear of
its edge fades. The explorer's Chats section opens, pages, and scrolls
the same way. When the row cannot be shown (hidden by the project
filter, or a side chat of another chat), no field opens and the sidebar
notice says why.
---
 crates/ui/src/composer.rs                |   5 +
 crates/ui/src/files/mod.rs               |   2 +
 crates/ui/src/files/sections.rs          | 206 ++++++++++++-
 crates/ui/src/shell.rs                   | 358 +++++++++++++++++-----
 crates/ui/src/shell/chat_rename_tests.rs | 374 +++++++++++++++++++++++
 crates/ui/src/shell/files_panel.rs       |   3 +
 crates/ui/src/shell/sidebar_sections.rs  |   1 +
 crates/ui/src/shell/spaces.rs            | 193 +++++++++---
 crates/ui/src/shell/tabs.rs              |   2 +-
 9 files changed, 1023 insertions(+), 121 deletions(-)
 create mode 100644 crates/ui/src/shell/chat_rename_tests.rs

diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 9341bb64a2..9e56f41830 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -3014,6 +3014,11 @@ impl ComposerInput {
     }
 
     fn select_all(&mut self, _: &SelectAll, _: &mut Window, cx: &mut Context<Self>) {
+        self.select_all_text(cx);
+    }
+
+    /// Select the whole draft — an inline rename opens with its name selected.
+    pub fn select_all_text(&mut self, cx: &mut Context<Self>) {
         self.move_to(0, cx);
         self.select_to(self.content.len(), cx);
     }
diff --git a/crates/ui/src/files/mod.rs b/crates/ui/src/files/mod.rs
index e672ec44ad..174436d597 100644
--- a/crates/ui/src/files/mod.rs
+++ b/crates/ui/src/files/mod.rs
@@ -211,6 +211,8 @@ pub enum FilesEvent {
     },
     /// A footer row: open this side chat (by id) in the right pane.
     OpenChildChat(String),
+    /// A footer row's double-click: edit this side chat's title in place.
+    RenameChildChat(String),
     ChildChatContextMenu {
         chat_id: String,
         position: Point<Pixels>,
diff --git a/crates/ui/src/files/sections.rs b/crates/ui/src/files/sections.rs
index cba70073ff..a167316044 100644
--- a/crates/ui/src/files/sections.rs
+++ b/crates/ui/src/files/sections.rs
@@ -18,12 +18,13 @@ use std::hash::{Hash, Hasher};
 
 use chrono::{DateTime, Utc};
 use gpui::{
-    Animation, AnimationExt as _, AnyElement, Context, EntityId, MouseButton, ScrollHandle,
+    Animation, AnimationExt as _, AnyElement, Context, Entity, EntityId, MouseButton, ScrollHandle,
     SharedString, div, prelude::*, px,
 };
 use zeron_doc::{MessagePart, SubagentStatus};
 use zeron_proto::{Chat, ChatIndicator};
 
+use crate::composer::ComposerInput;
 use crate::icons::{self, icon};
 use crate::state::AppState;
 use crate::theme::Theme;
@@ -123,6 +124,12 @@ pub(super) struct ExplorerSections {
     /// re-renders the explorer when a section's contents actually changed —
     /// not on every streamed transcript delta.
     fingerprint: u64,
+    /// The side chat whose title the shell is editing in place, and its
+    /// field — drawn over that row's title.
+    chat_rename: Option<(String, Entity<ComposerInput>)>,
+    /// A section opened to reveal a renamed row: its motion starts on the
+    /// render that knows the body height.
+    reveal: Option<Section>,
 }
 
 impl Default for ExplorerSections {
@@ -140,6 +147,8 @@ impl Default for ExplorerSections {
             .into_iter()
             .collect(),
             fingerprint: 0,
+            chat_rename: None,
+            reveal: None,
         }
     }
 }
@@ -177,6 +186,24 @@ impl ExplorerSections {
         self.open.insert(section, !open);
     }
 
+    /// Start the opening motion of a section a reveal opened.
+    fn begin_reveal(&mut self, section: Section, height: f32) {
+        if self.reveal != Some(section) || !self.is_open(section) {
+            return;
+        }
+        self.reveal = None;
+        let epoch = self.motion.get(&section).map_or(1, |m| m.epoch + 1);
+        self.motion.insert(
+            section,
+            DisclosureMotion {
+                epoch,
+                from: 0.0,
+                to: height,
+                started: std::time::Instant::now(),
+            },
+        );
+    }
+
     fn scroll(&self, section: Section) -> ScrollHandle {
         self.scroll
             .get(&section)
@@ -393,6 +420,47 @@ fn chrome_height() -> f32 {
 }
 
 impl FilesSurface {
+    /// Show (or clear) the shell's inline rename of one of the Chats rows.
+    pub(crate) fn set_chat_rename(
+        &mut self,
+        rename: Option<(String, Entity<ComposerInput>)>,
+        cx: &mut Context<Self>,
+    ) {
+        let key = |rename: &Option<(String, Entity<ComposerInput>)>| {
+            rename
+                .as_ref()
+                .map(|(id, input)| (id.clone(), input.entity_id()))
+        };
+        if key(&self.sections.chat_rename) != key(&rename) {
+            if let Some((chat_id, _)) = &rename {
+                self.reveal_chat_row(chat_id, cx);
+            }
+            self.sections.chat_rename = rename;
+            cx.notify();
+        }
+    }
+
+    /// Open the Chats section, page it, and scroll its list so `chat_id`'s
+    /// row shows — the inline rename's field must never sit on a hidden row.
+    fn reveal_chat_row(&mut self, chat_id: &str, cx: &mut Context<Self>) {
+        let rows = child_chat_rows(self.state.read(cx), &self.chat_id, Utc::now());
+        let Some(index) = rows.iter().position(|row| row.chat_id == chat_id) else {
+            return;
+        };
+        if !self.sections.is_open(Section::Chats) {
+            self.sections.open.insert(Section::Chats, true);
+            self.sections.reveal = Some(Section::Chats);
+        }
+        // Page in the same steps "Show more" takes.
+        if index >= self.sections.shown(Section::Chats) {
+            self.sections.shown.insert(
+                Section::Chats,
+                INITIAL_ROWS + (index + 1 - INITIAL_ROWS).div_ceil(PAGE_ROWS) * PAGE_ROWS,
+            );
+        }
+        self.sections.scroll(Section::Chats).scroll_to_item(index);
+    }
+
     /// Re-render only when the footer's contents changed.
     pub(super) fn refresh_sections(&mut self, cx: &mut Context<Self>) {
         let fingerprint = fingerprint(self.state.read(cx), &self.chat_id, Utc::now());
@@ -520,6 +588,7 @@ impl FilesSurface {
         cx: &mut Context<Self>,
     ) -> AnyElement {
         let open = self.sections.is_open(section);
+        self.sections.begin_reveal(section, height);
         // The collapsed header carries the count; open, the rows speak.
         let label: SharedString = if open || count == 0 {
             section.label().into()
@@ -811,12 +880,36 @@ impl FilesSurface {
             );
             let open_id = row.chat_id.clone();
             let menu_id = row.chat_id.clone();
+            let rename_input = self
+                .sections
+                .chat_rename
+                .as_ref()
+                .filter(|(id, _)| *id == row.chat_id)
+                .map(|(_, input)| input.clone());
+            let title = match rename_input {
+                Some(input) => crate::shell::chat_title_editor(
+                    format!("files-chat-title-editor-{}", row.chat_id).into(),
+                    input,
+                    theme,
+                ),
+                None => row_title(
+                    format!("files-chat-title-{}", row.chat_id),
+                    row.title.clone(),
+                )
+                .into_any_element(),
+            };
             list = list.child(
                 compact_row(format!("files-chat-{}", row.chat_id), theme)
                     .aria_label(SharedString::from(format!("Open side chat {}", row.title)))
-                    .on_click(cx.listener(move |_, _, _, cx| {
+                    .on_click(cx.listener(move |_, event: &gpui::ClickEvent, _, cx| {
                         cx.stop_propagation();
-                        cx.emit(FilesEvent::OpenChildChat(open_id.clone()));
+                        // The first click opened the tab; the second edits
+                        // the title in place.
+                        if event.click_count() >= 2 {
+                            cx.emit(FilesEvent::RenameChildChat(open_id.clone()));
+                        } else {
+                            cx.emit(FilesEvent::OpenChildChat(open_id.clone()));
+                        }
                     }))
                     .on_mouse_down(
                         MouseButton::Right,
@@ -829,10 +922,7 @@ impl FilesSurface {
                         }),
                     )
                     .child(glyph)
-                    .child(row_title(
-                        format!("files-chat-title-{}", row.chat_id),
-                        row.title.clone(),
-                    ))
+                    .child(title)
                     .children(row.change_request.clone().map(|summary| {
                         crate::change_requests::pull_request_badge(
                             format!("files-chat-pr-{}", row.chat_id).into(),
@@ -1268,6 +1358,108 @@ mod tests {
         assert_eq!(rows[0].status, ChatIndicator::Idle);
     }
 
+    #[gpui::test]
+    fn double_clicked_side_chat_asks_for_an_inline_rename(cx: &mut gpui::TestAppContext) {
+        use gpui::{AppContext as _, MouseDownEvent, MouseUpEvent};
+
+        let (files, cx) = super::super::test_support::setup(cx);
+        files.update(cx, |files, cx| {
+            files.state.update(cx, |state, _| {
+                let mut side = chat("side", Some("chat"), 1);
+                side.title = Some("Side work".into());
+                state.chats.push(side);
+            });
+        });
+        cx.update(|window, cx| {
+            window.refresh();
+            window.draw(cx).clear();
+        });
+        let events = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let recorded = events.clone();
+        let _sub = cx.update(|_, cx| {
+            cx.subscribe(&files, move |_, event, _| {
+                recorded.borrow_mut().push(event.clone())
+            })
+        });
+        let row = cx.debug_bounds("files-chat-title-side").unwrap();
+        for click_count in [1, 2] {
+            cx.simulate_event(MouseDownEvent {
+                button: MouseButton::Left,
+                position: row.center(),
+                click_count,
+                ..Default::default()
+            });
+            cx.simulate_event(MouseUpEvent {
+                button: MouseButton::Left,
+                position: row.center(),
+                click_count,
+                ..Default::default()
+            });
+        }
+        cx.run_until_parked();
+        {
+            let events = events.borrow();
+            assert!(matches!(&events[..], [
+                FilesEvent::OpenChildChat(open),
+                FilesEvent::RenameChildChat(rename),
+            ] if open == "side" && rename == "side"));
+        }
+
+        // The shell's field replaces the row title while the edit is open.
+        let input = cx.update(|_, cx| cx.new(|cx| ComposerInput::new("Session title", cx)));
+        files.update(cx, |files, cx| {
+            files.set_chat_rename(Some(("side".into(), input)), cx)
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        assert!(cx.debug_bounds("files-chat-title-editor-side").is_some());
+        assert!(cx.debug_bounds("files-chat-title-side").is_none());
+        files.update(cx, |files, cx| files.set_chat_rename(None, cx));
+        cx.update(|window, cx| window.draw(cx).clear());
+        assert!(cx.debug_bounds("files-chat-title-side").is_some());
+    }
+
+    #[gpui::test]
+    fn inline_rename_reveals_a_side_chat_in_a_collapsed_paged_section(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        use gpui::AppContext as _;
+
+        let (files, cx) = super::super::test_support::setup(cx);
+        files.update(cx, |files, cx| {
+            files.state.update(cx, |state, _| {
+                for ix in 0..12 {
+                    state
+                        .chats
+                        .push(chat(&format!("side-{ix:02}"), Some("chat"), ix));
+                }
+            });
+            files.sections.toggle(Section::Chats, 0.0, 0.0);
+            assert!(!files.sections.is_open(Section::Chats));
+        });
+        cx.update(|window, cx| {
+            window.refresh();
+            window.draw(cx).clear();
+        });
+
+        // Newest first: side-11 is the twelfth row, past the first page.
+        let input = cx.update(|_, cx| cx.new(|cx| ComposerInput::new("Session title", cx)));
+        files.update(cx, |files, cx| {
+            files.set_chat_rename(Some(("side-11".into(), input)), cx)
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        files.read_with(cx, |files, _| {
+            assert!(files.sections.is_open(Section::Chats));
+            assert_eq!(
+                files.sections.shown(Section::Chats),
+                INITIAL_ROWS + PAGE_ROWS
+            );
+            // The reveal became the section's opening motion.
+            assert_eq!(files.sections.reveal, None);
+            assert_eq!(files.sections.motion[&Section::Chats].from, 0.0);
+        });
+        assert!(cx.debug_bounds("files-chat-title-editor-side-11").is_some());
+    }
+
     #[test]
     fn fingerprint_tracks_membership_and_status() {
         let mut state = AppState::new();
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index 54e0070761..ba2b69d131 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -62,6 +62,8 @@ mod actions_ui;
 mod chat_dropzone;
 #[cfg(test)]
 mod chat_dropzone_tests;
+#[cfg(test)]
+mod chat_rename_tests;
 mod command_palette;
 mod file_mutations;
 mod files_panel;
@@ -1016,6 +1018,38 @@ pub(crate) fn sidebar_faded_label(
     .fade_label_overflow(&overflow)
 }
 
+/// A chat row's inline title editor, swapped in for its faded title while
+/// the chat is renamed in place: the title's 13/17 type in an accent-ringed
+/// field.
+pub(crate) fn chat_title_editor(
+    id: SharedString,
+    input: Entity<ComposerInput>,
+    theme: &Theme,
+) -> AnyElement {
+    div()
+        .id(id.clone())
+        .debug_selector(move || id.to_string())
+        .flex_1()
+        .min_w_0()
+        .h(px(21.0))
+        .my(px(-2.0))
+        .px(px(4.0))
+        .flex()
+        .items_center()
+        .rounded(px(4.0))
+        .border_1()
+        .border_color(theme.accent)
+        .bg(theme.input_glass_bg())
+        .text_color(theme.text)
+        .cursor_text()
+        // The field is not the row: clicks place the caret instead of
+        // opening the chat or starting a drag.
+        .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
+        .on_click(|_, _, cx| cx.stop_propagation())
+        .child(div().flex_1().min_w_0().overflow_hidden().child(input))
+        .into_any_element()
+}
+
 /// Ramp height of the sidebar's scroll-edge fade (the gpui
 /// [`gpui::EdgeFade`] scope — per-primitive, so text fades per glyph).
 const SIDEBAR_GLASS_FADE_BAND: f32 = 24.0;
@@ -1358,13 +1392,32 @@ enum SplashPhase {
     Gone,
 }
 
-/// The chat-row Rename dialog.
-struct RenameChatDialog {
+/// How long past a revealing disclosure's motion the sidebar keeps scrolling
+/// a renamed row into view.
+const CHAT_RENAME_REVEAL_GRACE: std::time::Duration = std::time::Duration::from_millis(150);
+
+/// Which list draws a chat's inline title editor: the sidebar's session row,
+/// or the side-chat row in the explorer's Chats footer.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ChatRenameSurface {
+    Sidebar,
+    Explorer,
+}
+
+/// A chat title edited in place on its row (double-click, or Rename in the
+/// chat menu). Enter or blur commits, Escape cancels.
+struct ChatRename {
     chat_id: String,
+    surface: ChatRenameSurface,
     input: Entity<ComposerInput>,
-    /// Focus the input on the dialog's first paint (opened without window access).
+    /// Focus the input on its first paint (opened without window access).
     focus_pending: bool,
+    /// Until when the sidebar scrolls to keep the row in view — long
+    /// enough to follow a disclosure that opened to reveal it.
+    reveal_until: Option<std::time::Instant>,
     _events: Subscription,
+    /// Commit-on-blur, armed once the input has taken focus.
+    _blur: Option<Subscription>,
 }
 
 /// Account lifecycle owned by this process. Sign-in on a local workspace
@@ -1790,6 +1843,9 @@ pub struct Shell {
     /// In-flight disclosure tweens, shared by device groups, Pinned and Archived.
     pub(super) sidebar_disclosure_motion:
         std::collections::HashMap<String, SidebarDisclosureMotion>,
+    /// Disclosures a reveal (an inline rename of a hidden row) just opened;
+    /// each starts its motion on the render that knows its height.
+    pub(super) sidebar_reveal_motions: std::collections::HashSet<String>,
     /// The jump-hint overlay: true while the held modifiers exactly match a
     /// jump shortcut, which swaps the first nine rows' time-ago for their
     /// key-cap chip (t3code's `showJumpHints`). Frame-transient — window
@@ -1873,7 +1929,8 @@ pub struct Shell {
     appearance_settings_sub: Option<Subscription>,
     /// Session-row context menu, including the Copy submenu.
     chat_menu: popover::Popup<ChatMenuState>,
-    rename_dialog: Option<RenameChatDialog>,
+    /// The chat title being edited in place on its row.
+    chat_rename: Option<ChatRename>,
     /// Chat id awaiting delete confirmation.
     delete_confirm: Option<String>,
     /// Global confirmation/error dialog for the Changes-pane trash action. The
@@ -2266,6 +2323,7 @@ impl Shell {
             sessions_open: true,
             archived_shown: 0,
             sidebar_collapsed_groups: std::collections::HashSet::new(),
+            sidebar_reveal_motions: std::collections::HashSet::new(),
             sidebar_disclosure_motion: std::collections::HashMap::new(),
             jump_hints: false,
             terminal: None,
@@ -2321,7 +2379,7 @@ impl Shell {
             files_settings_sub: None,
             appearance_settings_sub: None,
             chat_menu: popover::Popup::default(),
-            rename_dialog: None,
+            chat_rename: None,
             delete_confirm: None,
             discard_working_tree: None,
             discard_working_tree_task: None,
@@ -3666,6 +3724,7 @@ impl Shell {
                     // surface never emits them.
                     FilesEvent::OpenSubagent { .. }
                     | FilesEvent::OpenChildChat(_)
+                    | FilesEvent::RenameChildChat(_)
                     | FilesEvent::ChildChatContextMenu { .. }
                     | FilesEvent::NewChildChat
                     | FilesEvent::ForkChat => {}
@@ -5003,48 +5062,188 @@ impl Shell {
         }));
     }
 
+    /// Start editing `chat_id`'s title in place on its row: the sidebar's
+    /// session row, or — for a side chat — its row under the file tree.
     fn open_rename_chat(&mut self, chat_id: String, cx: &mut Context<Self>) {
         self.close_chat_menu(cx);
-        let current = self
+        if self.chat_rename.is_some() {
+            self.finish_rename_chat(true, cx);
+        }
+        let Some((current, parent, archived)) = self
             .state
             .read(cx)
             .chats
             .iter()
             .find(|c| c.id == chat_id)
-            .and_then(|c| c.title.clone())
-            .unwrap_or_default();
+            .map(|c| {
+                (
+                    c.title.clone().unwrap_or_default(),
+                    c.parent_chat_id.clone(),
+                    c.archived,
+                )
+            })
+        else {
+            return;
+        };
+        // The sidebar lists only top-level chats; side chats live in the
+        // explorer's Chats footer. Either way the row must be on screen
+        // first: a field on a hidden row would take keystrokes unseen.
+        let surface = if parent.is_some() {
+            ChatRenameSurface::Explorer
+        } else {
+            ChatRenameSurface::Sidebar
+        };
+        let revealed = match surface {
+            ChatRenameSurface::Sidebar => self.reveal_sidebar_chat(&chat_id, cx),
+            // The footer lists the open chat's live side chats; it reveals
+            // the row itself once handed the rename.
+            ChatRenameSurface::Explorer => {
+                !archived
+                    && parent.as_deref() == Some(self.active_chat.as_str())
+                    && self.files_panel_open(cx)
+                    && self.files.contains_key(&self.panel_key(cx))
+            }
+        };
+        if !revealed {
+            // The sidebar explains its own refusals.
+            if surface == ChatRenameSurface::Explorer {
+                self.sidebar_notice = Some("Open this side chat's parent to rename it".into());
+            }
+            cx.notify();
+            return;
+        }
         let input = cx.new(|cx| {
-            ComposerInput::new("Session title", cx).with_accessibility_role(gpui::Role::TextInput)
+            ComposerInput::new("Session title", cx)
+                .with_single_line()
+                .with_text_metrics(13.0, 17.0)
+                .with_accessibility_role(gpui::Role::TextInput)
+        });
+        input.update(cx, |input, cx| {
+            input.set_text(current, cx);
+            input.select_all_text(cx);
         });
-        input.update(cx, |input, cx| input.set_text(current, cx));
         let events = cx.subscribe(&input, |this: &mut Shell, _, event, cx| {
             if matches!(event, ComposerInputEvent::Submitted) {
-                this.submit_rename_chat(cx);
+                this.finish_rename_chat(true, cx);
             }
         });
-        self.rename_dialog = Some(RenameChatDialog {
+        // A pending composer refocus (the first click of the double-click
+        // opened the chat, or a side chat's tab) must not steal the field
+        // before it is typed in.
+        for composer in
+            std::iter::once(&self.composer).chain(self.side_chats.values().map(|tab| &tab.composer))
+        {
+            composer.update(cx, |composer, _| composer.focus_pending = false);
+        }
+        self.chat_rename = Some(ChatRename {
             chat_id,
+            surface,
             input,
             focus_pending: true,
+            reveal_until: Some(
+                std::time::Instant::now() + motion::COLLAPSE.total() + CHAT_RENAME_REVEAL_GRACE,
+            ),
             _events: events,
+            _blur: None,
         });
+        self.sync_explorer_chat_rename(cx);
         cx.notify();
     }
 
-    fn submit_rename_chat(&mut self, cx: &mut Context<Self>) {
-        let Some(dialog) = self.rename_dialog.take() else {
+    /// Focus a just-opened inline rename and arm its commit-on-blur.
+    fn focus_rename_chat(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(rename) = self.chat_rename.as_mut() else {
+            return;
+        };
+        if !std::mem::take(&mut rename.focus_pending) {
+            return;
+        }
+        let focus = rename.input.focus_handle(cx);
+        window.focus(&focus, cx);
+        rename._blur = Some(cx.on_blur(&focus, window, |this, _, cx| {
+            this.finish_rename_chat(true, cx);
+        }));
+    }
+
+    /// Close the inline rename, saving a changed, non-empty title when
+    /// `commit` (Enter or blur) and dropping it otherwise (Escape).
+    fn finish_rename_chat(&mut self, commit: bool, cx: &mut Context<Self>) {
+        let Some(rename) = self.chat_rename.take() else {
             return;
         };
-        let title = dialog.input.read(cx).text().trim().to_string();
-        if !title.is_empty() {
+        self.sync_explorer_chat_rename(cx);
+        let title = rename.input.read(cx).text().trim().to_string();
+        let unchanged = self
+            .state
+            .read(cx)
+            .chats
+            .iter()
+            .find(|c| c.id == rename.chat_id)
+            .is_none_or(|c| c.title.as_deref() == Some(title.as_str()));
+        if commit && !title.is_empty() && !unchanged {
             self.mutate(
-                serde_json::json!({ "op": "renameChat", "chatId": dialog.chat_id, "title": title }),
+                serde_json::json!({ "op": "renameChat", "chatId": rename.chat_id, "title": title }),
                 cx,
             );
         }
         cx.notify();
     }
 
+    /// Hand the explorer footers the side-chat rename to draw (or clear it).
+    fn sync_explorer_chat_rename(&mut self, cx: &mut Context<Self>) {
+        let rename = self
+            .chat_rename
+            .as_ref()
+            .filter(|rename| rename.surface == ChatRenameSurface::Explorer)
+            .map(|rename| (rename.chat_id.clone(), rename.input.clone()));
+        for files in self.files.values() {
+            files.update(cx, |files, cx| files.set_chat_rename(rename.clone(), cx));
+        }
+    }
+
+    /// Scroll the sidebar so the renamed row (painted at `row`) clears the
+    /// list's edge fades, while the rename is still revealing it.
+    fn keep_rename_row_in_view(&mut self, row: gpui::Bounds<Pixels>, cx: &mut Context<Self>) {
+        if !self.chat_rename_revealing() {
+            return;
+        }
+        let viewport = self.sidebar_scroll.bounds();
+        let band = px(SIDEBAR_GLASS_FADE_BAND);
+        let delta = if row.top() < viewport.top() + band {
+            row.top() - (viewport.top() + band)
+        } else if row.bottom() > viewport.bottom() - band {
+            row.bottom() - (viewport.bottom() - band)
+        } else {
+            return;
+        };
+        let offset = self.sidebar_scroll.offset();
+        let max = self.sidebar_scroll.max_offset().y;
+        let y = (offset.y - delta).clamp(-max, px(0.0));
+        if y != offset.y {
+            self.sidebar_scroll.set_offset(gpui::point(offset.x, y));
+            cx.notify();
+        }
+    }
+
+    fn chat_rename_revealing(&self) -> bool {
+        self.chat_rename
+            .as_ref()
+            .and_then(|rename| rename.reveal_until)
+            .is_some_and(|until| std::time::Instant::now() < until)
+    }
+
+    /// The inline title editor for `chat_id`'s row on `surface`, if one is open.
+    fn rename_input_for(
+        &self,
+        chat_id: &str,
+        surface: ChatRenameSurface,
+    ) -> Option<Entity<ComposerInput>> {
+        self.chat_rename
+            .as_ref()
+            .filter(|rename| rename.chat_id == chat_id && rename.surface == surface)
+            .map(|rename| rename.input.clone())
+    }
+
     fn archive_chat(&mut self, chat_id: String, cx: &mut Context<Self>) {
         self.set_chat_archived(chat_id, true, cx);
     }
@@ -7279,6 +7478,10 @@ impl Shell {
         };
         let select_id = id.clone();
         let menu_id = id.clone();
+        let search_query_none = search_query.is_none();
+        let rename_input = (search_query_none && !preview)
+            .then(|| self.rename_input_for(&id, ChatRenameSurface::Sidebar))
+            .flatten();
         // Hover fades over transition-colors (zeron session-row.tsx) — both
         // the wash and the title brighten ride the same 150ms blend.
         let fade_key = format!("{row_id}-hover");
@@ -7348,8 +7551,14 @@ impl Shell {
                     })
                 })
                 .cursor_pointer()
-                .on_click(cx.listener(move |this, _, _, cx| {
-                    this.open_chat(select_id.clone(), cx);
+                .on_click(cx.listener(move |this, event: &gpui::ClickEvent, _, cx| {
+                    // The palette's copy of the row only opens; the sidebar's
+                    // double-click edits the title in place.
+                    if event.click_count() >= 2 && search_query_none {
+                        this.open_rename_chat(select_id.clone(), cx);
+                    } else {
+                        this.open_chat(select_id.clone(), cx);
+                    }
                 }))
                 .on_mouse_down(
                     MouseButton::Right,
@@ -7374,6 +7583,31 @@ impl Shell {
                     cx.new(|_| DragGhost)
                 })
             })
+            // A row revealed for an inline rename reports where it painted,
+            // frame by frame while its disclosure opens, so the list can
+            // scroll it clear of the edges.
+            .when(
+                rename_input.is_some() && self.chat_rename_revealing(),
+                |el| {
+                    let shell = cx.weak_entity();
+                    el.child(
+                        gpui::canvas(
+                            |_, _, _| {},
+                            move |bounds, _, window, cx| {
+                                window.defer(cx, move |_, cx| {
+                                    shell
+                                        .update(cx, |this, cx| {
+                                            this.keep_rename_row_in_view(bounds, cx)
+                                        })
+                                        .ok();
+                                });
+                            },
+                        )
+                        .absolute()
+                        .inset_0(),
+                    )
+                },
+            )
             .when(self.chat_hover_resync && !preview, |el| {
                 let shell = cx.weak_entity();
                 let row_id = row_id.clone();
@@ -7455,14 +7689,22 @@ impl Shell {
                         },
                     )
                     .children(project_icon)
-                    .child(sidebar_faded_label(
-                        format!("chat-title-{content_id}").into(),
-                        true,
-                        div()
-                            .text_size(crate::typography::ui_rems(13.0))
-                            .line_height(px(17.0))
-                            .child(popover::search_highlight(title, search_query, theme)),
-                    ))
+                    .child(match rename_input {
+                        Some(input) => chat_title_editor(
+                            format!("chat-title-editor-{content_id}").into(),
+                            input,
+                            theme,
+                        ),
+                        None => sidebar_faded_label(
+                            format!("chat-title-{content_id}").into(),
+                            true,
+                            div()
+                                .text_size(crate::typography::ui_rems(13.0))
+                                .line_height(px(17.0))
+                                .child(popover::search_highlight(title, search_query, theme)),
+                        )
+                        .into_any_element(),
+                    })
                     .when(!compact && !show_label && remote, |el| {
                         el.child(
                             icon(icons::REMOTE_SERVER)
@@ -9209,9 +9451,8 @@ impl Shell {
             self.set_harness_updates_expanded(false, cx);
             return true;
         }
-        if self.rename_dialog.is_some() {
-            self.rename_dialog = None;
-            cx.notify();
+        if self.chat_rename.is_some() {
+            self.finish_rename_chat(false, cx);
             return true;
         }
         if self.rename_space_dialog.is_some() {
@@ -9385,11 +9626,17 @@ impl Shell {
                     .child(
                         popover::menu_row(&theme, false, format!("chat-menu-rename-{chat_id}"))
                             .id("chat-menu-rename")
-                            .on_click(cx.listener(move |this, _, _, cx| {
+                            .on_click(cx.listener(move |this, _, window, cx| {
+                                // A side chat's title is edited on its row
+                                // under the file tree: dock the explorer
+                                // when the menu came from its tab.
+                                if is_side_chat && !this.files_panel_open(cx) {
+                                    this.add_files_surface(window, cx);
+                                }
                                 this.open_rename_chat(rename_id.clone(), cx)
                             }))
                             .child(icon(icons::PEN).size(px(16.0)).text_color(theme.text_muted))
-                            .child(SharedString::from("Rename…")),
+                            .child(SharedString::from("Rename")),
                     )
                     .when(!is_side_chat, |menu| {
                         menu.child(
@@ -9602,52 +9849,6 @@ impl Shell {
             ));
         }
 
-        if let Some(dialog) = &mut self.rename_dialog {
-            if std::mem::take(&mut dialog.focus_pending) {
-                window.focus(&dialog.input.focus_handle(cx), cx);
-            }
-            let input = dialog.input.clone();
-            let card = popover::dialog_card(&theme)
-                .on_key_down(cx.listener(|this, ev: &gpui::KeyDownEvent, _, cx| {
-                    if ev.keystroke.key == "escape" {
-                        this.rename_dialog = None;
-                        cx.notify();
-                        cx.stop_propagation();
-                    }
-                }))
-                .child(popover::dialog_title(&theme, "Rename session"))
-                .child(
-                    div()
-                        .mt(px(12.0))
-                        .child(popover::dialog_field(input.into_any_element())),
-                )
-                .child(
-                    div()
-                        .mt(px(16.0))
-                        .flex()
-                        .flex_row()
-                        .justify_end()
-                        .gap(px(8.0))
-                        .child(
-                            popover::btn_ghost(&theme, "Cancel", "rename-chat-cancel")
-                                .id("rename-chat-cancel")
-                                .on_click(cx.listener(|this, _, _, cx| {
-                                    this.rename_dialog = None;
-                                    cx.notify();
-                                })),
-                        )
-                        .child(
-                            popover::btn_primary(&theme, "Rename")
-                                .id("rename-chat-save")
-                                .on_click(
-                                    cx.listener(|this, _, _, cx| this.submit_rename_chat(cx)),
-                                ),
-                        ),
-                )
-                .into_any_element();
-            overlays.push(popover::modal("rename-chat-dialog", viewport, card));
-        }
-
         overlays.extend(self.render_space_overlays(viewport, window, cx));
         overlays.extend(self.render_section_overlays(viewport, window, cx));
         if let Some(overlay) = self.render_command_palette(viewport, window, cx) {
@@ -12196,6 +12397,7 @@ impl Render for Shell {
                 _ => {}
             }
         }
+        self.focus_rename_chat(window, cx);
 
         self.render_time = Some(std::time::Instant::now());
         if self.all_file_edits_flushed(cx)
diff --git a/crates/ui/src/shell/chat_rename_tests.rs b/crates/ui/src/shell/chat_rename_tests.rs
new file mode 100644
index 0000000000..273597d7b6
--- /dev/null
+++ b/crates/ui/src/shell/chat_rename_tests.rs
@@ -0,0 +1,374 @@
+//! Inline chat renames on the sidebar row, without booting an engine.
+use super::*;
+use gpui::{AppContext, Modifiers, TestAppContext, VisualTestContext};
+
+struct SidebarHost(Entity<Shell>);
+
+impl Render for SidebarHost {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        self.0.update(cx, |shell, cx| {
+            shell.focus_rename_chat(window, cx);
+            div()
+                .w(px(280.0))
+                .h(px(800.0))
+                .capture_key_down(cx.listener(Shell::on_key_down_capture))
+                .child(shell.render_chat_sidebar(&Theme::default(), cx))
+        })
+    }
+}
+
+fn setup(cx: &mut TestAppContext) -> (Entity<Shell>, &mut VisualTestContext) {
+    let dir = tempfile::tempdir().unwrap();
+    cx.update(|cx| {
+        gpui_base::init(cx);
+        cx.set_global(Theme::default());
+        crate::app_menus::init(cx);
+        settings::init(UiSettings::default(), dir.path(), cx);
+        crate::history::init(
+            Default::default(),
+            Default::default(),
+            Default::default(),
+            Default::default(),
+            cx,
+        );
+        apply_keymap(
+            cx,
+            &KeymapConfig::default(),
+            ComposerSendBehavior::default(),
+        );
+    });
+    let (host, cx) = cx.add_window_view(|_, cx| {
+        SidebarHost(cx.new(|cx| {
+            let state = cx.new(|_| AppState::new());
+            let mut shell = Shell::new(
+                state,
+                EngineBootConfig {
+                    data_dir: dir.path().into(),
+                    ipc_port: 0,
+                    edge_url: "http://127.0.0.1:1".into(),
+                    edge_token: None,
+                    org_id: None,
+                    workos_client_id: None,
+                    default_harness: zeron_proto::HarnessId::Mock,
+                },
+                cx,
+            );
+            shell.settings.sidebar_organization = SidebarOrganization::InOneList;
+            shell.reduced_motion = true;
+            shell.state.update(cx, |state, _| {
+                state.workspace_scope = Some(WorkspaceScope::Local);
+                state.local_device_id = Some("local".into());
+                state.no_project = true;
+                state.chats = ["older", "newer"]
+                    .into_iter()
+                    .enumerate()
+                    .map(|(ix, id)| {
+                        serde_json::from_value(serde_json::json!({
+                            "id": id, "title": id, "deviceId": "local", "archived": false,
+                            "createdAt": Utc::now() - chrono::Duration::minutes(10 - ix as i64),
+                        }))
+                        .unwrap()
+                    })
+                    .collect();
+            });
+            shell
+        }))
+    });
+    let shell = host.read_with(cx, |host, _| host.0.clone());
+    cx.update(|window, cx| {
+        window.activate_window();
+        window.draw(cx).clear();
+    });
+    (shell, cx)
+}
+
+fn redraw(cx: &mut VisualTestContext) {
+    cx.update(|window, cx| {
+        window.refresh();
+        window.draw(cx).clear();
+    });
+}
+
+fn double_click(cx: &mut VisualTestContext, position: Point<Pixels>) {
+    for click_count in [1, 2] {
+        cx.simulate_event(MouseDownEvent {
+            button: MouseButton::Left,
+            position,
+            click_count,
+            ..Default::default()
+        });
+        cx.simulate_event(MouseUpEvent {
+            button: MouseButton::Left,
+            position,
+            click_count,
+            ..Default::default()
+        });
+    }
+    redraw(cx);
+}
+
+/// A rename that reached `mutate` reports the missing engine on the sidebar.
+fn mutated(shell: &Entity<Shell>, cx: &mut VisualTestContext) -> bool {
+    shell.read_with(cx, |shell, _| shell.sidebar_notice.is_some())
+}
+
+#[gpui::test]
+fn double_click_edits_a_sidebar_title_in_place(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    let row = cx.debug_bounds("chat-older").unwrap();
+    double_click(cx, row.center());
+
+    // The title swaps for a focused field holding the whole name, selected;
+    // no modal opens.
+    assert!(cx.debug_bounds("chat-title-older").is_none());
+    let field = cx.debug_bounds("chat-title-editor-older").unwrap();
+    assert!(row.contains(&field.center()));
+    let input = shell.read_with(cx, |shell, _| {
+        let rename = shell.chat_rename.as_ref().unwrap();
+        assert_eq!(rename.chat_id, "older");
+        assert_eq!(rename.surface, ChatRenameSurface::Sidebar);
+        rename.input.clone()
+    });
+    cx.update(|window, cx| {
+        assert!(input.focus_handle(cx).is_focused(window));
+        assert_eq!(input.read(cx).text(), "older");
+    });
+
+    // Clicking inside the field keeps editing instead of activating the row.
+    cx.simulate_click(field.center(), Modifiers::default());
+    redraw(cx);
+    assert!(shell.read_with(cx, |shell, _| shell.chat_rename.is_some()));
+
+    // Escape drops the edit without renaming.
+    cx.simulate_keystrokes("escape");
+    redraw(cx);
+    assert!(shell.read_with(cx, |shell, _| shell.chat_rename.is_none()));
+    assert!(cx.debug_bounds("chat-title-older").is_some());
+    assert!(!mutated(&shell, cx));
+
+    // Enter on an unchanged title closes without a mutation.
+    double_click(cx, row.center());
+    cx.simulate_keystrokes("enter");
+    redraw(cx);
+    assert!(shell.read_with(cx, |shell, _| shell.chat_rename.is_none()));
+    assert!(!mutated(&shell, cx));
+
+    // Typing replaces the selected name; Enter commits it.
+    double_click(cx, row.center());
+    cx.simulate_input("Renamed");
+    let input = shell.read_with(cx, |shell, _| {
+        shell.chat_rename.as_ref().unwrap().input.clone()
+    });
+    assert_eq!(
+        input.read_with(cx, |input, _| input.text().to_string()),
+        "Renamed"
+    );
+    cx.simulate_keystrokes("enter");
+    redraw(cx);
+    assert!(shell.read_with(cx, |shell, _| shell.chat_rename.is_none()));
+    assert!(mutated(&shell, cx));
+}
+
+#[gpui::test]
+fn menu_rename_opens_the_same_field_and_blur_commits(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    shell.update(cx, |shell, cx| shell.open_rename_chat("newer".into(), cx));
+    redraw(cx);
+    assert!(cx.debug_bounds("chat-title-editor-newer").is_some());
+    assert!(cx.debug_bounds("chat-title-editor-older").is_none());
+
+    cx.simulate_input("Moved on");
+    // Focus leaving the field saves the edit.
+    cx.update(|window, _| window.blur());
+    redraw(cx);
+    assert!(shell.read_with(cx, |shell, _| shell.chat_rename.is_none()));
+    assert!(mutated(&shell, cx));
+}
+
+/// Open a rename the way `/rename` does — without touching the row.
+fn rename(shell: &Entity<Shell>, cx: &mut VisualTestContext, chat_id: &str) {
+    shell.update(cx, |shell, cx| shell.open_rename_chat(chat_id.into(), cx));
+    redraw(cx);
+}
+
+fn editing(shell: &Entity<Shell>, cx: &mut VisualTestContext) -> Option<String> {
+    shell.read_with(cx, |shell, _| {
+        shell
+            .chat_rename
+            .as_ref()
+            .map(|rename| rename.chat_id.clone())
+    })
+}
+
+fn add_chats(shell: &Entity<Shell>, cx: &mut VisualTestContext, ids: &[&str], archived: bool) {
+    shell.update(cx, |shell, cx| {
+        shell.state.update(cx, |state, _| {
+            for (ix, id) in ids.iter().enumerate() {
+                state.chats.push(
+                    serde_json::from_value(serde_json::json!({
+                        "id": id, "title": id, "deviceId": "local", "archived": archived,
+                        "createdAt": Utc::now() - chrono::Duration::minutes(30 + ix as i64),
+                    }))
+                    .unwrap(),
+                );
+            }
+        });
+        cx.notify();
+    });
+    redraw(cx);
+}
+
+#[gpui::test]
+fn rename_opens_a_collapsed_pinned_section_with_its_motion(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    shell.update(cx, |shell, cx| {
+        shell.set_chat_pinned("older".into(), true, cx);
+        shell.pinned_open = false;
+        cx.notify();
+    });
+    redraw(cx);
+
+    rename(&shell, cx, "older");
+    assert_eq!(editing(&shell, cx).as_deref(), Some("older"));
+    shell.read_with(cx, |shell, _| {
+        assert!(shell.pinned_open);
+        // The queued reveal became the disclosure's opening motion.
+        assert!(shell.sidebar_reveal_motions.is_empty());
+        let motion = shell.sidebar_disclosure_motion["pinned"];
+        assert_eq!(motion.from, 0.0);
+        assert!(motion.to > 0.0);
+    });
+    assert!(cx.debug_bounds("chat-title-editor-older").is_some());
+}
+
+#[gpui::test]
+fn rename_opens_collapsed_sessions_groups_and_the_sidebar(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    shell.update(cx, |shell, cx| {
+        shell.sessions_open = false;
+        shell.settings.sidebar_collapsed = true;
+        cx.notify();
+    });
+    redraw(cx);
+    rename(&shell, cx, "newer");
+    shell.read_with(cx, |shell, _| {
+        assert!(shell.sessions_open);
+        assert!(!shell.settings.sidebar_collapsed);
+    });
+    assert_eq!(editing(&shell, cx).as_deref(), Some("newer"));
+
+    // Grouped by project: the chat's collapsed group opens.
+    shell.update(cx, |shell, cx| {
+        shell.finish_rename_chat(false, cx);
+        shell.settings.sidebar_organization = SidebarOrganization::ByProject;
+        shell
+            .sidebar_collapsed_groups
+            .insert("project:home:local".into());
+        cx.notify();
+    });
+    redraw(cx);
+    rename(&shell, cx, "older");
+    shell.read_with(cx, |shell, _| {
+        assert!(shell.sidebar_collapsed_groups.is_empty());
+        assert!(shell.sidebar_reveal_motions.is_empty());
+    });
+    assert!(cx.debug_bounds("chat-title-editor-older").is_some());
+}
+
+#[gpui::test]
+fn rename_pages_the_archived_shelf_to_its_row(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    let ids: Vec<String> = (0..14).map(|ix| format!("archived-{ix:02}")).collect();
+    add_chats(
+        &shell,
+        cx,
+        &ids.iter().map(String::as_str).collect::<Vec<_>>(),
+        true,
+    );
+    shell.update(cx, |shell, cx| {
+        shell.archived_open = false;
+        cx.notify();
+    });
+    redraw(cx);
+
+    // Oldest last: the 13th row is past the first page of ten.
+    rename(&shell, cx, "archived-12");
+    shell.read_with(cx, |shell, _| {
+        assert!(shell.archived_open);
+        assert_eq!(shell.archived_shown, 35);
+    });
+    assert!(cx.debug_bounds("chat-title-editor-archived-12").is_some());
+}
+
+#[gpui::test]
+fn rename_scrolls_a_far_row_into_view(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    let ids: Vec<String> = (0..40).map(|ix| format!("chat-{ix:02}")).collect();
+    add_chats(
+        &shell,
+        cx,
+        &ids.iter().map(String::as_str).collect::<Vec<_>>(),
+        false,
+    );
+    rename(&shell, cx, "chat-39");
+    for _ in 0..4 {
+        cx.run_until_parked();
+        redraw(cx);
+    }
+    let field = cx.debug_bounds("chat-title-editor-chat-39").unwrap();
+    let viewport = shell.read_with(cx, |shell, _| shell.sidebar_scroll.bounds());
+    assert!(shell.read_with(cx, |shell, _| shell.sidebar_scroll.offset().y < px(0.0)));
+    assert!(field.top() >= viewport.top() && field.bottom() <= viewport.bottom());
+}
+
+#[gpui::test]
+fn rename_refuses_a_row_the_project_filter_hides(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    shell.update(cx, |shell, cx| {
+        shell.settings.space_filter = Some("elsewhere".into());
+        cx.notify();
+    });
+    redraw(cx);
+    rename(&shell, cx, "older");
+    assert_eq!(editing(&shell, cx), None);
+    // The filter is the user's: it stays, and the sidebar says why.
+    shell.read_with(cx, |shell, _| {
+        assert_eq!(shell.settings.space_filter.as_deref(), Some("elsewhere"));
+        assert!(shell.sidebar_notice.is_some());
+    });
+}
+
+#[gpui::test]
+fn rename_expands_a_collapsed_custom_section(cx: &mut TestAppContext) {
+    use zeron_proto::SidebarSectionChange;
+
+    let (shell, cx) = setup(cx);
+    shell.update(cx, |shell, cx| {
+        for change in [
+            SidebarSectionChange::Create {
+                id: "work".into(),
+                name: "Work".into(),
+            },
+            SidebarSectionChange::Assign {
+                session_id: "older".into(),
+                section_id: Some("work".into()),
+            },
+            SidebarSectionChange::Collapse {
+                id: "work".into(),
+                collapsed: true,
+            },
+        ] {
+            assert!(shell.change_sidebar_section(change, cx));
+        }
+    });
+    redraw(cx);
+
+    rename(&shell, cx, "older");
+    shell.update(cx, |shell, cx| {
+        let sections = shell.active_sidebar_sections(cx);
+        assert!(!sections[0].collapsed);
+        assert!(shell.sidebar_reveal_motions.is_empty());
+        assert!(shell.sidebar_disclosure_motion.contains_key("custom:work"));
+    });
+    assert!(cx.debug_bounds("chat-title-editor-older").is_some());
+}
diff --git a/crates/ui/src/shell/files_panel.rs b/crates/ui/src/shell/files_panel.rs
index 6a5495a39d..46164330ef 100644
--- a/crates/ui/src/shell/files_panel.rs
+++ b/crates/ui/src/shell/files_panel.rs
@@ -232,6 +232,9 @@ impl Shell {
                         cx,
                     ),
                     FilesEvent::OpenChildChat(chat_id) => this.open_child_chat_tab(chat_id, cx),
+                    FilesEvent::RenameChildChat(chat_id) => {
+                        this.open_rename_chat(chat_id.clone(), cx)
+                    }
                     FilesEvent::ChildChatContextMenu { chat_id, position } => {
                         this.chat_menu.open(ChatMenuState {
                             chat_id: chat_id.clone(),
diff --git a/crates/ui/src/shell/sidebar_sections.rs b/crates/ui/src/shell/sidebar_sections.rs
index acc66a453d..e1f18a2c85 100644
--- a/crates/ui/src/shell/sidebar_sections.rs
+++ b/crates/ui/src/shell/sidebar_sections.rs
@@ -265,6 +265,7 @@ impl Shell {
                     + SIDEBAR_LIST_GAP * rows.len().saturating_sub(1) as f32
             };
         let motion_key = format!("custom:{id}");
+        self.begin_queued_sidebar_reveal(&motion_key, open, height);
         let hover_id = id.clone();
         let toggle_id = id.clone();
         let toggle_motion = motion_key.clone();
diff --git a/crates/ui/src/shell/spaces.rs b/crates/ui/src/shell/spaces.rs
index 4614f4dd42..f8b96628d1 100644
--- a/crates/ui/src/shell/spaces.rs
+++ b/crates/ui/src/shell/spaces.rs
@@ -2073,6 +2073,10 @@ const SIDEBAR_DISCLOSURE_SECTION_HEIGHT: f32 =
     SIDEBAR_SECTION_GAP + SIDEBAR_DISCLOSURE_HEADER_HEIGHT;
 pub(super) const SIDEBAR_DISCLOSURE_TWEEN_GRACE: std::time::Duration =
     std::time::Duration::from_millis(120);
+/// The Archived shelf shows this many rows, then "Show more" pages by
+/// [`ARCHIVED_PAGE_ROWS`].
+const ARCHIVED_INITIAL_ROWS: usize = 10;
+const ARCHIVED_PAGE_ROWS: usize = 25;
 
 /// Put this machine's device group first without disturbing the recency-based
 /// order of any remote groups. A targeted promotion is more truthful than a
@@ -4298,6 +4302,127 @@ impl Shell {
         visible
     }
 
+    /// The group a chat's row sits under when the sidebar groups by device or
+    /// by project; `None` in one list.
+    fn sidebar_group_key(&self, chat: &zeron_proto::Chat) -> Option<String> {
+        match self.settings.sidebar_organization {
+            SidebarOrganization::ByDevice => Some(chat.device_id.clone()),
+            SidebarOrganization::ByProject => Some(
+                chat.space_id
+                    .clone()
+                    .unwrap_or_else(|| format!("home:{}", chat.device_id)),
+            ),
+            SidebarOrganization::InOneList => None,
+        }
+    }
+
+    /// A device/project group's key in `sidebar_collapsed_groups`.
+    fn sidebar_group_collapse_key(&self, group: &str) -> String {
+        let organization = match self.settings.sidebar_organization {
+            SidebarOrganization::ByDevice => "device",
+            SidebarOrganization::ByProject => "project",
+            SidebarOrganization::InOneList => "list",
+        };
+        format!("{organization}:{group}")
+    }
+
+    /// Open whatever hides `chat_id`'s sidebar row — the sidebar itself, the
+    /// Pinned / Sessions / Archived disclosure, its custom section or group,
+    /// the Archived page — so an inline rename has a row to draw on. Each
+    /// disclosure opens with its usual motion. False when the row cannot be
+    /// shown: the project filter hides it (the filter is the user's to
+    /// clear), or a synced section could not be expanded. Either way the
+    /// sidebar notice says why.
+    pub(super) fn reveal_sidebar_chat(&mut self, chat_id: &str, cx: &mut Context<Self>) -> bool {
+        let (active, archived) = {
+            let state = self.state.read(cx);
+            let active = state
+                .sidebar_chats(Utc::now(), self.settings.space_filter.as_deref())
+                .into_iter()
+                .find(|(_, chat)| chat.id == chat_id)
+                .map(|(_, chat)| chat.clone());
+            let archived = self
+                .archived_sidebar_chats(cx)
+                .iter()
+                .position(|chat| chat.id == chat_id);
+            (active, archived)
+        };
+        if active.is_none() && archived.is_none() {
+            self.sidebar_notice = Some("Clear the project filter to rename this session".into());
+            return false;
+        }
+        if let Some(chat) = &active {
+            if self.active_sidebar_pins(cx).contains(&chat.id) {
+                if !self.pinned_open {
+                    self.pinned_open = true;
+                    self.queue_sidebar_reveal("pinned");
+                }
+            } else if let Some(section) = self
+                .active_sidebar_sections(cx)
+                .into_iter()
+                .find(|section| section.session_ids.contains(&chat.id))
+            {
+                if section.collapsed {
+                    if !self.change_sidebar_section(
+                        zeron_proto::SidebarSectionChange::Collapse {
+                            id: section.id.clone(),
+                            collapsed: false,
+                        },
+                        cx,
+                    ) {
+                        return false;
+                    }
+                    self.queue_sidebar_reveal(&format!("custom:{}", section.id));
+                }
+            } else if let Some(group) = self.sidebar_group_key(chat) {
+                let collapse_key = self.sidebar_group_collapse_key(&group);
+                if self.sidebar_collapsed_groups.remove(&collapse_key) {
+                    self.queue_sidebar_reveal(&format!("group:{collapse_key}"));
+                }
+            } else if !self.sessions_open {
+                self.sessions_open = true;
+                self.queue_sidebar_reveal("sessions");
+            }
+        } else if let Some(index) = archived {
+            if !self.archived_open {
+                self.archived_open = true;
+                self.archived_shown = ARCHIVED_INITIAL_ROWS;
+                self.queue_sidebar_reveal("archived");
+            }
+            // Page the shelf just far enough to include the row, in the
+            // same steps "Show more" takes.
+            let shown = self.archived_shown.max(ARCHIVED_INITIAL_ROWS);
+            if index >= shown {
+                self.archived_shown = ARCHIVED_INITIAL_ROWS
+                    + (index + 1 - ARCHIVED_INITIAL_ROWS).div_ceil(ARCHIVED_PAGE_ROWS)
+                        * ARCHIVED_PAGE_ROWS;
+            }
+        }
+        if self.settings.sidebar_collapsed {
+            self.toggle_sidebar(cx);
+        }
+        cx.notify();
+        true
+    }
+
+    /// Mark a disclosure opened for a reveal: its motion starts on the next
+    /// render, where the body height is known. Like a header click, it
+    /// replaces the resort glide for this movement.
+    fn queue_sidebar_reveal(&mut self, key: &str) {
+        self.sidebar_reveal_motions.insert(key.to_owned());
+        self.sidebar_prev_order.clear();
+        self.sidebar_resort.clear();
+        self.sidebar_new_keys.clear();
+    }
+
+    /// Start a revealed disclosure's opening motion now that its height is
+    /// known.
+    pub(super) fn begin_queued_sidebar_reveal(&mut self, key: &str, open: bool, body_height: f32) {
+        if open && self.sidebar_reveal_motions.remove(key) {
+            self.begin_sidebar_disclosure_motion(key, 0.0, body_height);
+        }
+    }
+
     /// Shared metadata and visibility settings for active and archived sessions.
     fn sidebar_chat_data(
         &self,
@@ -4333,16 +4458,13 @@ impl Shell {
             .change_request_for_chat(&chat)
             .cloned()
             .filter(|_| self.settings.sidebar_show_pull_request);
-        let group = match self.settings.sidebar_organization {
-            SidebarOrganization::ByDevice => Some((chat.device_id.clone(), device)),
-            SidebarOrganization::ByProject => Some((
-                chat.space_id
-                    .clone()
-                    .unwrap_or_else(|| format!("home:{}", chat.device_id)),
-                project,
-            )),
-            SidebarOrganization::InOneList => None,
-        };
+        let group = self.sidebar_group_key(&chat).map(|key| {
+            let label = match self.settings.sidebar_organization {
+                SidebarOrganization::ByDevice => device,
+                _ => project,
+            };
+            (key, label)
+        });
         ActiveChatRow {
             status,
             chat: chat.clone(),
@@ -4771,12 +4893,7 @@ impl Shell {
                     continue;
                 }
             }
-            let organization = match self.settings.sidebar_organization {
-                SidebarOrganization::ByDevice => "device",
-                SidebarOrganization::ByProject => "project",
-                SidebarOrganization::InOneList => "list",
-            };
-            let collapse_key = format!("{organization}:{key}");
+            let collapse_key = self.sidebar_group_collapse_key(&key);
             let motion_key = format!("group:{collapse_key}");
             let collapsed = self.sidebar_collapsed_groups.contains(&collapse_key);
             let row_count = rendered_rows.len();
@@ -4788,6 +4905,7 @@ impl Shell {
                     .map(|(_, height, _)| *height)
                     .sum::<f32>()
                 + SIDEBAR_LIST_GAP * row_count.saturating_sub(1) as f32;
+            self.begin_queued_sidebar_reveal(&motion_key, !collapsed, body_height);
             let body = div()
                 .w_full()
                 .flex()
@@ -4864,6 +4982,7 @@ impl Shell {
         cx: &mut Context<Self>,
     ) -> AnyElement {
         let open = self.pinned_open;
+        self.begin_queued_sidebar_reveal("pinned", open, body_height);
         let label = if open {
             "Pinned".into()
         } else {
@@ -4944,6 +5063,7 @@ impl Shell {
             return content;
         }
         let open = self.sessions_open;
+        self.begin_queued_sidebar_reveal("sessions", open, body_height);
         let label = if open {
             "Sessions".into()
         } else {
@@ -5009,6 +5129,24 @@ impl Shell {
             .into_any_element()
     }
 
+    /// The Archived shelf's chats under the project filter, in sidebar order.
+    fn archived_sidebar_chats(&self, cx: &App) -> Vec<zeron_proto::Chat> {
+        let filter = self.settings.space_filter.as_deref();
+        let mut rows: Vec<zeron_proto::Chat> = self
+            .state
+            .read(cx)
+            .chats
+            .iter()
+            // Spawned children stay out of the Archived section too — the
+            // same top-level rule as `visible_chats`.
+            .filter(|c| c.archived && c.parent_chat_id.is_none())
+            .filter(|chat| filter.is_none_or(|space_id| chat.space_id.as_deref() == Some(space_id)))
+            .cloned()
+            .collect();
+        rows.sort_by(|left, right| compare_sidebar_chats(self.settings.sidebar_sort, left, right));
+        rows
+    }
+
     /// Archived sessions share active-row data and layout, with a restore action.
     /// The shelf starts with ten sessions and pages by 25.
     pub(super) fn render_archived_section(
@@ -5016,26 +5154,10 @@ impl Shell {
         theme: &Theme,
         cx: &mut Context<Self>,
     ) -> Option<AnyElement> {
-        const INITIAL: usize = 10;
-        const PAGE: usize = 25;
+        const INITIAL: usize = ARCHIVED_INITIAL_ROWS;
+        const PAGE: usize = ARCHIVED_PAGE_ROWS;
         let now = Utc::now();
-        let filter = self.settings.space_filter.clone();
-        let mut rows: Vec<zeron_proto::Chat> = {
-            let state = self.state.read(cx);
-            state
-                .chats
-                .iter()
-                // Spawned children stay out of the Archived section too — the
-                // same top-level rule as `visible_chats`.
-                .filter(|c| c.archived && c.parent_chat_id.is_none())
-                .filter(|chat| match &filter {
-                    Some(space_id) => chat.space_id.as_deref() == Some(space_id.as_str()),
-                    None => true,
-                })
-                .cloned()
-                .collect()
-        };
-        rows.sort_by(|left, right| compare_sidebar_chats(self.settings.sidebar_sort, left, right));
+        let rows = self.archived_sidebar_chats(cx);
         if rows.is_empty() {
             return None;
         }
@@ -5078,6 +5200,7 @@ impl Shell {
             } else {
                 0.0
             };
+        self.begin_queued_sidebar_reveal("archived", open, body_height);
         // Match Pinned: a muted label with a right-aligned disclosure chevron.
         // The count only shows while collapsed.
         let label: SharedString = if open {
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index 88e07be64d..86939861e9 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -110,7 +110,7 @@ impl Shell {
             || self.sync_flow.has_visible_overlay()
             || self.delete_confirm.is_some()
             || self.delete_space_confirm.is_some()
-            || self.rename_dialog.is_some()
+            || self.chat_rename.is_some()
             || self.rename_space_dialog.is_some()
             || self.discard_working_tree.is_some()
             || self.chat_menu.get().is_some()

From 46bedeca053887b60b960c925e39b9bc56230e51 Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Fri, 2 Oct 2026 16:21:25 -0700
Subject: [PATCH 38/74] Test the inline rename in both full and compact sidebar
 rows

The rename tests run with the default compact rows; cover the full layout too,
and check that the field replaces the title without changing the row height.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/shell/chat_rename_tests.rs | 27 ++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/crates/ui/src/shell/chat_rename_tests.rs b/crates/ui/src/shell/chat_rename_tests.rs
index 273597d7b6..195d935587 100644
--- a/crates/ui/src/shell/chat_rename_tests.rs
+++ b/crates/ui/src/shell/chat_rename_tests.rs
@@ -372,3 +372,30 @@ fn rename_expands_a_collapsed_custom_section(cx: &mut TestAppContext) {
     });
     assert!(cx.debug_bounds("chat-title-editor-older").is_some());
 }
+
+#[gpui::test]
+fn inline_rename_keeps_the_row_height_in_compact_and_full_rows(cx: &mut TestAppContext) {
+    let (shell, cx) = setup(cx);
+    for compact in [true, false] {
+        shell.update(cx, |shell, cx| {
+            shell.settings.sidebar_compact = compact;
+            cx.notify();
+        });
+        redraw(cx);
+        let row = cx.debug_bounds("chat-older").unwrap();
+        double_click(cx, row.center());
+
+        // The field takes the title's place without growing the row.
+        let field = cx.debug_bounds("chat-title-editor-older").unwrap();
+        assert!(row.contains(&field.center()), "compact: {compact}");
+        assert_eq!(
+            cx.debug_bounds("chat-older").unwrap().size.height,
+            row.size.height,
+            "compact: {compact}"
+        );
+
+        cx.simulate_keystrokes("escape");
+        redraw(cx);
+        assert!(shell.read_with(cx, |shell, _| shell.chat_rename.is_none()));
+    }
+}

From 2a884777a5a399c126c25fc6f5bd77c306a62983 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Fri, 2 Oct 2026 22:46:12 -0700
Subject: [PATCH 39/74] Fix Shift+Backspace in composer and palette inputs
 (#757)

---
 crates/ui/src/composer.rs | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 4dc7460245..da9b121fda 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -1499,6 +1499,7 @@ fn input_bindings(context: &'static str) -> Vec<KeyBinding> {
         KeyBinding::new("shift-tab", OutdentList, ctx),
         KeyBinding::new("shift-enter", Newline, ctx),
         KeyBinding::new("backspace", Backspace, ctx),
+        KeyBinding::new("shift-backspace", Backspace, ctx),
         KeyBinding::new("delete", Delete, ctx),
         KeyBinding::new("left", Left, ctx),
         KeyBinding::new("right", Right, ctx),
@@ -1618,6 +1619,7 @@ pub fn init(cx: &mut App, send_behavior: ComposerSendBehavior) {
     let palette = Some(PALETTE_SEARCH_CONTEXT);
     let mut palette_bindings = vec![
         KeyBinding::new("backspace", Backspace, palette),
+        KeyBinding::new("shift-backspace", Backspace, palette),
         KeyBinding::new("delete", Delete, palette),
         KeyBinding::new("home", Home, palette),
         KeyBinding::new("end", End, palette),
@@ -10930,6 +10932,54 @@ mod tests {
             .unwrap();
     }
 
+    #[gpui::test]
+    fn shift_backspace_deletes_text_and_selection_in_all_input_contexts(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            init(cx, ComposerSendBehavior::default());
+        });
+        for context in [
+            GENERIC_COMPOSER_CONTEXT,
+            MESSAGE_COMPOSER_CONTEXT,
+            PALETTE_SEARCH_CONTEXT,
+        ] {
+            let handle = cx.add_window(|window, cx| {
+                let mut input = ComposerInput::with_context("", context, cx);
+                input.set_text("café", cx);
+                window.focus(&input.focus_handle, cx);
+                input
+            });
+            cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+                .unwrap();
+            cx.simulate_keystrokes(handle.into(), "shift-backspace");
+            handle
+                .update(cx, |input, _, cx| {
+                    assert_eq!(input.text(), "caf", "{context}");
+                    input.set_text("hello world", cx);
+                    input.move_to(6, cx);
+                    input.extend_selection(11, cx);
+                })
+                .unwrap();
+            cx.simulate_keystrokes(handle.into(), "shift-backspace");
+            handle
+                .update(cx, |input, _, cx| {
+                    assert_eq!(input.text(), "hello ", "{context}");
+                    input.set_text("", cx);
+                })
+                .unwrap();
+            cx.simulate_keystrokes(handle.into(), "shift-backspace");
+            assert_eq!(
+                handle
+                    .read_with(cx, |input, _| input.text().to_owned())
+                    .unwrap(),
+                ""
+            );
+        }
+    }
+
     #[gpui::test]
     fn dock_morph_restores_skinny_height_with_a_continuous_editor_origin(
         cx: &mut gpui::TestAppContext,

From 612df5126130c3117c80eb24483fec56fbd9bed3 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Fri, 2 Oct 2026 22:46:18 -0700
Subject: [PATCH 40/74] fix(preview): leave authentication callback listeners
 unprobed (#763)

---
 crates/preview/src/discovery.rs   |  75 +++++++++++++++++++-
 crates/preview/src/service.rs     |   1 +
 crates/preview/tests/discovery.rs | 114 ++++++++++++++++++++++++++++++
 docs/preview-networking.md        |  16 ++++-
 4 files changed, 202 insertions(+), 4 deletions(-)

diff --git a/crates/preview/src/discovery.rs b/crates/preview/src/discovery.rs
index 34fe6cb71a..0ee2977cae 100644
--- a/crates/preview/src/discovery.rs
+++ b/crates/preview/src/discovery.rs
@@ -1,5 +1,6 @@
 //! Observe only this user's listeners. HTTP probes run only after project
-//! ownership has been established from the process's actual working directory.
+//! ownership has been established from the process's actual working directory
+//! and commands performing authentication have been excluded.
 use std::{
     collections::HashMap,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
@@ -23,6 +24,31 @@ impl Listener {
     pub fn belongs_to(&self, root: &Path) -> bool {
         self.cwd.starts_with(root)
     }
+
+    /// A login CLI may open an HTTP listener in the project's cwd, but that
+    /// listener is a browser callback, not a development server. Some (such as
+    /// Infisical) abort the login on an unsolicited HEAD, so exclude explicit
+    /// authentication commands before connecting at all. Match whole arguments,
+    /// not paths, URLs or source strings that happen to mention authentication.
+    pub(crate) fn is_authentication_command(&self) -> bool {
+        self.args
+            .iter()
+            .skip(1)
+            .take_while(|arg| arg.as_str() != "--")
+            .any(|arg| {
+                matches!(
+                    arg.as_str(),
+                    "login"
+                        | "auth"
+                        | "authenticate"
+                        | "signin"
+                        | "sign-in"
+                        | "sso"
+                        | "oauth"
+                        | "oauth2"
+                )
+            })
+    }
 }
 
 /// Preserve a useful framework label without advertising process arguments,
@@ -432,6 +458,53 @@ pub fn same_process(_pid: u32, _started_at: u64) -> bool {
 mod tests {
     use super::*;
     #[test]
+    fn authentication_commands_are_not_preview_candidates() {
+        let listener = |args: &[&str]| Listener {
+            pid: 1,
+            parent: 0,
+            cwd: "/project".into(),
+            args: args.iter().map(|arg| (*arg).into()).collect(),
+            started_at: 1,
+            address: "127.0.0.1:3000".parse().unwrap(),
+            zeron_owned: true,
+        };
+        for args in [
+            vec!["/usr/bin/infisical", "login"],
+            vec![
+                "infisical",
+                "--silent",
+                "login",
+                "--domain",
+                "https://app.infisical.com",
+            ],
+            vec!["gh", "auth", "login"],
+            vec!["aws", "sso", "login"],
+            vec!["gcloud", "auth", "application-default", "login"],
+            vec!["codex", "login"],
+            vec!["node", "/tools/firebase.js", "login"],
+            vec!["cli", "authenticate"],
+            vec!["cli", "signin"],
+            vec!["cli", "sign-in"],
+            vec!["cli", "oauth"],
+            vec!["cli", "oauth2"],
+        ] {
+            assert!(listener(&args).is_authentication_command(), "{args:?}");
+        }
+        for args in [
+            vec![],
+            vec!["node", "/project/auth/server.js"],
+            vec!["node", "/project/login.js"],
+            vec!["node", "/project/node_modules/vite/bin/vite.js"],
+            vec!["next", "dev"],
+            vec!["python3", "-m", "http.server", "3000"],
+            vec!["python3", "-c", "import auth; auth.serve()"],
+            vec!["server", "--auth", "--login-url=https://example.com/login"],
+            vec!["infisical", "run", "--", "node", "server.js", "login"],
+        ] {
+            assert!(!listener(&args).is_authentication_command(), "{args:?}");
+        }
+    }
+    #[test]
     fn service_identity_ignores_port_configuration() {
         let args = |port: &str| vec!["node".into(), "api.js".into(), "--port".into(), port.into()];
         assert_eq!(
diff --git a/crates/preview/src/service.rs b/crates/preview/src/service.rs
index ae028d45c1..9416093ad5 100644
--- a/crates/preview/src/service.rs
+++ b/crates/preview/src/service.rs
@@ -226,6 +226,7 @@ impl PreviewService {
                             .filter(|l| {
                                 l.address.port() != zeron_proto::PREVIEW_PROXY_PORT
                                     && l.pid != std::process::id()
+                                    && !l.is_authentication_command()
                             })
                             .filter_map(|listener| {
                                 roots
diff --git a/crates/preview/tests/discovery.rs b/crates/preview/tests/discovery.rs
index 6228ea5abe..3d511e77ce 100644
--- a/crates/preview/tests/discovery.rs
+++ b/crates/preview/tests/discovery.rs
@@ -157,3 +157,117 @@ async fn a_discovered_server_is_probed_once_not_every_cycle() {
     );
     service.shutdown().await;
 }
+
+/// Infisical's browser login decodes the first callback request as JSON. A
+/// discovery HEAD has no body and aborts that login with EOF. Even opening a
+/// connection to these one-shot listeners is outside preview discovery's remit.
+#[tokio::test]
+async fn authentication_callbacks_receive_no_discovery_connections() {
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    let _serial = SERIAL.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let app = temp.path().join("app");
+    std::fs::create_dir(&app).unwrap();
+    let ready = temp.path().join("callback-port");
+    let connections = temp.path().join("callback-connections");
+    let script = format!(
+        r#"import json,socket
+s=socket.socket()
+s.bind(('127.0.0.1',0))
+s.listen()
+open({ready:?},'w').write(str(s.getsockname()[1]))
+c,_=s.accept()
+open({connections:?},'a').write('connected\n')
+r=c.makefile('rb')
+request=r.readline()
+headers={{}}
+while True:
+    line=r.readline()
+    if line in (b'\r\n',b''): break
+    name,value=line.decode().split(':',1)
+    headers[name.lower()]=value.strip()
+body=r.read(int(headers.get('content-length','0')))
+if not body: raise RuntimeError('EOF')
+assert request.startswith(b'POST ')
+assert json.loads(body)=={{'code':'test-code'}}
+c.sendall(b'HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK')
+"#,
+        ready = ready.display().to_string(),
+        connections = connections.display().to_string(),
+    );
+    let mut callback = Child(
+        std::process::Command::new("python3")
+            .args([
+                "-c",
+                &script,
+                "login",
+                "--domain",
+                "https://app.infisical.com",
+            ])
+            .current_dir(&app)
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::inherit())
+            .spawn()
+            .unwrap(),
+    );
+    let port: u16 = tokio::time::timeout(Duration::from_secs(5), async {
+        loop {
+            if let Some(port) = std::fs::read_to_string(&ready)
+                .ok()
+                .and_then(|s| s.parse::<u16>().ok())
+            {
+                break port;
+            }
+            tokio::time::sleep(Duration::from_millis(20)).await;
+        }
+    })
+    .await
+    .expect("callback did not start");
+    let server = launch(&app, true);
+    let service = PreviewService::new(
+        temp.path().join("names.json"),
+        "local".into(),
+        "Laptop".into(),
+    )
+    .unwrap();
+    let roots = vec![app];
+    service.start(Arc::new(move || roots.clone()), None).await;
+    wait(&service, Some(server.0.id())).await;
+    // Discovery actually runs, including multiple cycles after the ordinary
+    // development server is found. The callback must remain entirely untouched.
+    tokio::time::sleep(Duration::from_secs(5)).await;
+    assert!(
+        !connections.exists(),
+        "preview discovery connected to the authentication callback"
+    );
+    assert!(callback.0.try_wait().unwrap().is_none());
+
+    // The real browser request can still finish the waiting sign-in.
+    let body = r#"{"code":"test-code"}"#;
+    let mut browser = tokio::net::TcpStream::connect(("127.0.0.1", port))
+        .await
+        .unwrap();
+    browser
+        .write_all(
+            format!(
+                "POST / HTTP/1.1\r\nHost: localhost:{port}\r\nContent-Length: {}\r\n\r\n{body}",
+                body.len()
+            )
+            .as_bytes(),
+        )
+        .await
+        .unwrap();
+    let mut response = String::new();
+    tokio::time::timeout(
+        Duration::from_secs(5),
+        browser.read_to_string(&mut response),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert!(response.starts_with("HTTP/1.1 200 OK"));
+    assert_eq!(std::fs::read_to_string(connections).unwrap(), "connected\n");
+    assert!(callback.0.wait().unwrap().success());
+    service.shutdown().await;
+}
diff --git a/docs/preview-networking.md b/docs/preview-networking.md
index c90ac722f3..23356c503e 100644
--- a/docs/preview-networking.md
+++ b/docs/preview-networking.md
@@ -16,9 +16,19 @@ On Linux, the scanner joins the current user's `/proc` process cwd, ancestry,
 creation time and socket descriptors to listening TCP sockets. On macOS it uses
 `lsof` and `ps` for equivalent metadata. Only loopback-reachable listeners whose
 cwd belongs to a known local project are probed. The deepest matching project
-wins. Unrelated listeners and non-HTTP services are excluded. HTTP probes are
-bounded and run every two seconds, using HEAD and accepting valid HTTP status
-responses (including authentication and application errors).
+wins. Commands with explicit authentication arguments (`login`, `auth`,
+`authenticate`, `signin`, `sign-in`, `sso`, `oauth`, or `oauth2`, before `--`)
+are excluded before any connection, even when started by a Zeron terminal or
+agent. Their listeners may be one-shot browser callbacks: for example,
+`infisical login` fails with EOF if it receives a discovery HEAD without the
+browser's JSON body. This command check does not identify custom callback
+servers without an authentication argument.
+
+Unrelated listeners and non-HTTP services are excluded. Discovery runs every
+two seconds; bounded HEAD probes accept valid HTTP status responses (including
+authentication and application errors). Confirmed HTTP listeners are not
+probed again during that socket's lifetime; non-HTTP results use a capped
+exponential backoff.
 
 Zeron terminal/task/agent descendants are marked as Zeron-owned. Framework
 commands identify Vite, Next.js, Astro, Miniflare and Node servers; otherwise the

From e96eccb1aab3bf63fc475f5e85d2935736940cc9 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Fri, 2 Oct 2026 22:46:24 -0700
Subject: [PATCH 41/74] Keep activity loaders pulsing with system reduced
 motion (#754)

---
 crates/ui/src/loaders.rs              |  12 +-
 crates/ui/src/motion.rs               | 220 ++++++++++++++++++++++++++
 crates/ui/src/settings/appearance.rs  |   4 +-
 docs/reference/windows-development.md |   6 +
 4 files changed, 236 insertions(+), 6 deletions(-)

diff --git a/crates/ui/src/loaders.rs b/crates/ui/src/loaders.rs
index 182b45fe36..9718a4ded0 100644
--- a/crates/ui/src/loaders.rs
+++ b/crates/ui/src/loaders.rs
@@ -6,7 +6,9 @@
 //! come from [`motion::staggered_phase`], so all cells stay phase-locked.
 //! Cells animate inside fixed-size slots — opacity and inner size
 //! are paint-local and never move surrounding layout. Reduced motion snaps every
-//! cell to its rest state automatically (gpui `reduce_motion`).
+//! cell to its rest state automatically (gpui `reduce_motion`). Activity grids
+//! retain a gentle brightness pulse with system reduced motion; explicit On
+//! and background pause keep them still.
 
 use gpui::{
     AnyElement, App, AppContext, Context, Entity, EntityId, IntoElement, ParentElement,
@@ -121,7 +123,7 @@ pub fn gradient_spinner(
 ) -> impl IntoElement {
     let center = (MATRIX_SIDE as f32 - 1.0) / 2.0;
     let max = MATRIX_SIDE as f32 - 1.0 + center;
-    let delta = motion::pulse_delta_slow(&GRADIENT_SPIN, view, cx);
+    let pulse = motion::activity_pulse_slow(view, cx);
     div()
         .flex()
         .flex_col()
@@ -141,7 +143,7 @@ pub fn gradient_spinner(
                         .size(px(cell_px))
                         .rounded(px(cell_px / 2.0))
                         .bg(tint)
-                        .opacity(motion::gspin_opacity(delta + phase, GSPIN_DIM))
+                        .opacity(pulse.opacity(phase, GSPIN_DIM))
                 }))
         }))
 }
@@ -246,7 +248,7 @@ fn mini_spinner_cells(
     /// (0,0) → (0,1) → (1,1) → (2,1) → (2,0) → (1,0).
     const RING: [[usize; COLS]; ROWS] = [[0, 1], [5, 2], [4, 3]];
     const RING_LEN: f32 = (COLS * ROWS) as f32;
-    let delta = motion::pulse_delta(&GRADIENT_SPIN, view, cx);
+    let pulse = motion::activity_pulse(view, cx);
     div()
         .flex()
         .flex_col()
@@ -263,7 +265,7 @@ fn mini_spinner_cells(
                         .size(px(cell_px))
                         .rounded(px(cell_px / 2.0))
                         .bg(tint)
-                        .opacity(motion::gspin_opacity(delta + phase, GSPIN_DIM))
+                        .opacity(pulse.opacity(phase, GSPIN_DIM))
                 }))
         }))
 }
diff --git a/crates/ui/src/motion.rs b/crates/ui/src/motion.rs
index 3726af509c..4b91ab786a 100644
--- a/crates/ui/src/motion.rs
+++ b/crates/ui/src/motion.rs
@@ -21,6 +21,8 @@
 //! switch; pure helpers take the flag explicitly where they run outside elements.
 //! [`ReduceMotion`] drives that switch from the OS accessibility setting or the
 //! user's override, and optionally from main-window focus.
+//! Activity grids use [`ActivityPulse`] to retain a gentle brightness cue under
+//! system reduced motion; explicit On and background pause keep them still.
 //!
 //! translateY is implemented as a relative-position `top` inset: taffy applies
 //! relative insets after layout, so — like a CSS transform — siblings never move.
@@ -122,10 +124,59 @@ fn pulse_delta_every(spec: &MotionSpec, view: EntityId, stride: u64, cx: &mut Ap
         return 0.0;
     }
     pulse_lease_every(view, stride, cx);
+    pulse_phase(spec, cx)
+}
+
+fn pulse_phase(spec: &MotionSpec, cx: &mut App) -> f32 {
     let clock = cx.default_global::<PulseClock>();
     (clock.epoch.elapsed().as_secs_f32() / spec.total().as_secs_f32()).fract()
 }
 
+/// Activity feedback uses a slow, uniform brightness pulse when the system
+/// reduces motion. Explicit On and background pause still stop all animation.
+/// Decorative animation continues to use the reduced-motion-gated helpers.
+#[derive(Clone, Copy)]
+pub struct ActivityPulse {
+    phase: f32,
+    subtle: bool,
+}
+
+impl ActivityPulse {
+    pub fn opacity(&self, cell_phase: f32, dim: f32) -> f32 {
+        if self.subtle {
+            // No travelling chase or size change, just a gentle 2.4s fade.
+            0.6 + 0.2 * pulse_wave(self.phase)
+        } else {
+            gspin_opacity(self.phase + cell_phase, dim)
+        }
+    }
+}
+
+pub fn activity_pulse(view: EntityId, cx: &mut App) -> ActivityPulse {
+    activity_pulse_every(view, 1, cx)
+}
+
+pub fn activity_pulse_slow(view: EntityId, cx: &mut App) -> ActivityPulse {
+    activity_pulse_every(view, 2, cx)
+}
+
+fn activity_pulse_every(view: EntityId, stride: u64, cx: &mut App) -> ActivityPulse {
+    let subtle = cx.reduce_motion();
+    let animate = !subtle
+        || cx.try_global::<MotionState>().is_some_and(|state| {
+            state.preference == ReduceMotion::System
+                && state.system
+                && !(state.pause_in_background && !state.active)
+        });
+    let phase = if animate {
+        schedule_pulse_every(view, if subtle { 2 } else { stride }, cx);
+        pulse_phase(if subtle { &ZERON_PULSE } else { &GRADIENT_SPIN }, cx)
+    } else {
+        0.0
+    };
+    ActivityPulse { phase, subtle }
+}
+
 /// Schedule cosmetic animation through the same bounded clock as loaders.
 /// Renew only while painting an active animation; the clock parks after the
 /// last lease expires, including when a view is hidden or removed.
@@ -137,6 +188,10 @@ fn pulse_lease_every(view: EntityId, stride: u64, cx: &mut App) {
     if cx.reduce_motion() {
         return;
     }
+    schedule_pulse_every(view, stride, cx);
+}
+
+fn schedule_pulse_every(view: EntityId, stride: u64, cx: &mut App) {
     let clock = cx.default_global::<PulseClock>();
     let now = Instant::now();
     clock
@@ -1074,6 +1129,171 @@ fn refresh_system(_cx: &mut App) {}
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn reduced_activity_pulse_is_slow_uniform_and_gentle() {
+        for phase in [0.0, 0.1, 0.25, 0.5, 0.75, 0.9] {
+            let pulse = ActivityPulse {
+                phase,
+                subtle: true,
+            };
+            let opacity = pulse.opacity(0.0, 0.1);
+            assert!((0.6..=0.8).contains(&opacity));
+            assert_eq!(opacity, pulse.opacity(0.5, 0.1), "no travelling wave");
+        }
+        let rest = ActivityPulse {
+            phase: 0.0,
+            subtle: true,
+        }
+        .opacity(0.0, 0.1);
+        let crest = ActivityPulse {
+            phase: 0.5,
+            subtle: true,
+        }
+        .opacity(0.0, 0.1);
+        assert!(
+            crest > rest,
+            "the activity cue must visibly change brightness"
+        );
+    }
+
+    #[gpui::test]
+    fn activity_pulse_honors_explicit_on_and_background_pause(cx: &mut gpui::TestAppContext) {
+        use gpui::AppContext as _;
+
+        cx.update(|cx| {
+            for (preference, system, pause_in_background, active, animates) in [
+                (ReduceMotion::On, false, false, true, false),
+                (ReduceMotion::On, true, false, true, false),
+                (ReduceMotion::System, true, true, false, false),
+                (ReduceMotion::Off, true, true, false, false),
+                (ReduceMotion::System, true, true, true, true),
+                (ReduceMotion::System, true, false, false, true),
+                (ReduceMotion::System, false, false, true, true),
+                (ReduceMotion::Off, true, false, true, true),
+            ] {
+                cx.set_global(MotionState {
+                    preference,
+                    pause_in_background,
+                    system,
+                    active,
+                });
+                apply(cx);
+                let view = cx.new(|_| ());
+                let pulse = activity_pulse(view.entity_id(), cx);
+                let leased = cx
+                    .try_global::<PulseClock>()
+                    .is_some_and(|clock| clock.leases.contains_key(&view.entity_id()));
+                assert_eq!(
+                    leased, animates,
+                    "{preference:?}, system={system}, pause={pause_in_background}, active={active}"
+                );
+                if reduced_motion(cx) {
+                    assert!(pulse.subtle);
+                    let decorative_view = cx.new(|_| ());
+                    assert_eq!(
+                        pulse_delta(&ZERON_PULSE, decorative_view.entity_id(), cx),
+                        0.0
+                    );
+                    assert!(!cx.try_global::<PulseClock>().is_some_and(|clock| {
+                        clock.leases.contains_key(&decorative_view.entity_id())
+                    }));
+                }
+            }
+        });
+    }
+
+    #[gpui::test]
+    fn cached_activity_loaders_keep_renewing_under_system_reduced_motion(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        use gpui::{AppContext as _, Context, ParentElement as _, Render};
+
+        struct Loaders;
+        impl Render for Loaders {
+            fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+                let theme = crate::theme::Theme::dark();
+                gpui::div()
+                    .child(crate::loaders::gradient_spinner(
+                        "working",
+                        &theme,
+                        2.5,
+                        cx.entity_id(),
+                        cx,
+                    ))
+                    .child(crate::loaders::mini_glyph_spinner(
+                        "sidebar-working",
+                        2.0,
+                        theme.glyph,
+                        cx.entity_id(),
+                        cx,
+                    ))
+            }
+        }
+
+        cx.update(|cx| {
+            cx.set_global(MotionState {
+                preference: ReduceMotion::System,
+                pause_in_background: false,
+                system: true,
+                active: true,
+            });
+            apply(cx);
+        });
+        let window = cx.add_window(|_, _| Loaders);
+        cx.update_window(window.into(), |_, window, cx| window.draw(cx).clear())
+            .unwrap();
+        cx.run_until_parked();
+        for _ in 0..20 {
+            cx.background_executor.advance_clock(PULSE_TICK);
+            cx.run_until_parked();
+            cx.update_window(window.into(), |_, window, cx| window.draw(cx).clear())
+                .unwrap();
+        }
+        cx.update(|cx| {
+            let clock = cx.global::<PulseClock>();
+            assert!(clock.tick >= 20);
+            assert_eq!(
+                clock.leases.len(),
+                2,
+                "transcript and cached sidebar loader"
+            );
+            assert!(
+                clock.leases.values().all(|lease| lease.stride == 2),
+                "both loaders renew at 15Hz"
+            );
+        });
+    }
+
+    #[gpui::test]
+    fn system_reduced_motion_keeps_activity_loaders_ticking(cx: &mut gpui::TestAppContext) {
+        use gpui::AppContext as _;
+
+        cx.update(|cx| {
+            cx.set_global(MotionState {
+                preference: ReduceMotion::System,
+                pause_in_background: false,
+                system: true,
+                active: true,
+            });
+            apply(cx);
+            assert!(reduced_motion(cx));
+
+            let view = cx.new(|_| ());
+            drop(crate::loaders::gradient_spinner(
+                "working",
+                &crate::theme::Theme::dark(),
+                2.5,
+                view.entity_id(),
+                cx,
+            ));
+            assert!(
+                cx.try_global::<PulseClock>()
+                    .is_some_and(|clock| clock.leases.contains_key(&view.entity_id())),
+                "a working indicator must keep receiving ticks with system reduced motion"
+            );
+        });
+    }
+
     #[test]
     fn pulse_stride_reestablishes_after_each_paint() {
         let now = Instant::now();
diff --git a/crates/ui/src/settings/appearance.rs b/crates/ui/src/settings/appearance.rs
index 06eea23100..1d6774a57b 100644
--- a/crates/ui/src/settings/appearance.rs
+++ b/crates/ui/src/settings/appearance.rs
@@ -1395,7 +1395,9 @@ fn surface_label(surface: SurfacePreference) -> &'static str {
 
 fn reduce_motion_helper(preference: ReduceMotion, system: bool) -> &'static str {
     match (preference, system) {
-        (ReduceMotion::System, true) => "Following the system, which currently reduces motion.",
+        (ReduceMotion::System, true) => {
+            "Following reduced system motion. Activity indicators use a gentle brightness pulse."
+        }
         (ReduceMotion::System, false) => "Following the system, which currently allows motion.",
         (ReduceMotion::On, _) => "Animations skip straight to their final state.",
         (ReduceMotion::Off, _) => "Animations play even if the system asks for less motion.",
diff --git a/docs/reference/windows-development.md b/docs/reference/windows-development.md
index 6c76cb21df..49a92bbc83 100644
--- a/docs/reference/windows-development.md
+++ b/docs/reference/windows-development.md
@@ -69,6 +69,12 @@ remain opaque because in-app backdrop blur is not supported. The pinned
 [Zui DirectX fix](https://github.com/zeronsh/zui/pull/7) supplies the renderer
 layout and edge-fade corrections.
 
+When Windows disables **Animation effects**, Zeron's **Reduce motion: System**
+setting skips transitions and gives activity grids a gentle 2.4-second brightness
+pulse. **Reduce motion: On** keeps those indicators still; **Off** restores the
+usual travelling wave. **Pause animations in background** also pauses activity
+grids when the main window loses focus.
+
 ## Verification
 
 [Windows CI](../../.github/workflows/windows.yml) builds the release application

From edac0d7d9d58c294ab81e8ff088a7ef0a43d4bba Mon Sep 17 00:00:00 2001
From: notsapinho <52896767+notsapinho@users.noreply.github.com>
Date: Sat, 3 Oct 2026 02:46:29 -0300
Subject: [PATCH 42/74] Fix Windows drive paths in the project folder picker
 (#727)

* Fix Windows drive paths in the project folder picker

The folder-browser helpers (breadcrumbs, parent_path, child_path,
path_under) only understood "/" separators. For a drive path like D:\ they
produced a bogus "/D:\" crumb; clicking it (or any deeper crumb) sent that
path to the engine, which failed with "os error 123". Going up from D:\Foo
also fell back to the drive list instead of reaching D:\.

Detect drive-rooted paths by shape (not cfg, since a non-Windows client can
browse a remote Windows device) and use "\" there. Drive roots no longer get
a duplicate crumb.

* Accept typed Windows drive paths in the folder picker search

Typing an absolute (/x) or home-relative (~/x) path in the folder search jumps
straight to it, but a drive path like D:\projects\ was treated as a folder-name
filter. Recognise drive-rooted queries (D:, D:\, D:/x) as path jumps, normalise
them to backslashes so the breadcrumb trail matches, and commit on a trailing
\ or /.
---
 crates/ui/src/pickers.rs      | 107 ++++++++++++++++++++++++++++++----
 crates/ui/src/shell/spaces.rs |  40 ++++++++-----
 2 files changed, 124 insertions(+), 23 deletions(-)

diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 259ef8af59..4f8826da06 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -243,8 +243,28 @@ pub fn offered_options(
 // Pure: folder-browser navigation (used by the shell's add-space flow)
 // ---------------------------------------------------------------------------
 
+/// Whether `path` is drive-rooted (`C:`, `C:\…`, `C:/…`). Judged by shape,
+/// not `cfg`: the device being browsed may be a Windows machine reached from
+/// any platform.
+fn is_windows_path(path: &str) -> bool {
+    let bytes = path.as_bytes();
+    bytes.len() >= 2
+        && bytes[0].is_ascii_alphabetic()
+        && bytes[1] == b':'
+        && bytes.get(2).is_none_or(|b| matches!(b, b'/' | b'\\'))
+}
+
 /// Parent of an absolute path; `None` at the filesystem root.
 pub fn parent_path(path: &str) -> Option<String> {
+    if is_windows_path(path) {
+        let (drive, rest) = path.split_at(2);
+        let rest = rest.trim_matches(['/', '\\']);
+        if rest.is_empty() {
+            return None; // drive root
+        }
+        let parent = rest.rfind(['/', '\\']).map_or("", |at| &rest[..at]);
+        return Some(format!("{drive}\\{parent}"));
+    }
     let trimmed = path.trim_end_matches('/');
     if trimmed.is_empty() {
         return None; // was "/" (or empty)
@@ -258,8 +278,10 @@ pub fn parent_path(path: &str) -> Option<String> {
 
 /// Join a listing path and an entry name.
 pub fn child_path(base: &str, name: &str) -> String {
-    if base.ends_with('/') {
+    if base.ends_with(['/', '\\']) {
         format!("{base}{name}")
+    } else if is_windows_path(base) {
+        format!("{base}\\{name}")
     } else {
         format!("{base}/{name}")
     }
@@ -304,13 +326,29 @@ pub fn segment_target(names: &[&str], query: &str) -> Option<usize> {
     hits.next().is_none().then_some(ix)
 }
 
-/// Interpret a palette query as a typed path jump: absolute (`/disk2/projects`)
-/// or home-relative (`~`, `~/github`). Returns the absolute path to browse,
-/// trailing slash trimmed. `home` is the device's resolved home — `None`
-/// until the first listing lands, when `~` can't expand yet. A query like
-/// `~foo` is a folder name, not a path.
+/// Whether a palette query is path-shaped (absolute, home-relative or
+/// drive-rooted) rather than a folder name to filter by.
+pub fn is_typed_path(query: &str) -> bool {
+    query.starts_with(['/', '~']) || is_windows_path(query)
+}
+
+/// Interpret a palette query as a typed path jump: absolute (`/disk2/projects`),
+/// drive-rooted (`D:\projects`) or home-relative (`~`, `~/github`). Returns the
+/// absolute path to browse, trailing separator trimmed. `home` is the device's
+/// resolved home — `None` until the first listing lands, when `~` can't expand
+/// yet. A query like `~foo` is a folder name, not a path.
 pub fn typed_path_target(query: &str, home: Option<&str>) -> Option<String> {
     let query = query.trim();
+    if is_windows_path(query) {
+        let path = query.replace('/', "\\");
+        let trimmed = path.trim_end_matches('\\');
+        // `D:` and `D:\` both mean the drive root.
+        return Some(if trimmed.len() == 2 {
+            format!("{trimmed}\\")
+        } else {
+            trimmed.to_string()
+        });
+    }
     if let Some(rest) = query.strip_prefix('~') {
         let home = home?.trim_end_matches('/');
         if rest.is_empty() {
@@ -336,10 +374,17 @@ pub fn typed_path_target(query: &str, home: Option<&str>) -> Option<String> {
 
 /// Breadcrumb segments for a path: `(label, full path)`, root first.
 pub fn breadcrumbs(path: &str) -> Vec<(String, String)> {
-    let mut out: Vec<(String, String)> = vec![("/".to_string(), "/".to_string())];
-    let mut acc = String::new();
-    for segment in path.split('/').filter(|s| !s.is_empty()) {
-        acc.push('/');
+    let (drive, sep, rest) = if is_windows_path(path) {
+        let (drive, rest) = path.split_at(2);
+        (drive, '\\', rest)
+    } else {
+        ("", '/', path)
+    };
+    let root = format!("{drive}{sep}");
+    let mut out = vec![(root.clone(), root)];
+    let mut acc = drive.to_string();
+    for segment in rest.split(['/', sep]).filter(|s| !s.is_empty()) {
+        acc.push(sep);
         acc.push_str(segment);
         out.push((segment.to_string(), acc.clone()));
     }
@@ -8698,6 +8743,28 @@ mod tests {
         assert_eq!(breadcrumbs("/").len(), 1);
     }
 
+    #[test]
+    fn windows_folder_paths_and_breadcrumbs() {
+        assert_eq!(
+            parent_path(r"D:\Random\zeron"),
+            Some(r"D:\Random".to_string())
+        );
+        assert_eq!(parent_path(r"D:\Random"), Some(r"D:\".to_string()));
+        assert_eq!(parent_path(r"D:\Random\"), Some(r"D:\".to_string()));
+        assert_eq!(parent_path(r"D:\"), None);
+        assert_eq!(parent_path("D:"), None);
+        assert_eq!(child_path(r"D:\", "Random"), r"D:\Random");
+        assert_eq!(child_path(r"D:\Random", "zeron"), r"D:\Random\zeron");
+        let crumbs = breadcrumbs(r"D:\Random\zeron");
+        let labels: Vec<&str> = crumbs.iter().map(|(l, _)| l.as_str()).collect();
+        assert_eq!(labels, [r"D:\", "Random", "zeron"]);
+        assert_eq!(crumbs[0].1, r"D:\");
+        assert_eq!(crumbs[1].1, r"D:\Random");
+        assert_eq!(breadcrumbs(r"D:\").len(), 1);
+        assert!(!is_windows_path("/D:/x"));
+        assert!(!is_windows_path("ab:/x"));
+    }
+
     #[test]
     fn completion_prefix_lengths() {
         // Case-insensitive; the length indexes into the NAME's bytes.
@@ -8750,6 +8817,26 @@ mod tests {
         assert_eq!(typed_path_target("/disk2", None), Some("/disk2".into()));
     }
 
+    #[test]
+    fn typed_path_target_accepts_windows_drive_paths() {
+        let home = Some(r"C:\Users\wing");
+        assert_eq!(typed_path_target(r"D:\", home), Some(r"D:\".into()));
+        assert_eq!(typed_path_target("D:", home), Some(r"D:\".into()));
+        assert_eq!(typed_path_target("D:/", home), Some(r"D:\".into()));
+        assert_eq!(
+            typed_path_target(r"D:\Random\zeron\", home),
+            Some(r"D:\Random\zeron".into())
+        );
+        // Forward slashes normalise so the crumb trail can match the path.
+        assert_eq!(
+            typed_path_target("D:/Random/zeron", None),
+            Some(r"D:\Random\zeron".into())
+        );
+        assert!(is_typed_path(r"D:\x"));
+        assert!(is_typed_path("/x") && is_typed_path("~"));
+        assert!(!is_typed_path("src") && !is_typed_path("ab:/x"));
+    }
+
     #[test]
     fn browser_navigation_reducer() {
         let listing = FolderListing {
diff --git a/crates/ui/src/shell/spaces.rs b/crates/ui/src/shell/spaces.rs
index f8b96628d1..5796e7922a 100644
--- a/crates/ui/src/shell/spaces.rs
+++ b/crates/ui/src/shell/spaces.rs
@@ -2231,10 +2231,14 @@ fn device_glyph(platform: &str) -> &'static str {
 }
 
 /// Segment-aware "is `path` at or under `base`" (`/media/a` is not under
-/// `/media/ab`); a root base covers everything.
+/// `/media/ab`); a root base covers everything. Either separator counts, so
+/// Windows drive paths (`D:\` under `D:\`) work too.
 fn path_under(path: &str, base: &str) -> bool {
-    let base = base.trim_end_matches('/');
-    base.is_empty() || path == base || path.starts_with(&format!("{base}/"))
+    let base = base.trim_end_matches(['/', '\\']);
+    base.is_empty()
+        || path
+            .strip_prefix(base)
+            .is_some_and(|rest| rest.is_empty() || rest.starts_with(['/', '\\']))
 }
 
 /// The space-row Rename dialog (same shape as [`RenameChatDialog`]).
@@ -5565,11 +5569,8 @@ impl Shell {
         };
         if rows.is_empty() {
             let text = flow.search.read(cx).text().to_string();
-            if text.starts_with('/') || text.starts_with('~') {
-                if let Some(target) = crate::pickers::typed_path_target(&text, flow.home.as_deref())
-                {
-                    self.add_space_descend(target, false, cx);
-                }
+            if let Some(target) = crate::pickers::typed_path_target(&text, flow.home.as_deref()) {
+                self.add_space_descend(target, false, cx);
             }
             return;
         }
@@ -5603,16 +5604,17 @@ impl Shell {
         {
             return false;
         }
-        // A typed PATH jump: an absolute (`/disk2/`) or home-relative (`~/x/`)
-        // query browses that path directly — mounts at unconventional roots
-        // (and anywhere else) are reachable without a Locations row. Same
-        // trailing-`/` trigger as the folder-name descend below.
+        // A typed PATH jump: an absolute (`/disk2/`), drive-rooted (`D:\x\`)
+        // or home-relative (`~/x/`) query browses that path directly — mounts
+        // at unconventional roots (and anywhere else) are reachable without a
+        // Locations row. Same trailing-separator trigger as the folder-name
+        // descend below.
         {
             let Some(flow) = self.add_space.as_ref() else {
                 return false;
             };
             let text = flow.search.read(cx).text().to_string();
-            if text.ends_with('/') && (text.starts_with('/') || text.starts_with('~')) {
+            if crate::pickers::is_typed_path(&text) && text.ends_with(['/', '\\']) {
                 let target = crate::pickers::typed_path_target(&text, flow.home.as_deref());
                 let Some(target) = target else {
                     // Path-shaped but unresolvable (`~/…` before home is
@@ -6926,6 +6928,18 @@ mod project_flow_tests {
         assert_eq!(deep, ["d", "e"]);
     }
 
+    #[test]
+    fn path_under_handles_posix_and_windows_drive_paths() {
+        assert!(path_under("/media/a", "/"));
+        assert!(path_under("/media/a", "/media"));
+        assert!(!path_under("/media/ab", "/media/a"));
+        // A drive-root crumb hides itself, not a sibling drive.
+        assert!(path_under(r"D:\", r"D:\"));
+        assert!(path_under(r"D:\Random", r"D:\"));
+        assert!(!path_under(r"D:\Random2", r"D:\Random"));
+        assert!(!path_under(r"C:\Random", r"D:\"));
+    }
+
     #[gpui::test]
     fn devices_locations_folders_and_back_clear_stale_state(cx: &mut gpui::TestAppContext) {
         let data = tempfile::tempdir().unwrap();

From f9a4a18bedf71513a2abc0dbdf608b4bea5499e1 Mon Sep 17 00:00:00 2001
From: notsapinho <52896767+notsapinho@users.noreply.github.com>
Date: Sat, 3 Oct 2026 02:46:34 -0300
Subject: [PATCH 43/74] Convert BMP attachments to PNG so agents can read them
 (#739)

Windows puts screenshots on the clipboard as BMP (gpui turns CF_DIB into
ImageFormat::Bmp). No harness inlines BMP, so the agent fell back to its
Read tool, which cannot decode one.

stage_file and stage_clipboard_image now re-encode BMP as PNG and rename
.bmp to .png at staging, so the queued pending:// refs, the upload and
the transcript all see the PNG. A file that won't decode is refused; a
pasted image that won't decode stays as pasted. Wallpapers keep their
original bytes and name through the new stage_file_verbatim.

Staging (file read + BMP decode) now runs on the background executor via
Composer::stage_in_background instead of the UI thread. The result lands
in the draft that was current when the image arrived, even if the user
navigates to another chat while it converts.

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/ui/src/attachments.rs        | 113 +++++++++++++++++++++++++--
 crates/ui/src/composer.rs           | 115 ++++++++++++++++++++--------
 crates/ui/src/settings.rs           |   2 +-
 crates/ui/src/settings/wallpaper.rs |   2 +-
 4 files changed, 192 insertions(+), 40 deletions(-)

diff --git a/crates/ui/src/attachments.rs b/crates/ui/src/attachments.rs
index 6692feb720..c5483bf1f3 100644
--- a/crates/ui/src/attachments.rs
+++ b/crates/ui/src/attachments.rs
@@ -231,9 +231,26 @@ pub fn ensure_extension(name: &str, format: ImageFormat) -> String {
     }
 }
 
-/// Stage a file from disk (picker / drop / pasted path). `Err` carries the
-/// user-facing message (mirrors the old `onError` copy).
+/// Stage a file from disk (picker / drop / pasted path); a BMP is converted to
+/// PNG, which agents can read. `Err` carries the user-facing message (mirrors
+/// the old `onError` copy).
 pub fn stage_file(path: &Path) -> Result<StagedAttachment, String> {
+    let mut staged = stage_file_verbatim(path)?;
+    if staged.image.format == ImageFormat::Bmp {
+        let png = bmp_to_png(&staged.image)
+            .map_err(|_| format!("{} is not a valid image.", staged.name))?;
+        staged.image = Arc::new(png);
+        staged.name = Path::new(&staged.name)
+            .with_extension("png")
+            .to_string_lossy()
+            .into_owned();
+    }
+    Ok(staged)
+}
+
+/// Stage a file's bytes exactly as stored, for callers that decode the image
+/// themselves (wallpapers) rather than hand it to an agent.
+pub fn stage_file_verbatim(path: &Path) -> Result<StagedAttachment, String> {
     let display_name = path
         .file_name()
         .map(|n| n.to_string_lossy().to_string())
@@ -253,16 +270,36 @@ pub fn stage_file(path: &Path) -> Result<StagedAttachment, String> {
     })
 }
 
-/// Stage an image pasted from the clipboard.
+/// Stage an image pasted from the clipboard. A BMP (what Windows puts there for
+/// a screenshot) is converted to PNG like [`stage_file`] does; one that won't
+/// decode stays as pasted.
 pub fn stage_clipboard_image(image: Image) -> StagedAttachment {
-    let format = image.format;
+    let image = if image.format == ImageFormat::Bmp
+        && let Ok(png) = bmp_to_png(&image)
+    {
+        png
+    } else {
+        image
+    };
     StagedAttachment {
         id: uuid::Uuid::new_v4().to_string(),
-        name: ensure_extension("image", format),
+        name: ensure_extension("image", image.format),
         image: Arc::new(image),
     }
 }
 
+/// Windows screenshots are BMP, but no agent harness inlines BMP and the
+/// agent's `Read` tool can't decode one — so they go out as PNG.
+fn bmp_to_png(bmp: &Image) -> Result<Image, String> {
+    let decoded = image::load_from_memory_with_format(&bmp.bytes, image::ImageFormat::Bmp)
+        .map_err(|e| e.to_string())?;
+    let mut png = std::io::Cursor::new(Vec::new());
+    decoded
+        .write_to(&mut png, image::ImageFormat::Png)
+        .map_err(|e| e.to_string())?;
+    Ok(Image::from_bytes(ImageFormat::Png, png.into_inner()))
+}
+
 /// Stage native macOS capture bytes without a temporary file. The capture
 /// service already encoded PNG and enforces the shared size limit.
 pub fn stage_png_bytes(name: String, bytes: Vec<u8>) -> StagedAttachment {
@@ -1176,6 +1213,72 @@ mod tests {
         }
     }
 
+    /// A 1x1 32-bit BI_RGB bitmap as the Windows clipboard produces it: one
+    /// BGRX pixel, the fourth byte unused (zero).
+    fn clipboard_bmp() -> Vec<u8> {
+        let mut bmp = b"BM".to_vec();
+        // File size, reserved, pixel offset, header size, width, height.
+        for field in [58u32, 0, 54, 40, 1, 1] {
+            bmp.extend(field.to_le_bytes());
+        }
+        bmp.extend([1, 0, 32, 0]); // planes, bits per pixel
+        bmp.extend([0; 24]); // BI_RGB, image size, resolution, palette
+        bmp.extend([30, 20, 10, 0]);
+        bmp
+    }
+
+    #[test]
+    fn pasted_bmp_screenshot_is_staged_as_an_opaque_png() {
+        let staged = stage_clipboard_image(Image::from_bytes(ImageFormat::Bmp, clipboard_bmp()));
+        assert_eq!(staged.image.format, ImageFormat::Png);
+        assert_eq!(staged.name, "image.png");
+        let png = image::load_from_memory(staged.bytes()).unwrap();
+        assert_eq!(png.into_rgba8().get_pixel(0, 0).0, [10, 20, 30, 255]);
+    }
+
+    #[test]
+    fn bmp_file_is_staged_as_png_but_wallpapers_keep_the_original() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("Screenshot 1.BMP");
+        std::fs::write(&path, clipboard_bmp()).unwrap();
+
+        let staged = stage_file(&path).unwrap();
+        assert_eq!(staged.image.format, ImageFormat::Png);
+        assert_eq!(staged.name, "Screenshot 1.png");
+        assert!(image::load_from_memory(staged.bytes()).is_ok());
+
+        let verbatim = stage_file_verbatim(&path).unwrap();
+        assert_eq!(verbatim.image.format, ImageFormat::Bmp);
+        assert_eq!(verbatim.name, "Screenshot 1.BMP");
+        assert_eq!(verbatim.bytes(), clipboard_bmp());
+    }
+
+    #[test]
+    fn non_bmp_files_are_staged_untouched() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("shot.png");
+        image::RgbImage::new(1, 1).save(&path).unwrap();
+        let staged = stage_file(&path).unwrap();
+        assert_eq!(staged.name, "shot.png");
+        assert_eq!(staged.bytes(), std::fs::read(&path).unwrap());
+    }
+
+    #[test]
+    fn undecodable_bmp_is_refused_for_files_and_kept_for_pastes() {
+        let broken = b"BM not really a bitmap".to_vec();
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("broken.bmp");
+        std::fs::write(&path, &broken).unwrap();
+        assert_eq!(
+            stage_file(&path).err().unwrap(),
+            "broken.bmp is not a valid image."
+        );
+
+        let pasted = stage_clipboard_image(Image::from_bytes(ImageFormat::Bmp, broken));
+        assert_eq!(pasted.image.format, ImageFormat::Bmp);
+        assert_eq!(pasted.name, "image.bmp");
+    }
+
     #[test]
     fn retry_ladder_is_2s_doubling_capped_at_15s() {
         assert_eq!(retry_delay(0), Duration::from_millis(2_000));
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index da9b121fda..2230935e32 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -5905,11 +5905,17 @@ impl Composer {
                 }
             }
             ComposerInputEvent::PastedImages(images) => {
-                let staged = images
-                    .iter()
-                    .map(|image| attachments::stage_clipboard_image(image.clone()))
-                    .collect();
-                this.add_staged(staged, cx);
+                let images = images.clone();
+                this.stage_in_background(
+                    move || {
+                        images
+                            .into_iter()
+                            .map(attachments::stage_clipboard_image)
+                            .map(Ok)
+                            .collect()
+                    },
+                    cx,
+                );
             }
             ComposerInputEvent::PastedPaths(paths) => this.add_paths(paths.clone(), cx),
             ComposerInputEvent::PastedText { range, revision } => {
@@ -6212,40 +6218,54 @@ impl Composer {
         cx.notify();
     }
 
-    fn add_staged(&mut self, staged: Vec<StagedAttachment>, cx: &mut Context<Self>) {
-        if self.queue_edit_finishing {
-            return;
-        }
-        if staged.is_empty() {
-            return;
-        }
-        self.attachments
-            .entry(self.current_key.clone())
-            .or_default()
-            .extend(staged);
-        self.focus_pending = true;
-        cx.notify();
+    /// Run `stage` on the background executor — reading a file and converting
+    /// a BMP are too slow for the UI thread — and add what it staged to the
+    /// draft that is current now, even if the user has navigated away by the
+    /// time it finishes. Failures surface in that draft's failure notice.
+    fn stage_in_background(
+        &mut self,
+        stage: impl FnOnce() -> Vec<Result<StagedAttachment, String>> + Send + 'static,
+        cx: &mut Context<Self>,
+    ) {
+        let key = self.current_key.clone();
+        cx.spawn(async move |this, cx| {
+            let results = cx.background_executor().spawn(async move { stage() }).await;
+            this.update(cx, |this, cx| {
+                let mut staged = Vec::new();
+                for result in results {
+                    match result {
+                        Ok(att) => staged.push(att),
+                        Err(message) => {
+                            this.failure = Some(message.into());
+                            this.failure_key = Some(key.clone());
+                        }
+                    }
+                }
+                if !staged.is_empty() && !this.queue_edit_finishing {
+                    this.attachments.entry(key).or_default().extend(staged);
+                    this.focus_pending = true;
+                }
+                cx.notify();
+            })
+            .ok();
+        })
+        .detach();
     }
 
     /// Stage image files (picker / drop / pasted paths). Non-images are
     /// skipped silently (matching the original's `image/*` filter); read
     /// failures and oversize files surface in the failure notice.
     pub(crate) fn add_paths(&mut self, paths: Vec<PathBuf>, cx: &mut Context<Self>) {
-        let mut staged = Vec::new();
-        for path in &paths {
-            if attachments::format_by_extension(path).is_none() {
-                continue;
-            }
-            match attachments::stage_file(path) {
-                Ok(att) => staged.push(att),
-                Err(message) => {
-                    self.failure = Some(message.into());
-                    self.failure_key = Some(self.current_key.clone());
-                    cx.notify();
-                }
-            }
-        }
-        self.add_staged(staged, cx);
+        self.stage_in_background(
+            move || {
+                paths
+                    .iter()
+                    .filter(|path| attachments::format_by_extension(path).is_some())
+                    .map(|path| attachments::stage_file(path))
+                    .collect()
+            },
+            cx,
+        );
     }
 
     /// Add a file-tree or file-tab drop through the existing file-mention
@@ -11384,6 +11404,7 @@ mod tests {
                 composer.add_paths(vec![image_path], cx);
             })
             .unwrap();
+        cx.run_until_parked();
         cx.update_window(handle.into(), |_, window, cx| {
             window.draw(cx).clear();
             assert!(input.read(cx).focus_handle.is_focused(window));
@@ -11391,6 +11412,34 @@ mod tests {
         .unwrap();
     }
 
+    #[gpui::test]
+    fn staged_files_land_in_the_draft_they_were_added_to(cx: &mut gpui::TestAppContext) {
+        let (dir, handle) = composer_focus_window(cx);
+        let bmp = dir.path().join("shot.bmp");
+        image::RgbImage::new(1, 1).save(&bmp).unwrap();
+        handle
+            .update(cx, |composer, _, cx| {
+                composer.current_key = "chat-a".into();
+                composer.add_paths(vec![bmp, dir.path().join("notes.txt")], cx);
+                // Staging runs in the background; navigating meanwhile must
+                // not move the attachment into the other chat's draft.
+                composer.current_key = "chat-b".into();
+                assert!(composer.attachments.is_empty());
+            })
+            .unwrap();
+        cx.run_until_parked();
+        handle
+            .read_with(cx, |composer, _| {
+                let names: Vec<_> = composer.attachments["chat-a"]
+                    .iter()
+                    .map(|att| att.name.as_str())
+                    .collect();
+                assert_eq!(names, ["shot.png"]);
+                assert!(!composer.attachments.contains_key("chat-b"));
+            })
+            .unwrap();
+    }
+
     #[gpui::test]
     fn composer_picker_escape_restores_focus_but_click_away_does_not(
         cx: &mut gpui::TestAppContext,
diff --git a/crates/ui/src/settings.rs b/crates/ui/src/settings.rs
index c578b1f3e8..51f27089e6 100644
--- a/crates/ui/src/settings.rs
+++ b/crates/ui/src/settings.rs
@@ -360,7 +360,7 @@ pub fn compact_model_picker(cx: &App) -> bool {
 /// the new-thread canvas background. A unique file name avoids stale image
 /// caches when the background is replaced.
 pub fn install_new_thread_composer_background(source: &Path, cx: &mut App) -> Result<(), String> {
-    let staged = crate::attachments::stage_file(source)?;
+    let staged = crate::attachments::stage_file_verbatim(source)?;
     // Do not persist the candidate or retire the old managed file until the
     // renderer's decoder has accepted the exact bytes we are about to save.
     let image = crate::new_thread_background_image::decode(staged.bytes()).map_err(|_| {
diff --git a/crates/ui/src/settings/wallpaper.rs b/crates/ui/src/settings/wallpaper.rs
index 1fa61fdc93..e413aec32f 100644
--- a/crates/ui/src/settings/wallpaper.rs
+++ b/crates/ui/src/settings/wallpaper.rs
@@ -57,7 +57,7 @@ fn choose(
         (recency, *rank)
     });
     for (_, path) in candidates {
-        if let Ok(staged) = crate::attachments::stage_file(&path)
+        if let Ok(staged) = crate::attachments::stage_file_verbatim(&path)
             && let Ok(image) = crate::new_thread_background_image::decode(staged.bytes())
         {
             return Ok((path, staged, image));

From e2a7706fac45ff2cc2a742b841036e2d93dcad5d Mon Sep 17 00:00:00 2001
From: notsapinho <52896767+notsapinho@users.noreply.github.com>
Date: Sat, 3 Oct 2026 02:46:39 -0300
Subject: [PATCH 44/74] Add per-project new chat button and archive tooltip to
 the sidebar (#737)

* Add a per-project "new chat" button to sidebar group headers

Hovering a project group in the thread list now reveals a `+` before the
collapse chevron that opens the new-chat canvas already homed on that
project, instead of using the titlebar `+` and then picking the project.

`open_new_session` takes an optional project that wins over the sidebar
filter; existing callers pass `None`. The button only appears for real
projects when grouping by project.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Add a tooltip above the sidebar archive pill

The Archive/Unarchive pill that replaces a thread row's time on hover had
no tooltip, unlike the other icon controls. It now shows "Archive session"
(or "Unarchive session"), above the pill rather than below, where gpui's
default placement would cover the next row.

`text_tooltip_above` is `text_tooltip` anchored above the pointer.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Show the project "new chat" tooltip above its button

Matches the archive pill: below the pointer the chip would cover the
group's first row.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/ui/src/settings/widgets.rs      | 48 +++++++++++++--
 crates/ui/src/shell.rs                 | 83 +++++++++++++++++++++++---
 crates/ui/src/shell/command_palette.rs |  2 +-
 crates/ui/src/shell/spaces.rs          | 55 +++++++++++++++--
 crates/ui/src/shell/tabs.rs            | 10 ++--
 5 files changed, 176 insertions(+), 22 deletions(-)

diff --git a/crates/ui/src/settings/widgets.rs b/crates/ui/src/settings/widgets.rs
index e649bf555a..d31b17775a 100644
--- a/crates/ui/src/settings/widgets.rs
+++ b/crates/ui/src/settings/widgets.rs
@@ -1649,7 +1649,14 @@ impl RenderOnce for SettingsScroll {
 
 /// A one-line hover note for settings controls (reset times, icon-only
 /// actions), in the same frosted chip as the rest of the app's tooltips.
-pub struct TextTooltip(pub SharedString);
+pub struct TextTooltip {
+    text: SharedString,
+    above: bool,
+}
+
+/// How far a [`text_tooltip_above`] chip sits over the pointer; clears a
+/// small control the pointer is anywhere inside.
+const TOOLTIP_ABOVE_GAP: f32 = 20.0;
 
 impl Render for TextTooltip {
     fn render(
@@ -1668,8 +1675,20 @@ impl Render for TextTooltip {
             .bg(crate::popover::surface_bg(theme))
             .text_size(px(11.0))
             .text_color(theme.text_muted)
-            .child(self.0.clone());
-        crate::frost::frosted(6.0, crate::frost::MENU_BLUR, card)
+            .child(self.text.clone());
+        let card = crate::frost::frosted(6.0, crate::frost::MENU_BLUR, card);
+        if !self.above {
+            return card.into_any_element();
+        }
+        // gpui hangs a tooltip below-right of the pointer. A zero-height box
+        // with end-aligned content makes the chip overflow upward instead.
+        div()
+            .h(px(0.0))
+            .flex()
+            .flex_col()
+            .justify_end()
+            .child(div().relative().bottom(px(TOOLTIP_ABOVE_GAP)).child(card))
+            .into_any_element()
     }
 }
 
@@ -1678,5 +1697,26 @@ pub fn text_tooltip(
     text: impl Into<SharedString>,
 ) -> impl Fn(&mut gpui::Window, &mut gpui::App) -> gpui::AnyView + 'static {
     let text: SharedString = text.into();
-    move |_, cx| cx.new(|_| TextTooltip(text.clone())).into()
+    move |_, cx| {
+        cx.new(|_| TextTooltip {
+            text: text.clone(),
+            above: false,
+        })
+        .into()
+    }
+}
+
+/// Like [`text_tooltip`], shown above the pointer instead of below it, for
+/// controls with content underneath that the chip would otherwise cover.
+pub fn text_tooltip_above(
+    text: impl Into<SharedString>,
+) -> impl Fn(&mut gpui::Window, &mut gpui::App) -> gpui::AnyView + 'static {
+    let text: SharedString = text.into();
+    move |_, cx| {
+        cx.new(|_| TextTooltip {
+            text: text.clone(),
+            above: true,
+        })
+        .into()
+    }
 }
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index ba2b69d131..e990e96c92 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -2520,7 +2520,7 @@ impl Shell {
         {
             // Reuse upstream's project-filter and device defaults for a new
             // canvas. Automatic capture on an existing canvas keeps its pick.
-            self.open_new_session(cx);
+            self.open_new_session(None, cx);
         } else {
             self.route = Route::Chat;
         }
@@ -6516,7 +6516,7 @@ impl Shell {
                         icons::PLUS,
                         ShortcutId::NewSession.label(),
                         &theme,
-                        cx.listener(|this, _, _, cx| this.open_new_session(cx)),
+                        cx.listener(|this, _, _, cx| this.open_new_session(None, cx)),
                     ))
             }))
             .into_any_element()
@@ -7464,6 +7464,12 @@ impl Shell {
                             this.chat_hover_resync = true;
                             this.set_chat_archived(archive_id.clone(), !archived, cx);
                         }))
+                        // Above the pill: below it the chip would cover the next row.
+                        .tooltip(crate::settings::widgets::text_tooltip_above(if archived {
+                            "Unarchive session"
+                        } else {
+                            ShortcutId::ArchiveSession.label()
+                        }))
                 })
                 .child(corner_body)
                 .into_any_element()
@@ -12376,7 +12382,7 @@ impl Render for Shell {
                 WorkspaceCommand::Model => self
                     .composer
                     .update(cx, |c, cx| c.open_model_menu(window, cx)),
-                WorkspaceCommand::New => self.open_new_session(cx),
+                WorkspaceCommand::New => self.open_new_session(None, cx),
                 WorkspaceCommand::Resume => self.toggle_command_palette(window, cx),
                 WorkspaceCommand::Settings => self.open_last_settings(cx),
                 WorkspaceCommand::Diff if !self.active_chat.is_empty() => {
@@ -12675,7 +12681,7 @@ impl Render for Shell {
             }))
             // New session works from anywhere — `open_new_session` routes back
             // to chat itself, so Settings is not a dead spot.
-            .on_action(cx.listener(|this, _: &NewSession, _, cx| this.open_new_session(cx)))
+            .on_action(cx.listener(|this, _: &NewSession, _, cx| this.open_new_session(None, cx)))
             // Native Settings menu item and the platform convention (Cmd+, on
             // macOS, Ctrl+, elsewhere) toggle the modal from any section.
             .on_action(cx.listener(|this, _: &OpenSettings, _, cx| this.toggle_settings(cx)))
@@ -14524,7 +14530,7 @@ mod exit_regressions {
                 });
                 shell.on_state_changed(&shell.state.clone(), cx);
                 shell.settings.space_filter = Some("b".into());
-                shell.open_new_session(cx);
+                shell.open_new_session(None, cx);
                 shell.on_state_changed(&shell.state.clone(), cx);
                 assert!(shell.active_chat.is_empty());
                 shell.settings.appshot_destination =
@@ -15236,7 +15242,7 @@ mod exit_regressions {
             window
                 .update(cx, |shell, _, cx| match destination {
                     "chat" => shell.open_chat("existing-session".into(), cx),
-                    "new" => shell.open_new_session(cx),
+                    "new" => shell.open_new_session(None, cx),
                     "back" => shell.apply_nav(NavEntry::Chat("existing-session".into()), cx),
                     "settings" => {
                         shell.open_settings(SettingsSection::Devices, cx);
@@ -15324,7 +15330,7 @@ mod exit_regressions {
                     state.no_project = false;
                 });
                 shell.settings.space_filter = None;
-                shell.open_new_session(cx);
+                shell.open_new_session(None, cx);
                 assert!(shell.state.read(cx).no_project);
                 assert!(shell.state.read(cx).selected_space.is_none());
                 assert_eq!(
@@ -15416,7 +15422,7 @@ mod exit_regressions {
                 shell.settings.space_filter = None;
                 shell.open_chat("elsewhere".into(), cx);
                 assert_eq!(shell.state.read(cx).selected_space.as_deref(), Some("other"));
-                shell.open_new_session(cx);
+                shell.open_new_session(None, cx);
                 let state = shell.state.read(cx);
                 assert!(state.selected_chat.is_none());
                 assert_eq!(state.selected_space.as_deref(), Some("mine"));
@@ -15425,6 +15431,67 @@ mod exit_regressions {
             .unwrap();
     }
 
+    #[gpui::test]
+    fn new_session_in_project_homes_the_canvas_on_that_project(cx: &mut TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            crate::history::init(
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                cx,
+            );
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let window = cx.add_window(|_, cx| {
+            let state = cx.new(|_| AppState::new());
+            Shell::new(
+                state,
+                EngineBootConfig {
+                    data_dir: dir.path().into(),
+                    ipc_port: 0,
+                    edge_url: "http://127.0.0.1:1".into(),
+                    edge_token: None,
+                    org_id: None,
+                    workos_client_id: None,
+                    default_harness: zeron_proto::HarnessId::Mock,
+                },
+                cx,
+            )
+        });
+        let space = |id: &str| zeron_proto::Space {
+            id: id.into(),
+            device_id: "local".into(),
+            path: format!("/{id}"),
+            name: None,
+            git_detected: false,
+            git_checked_at: None,
+            checkout_id: None,
+            created_at: Utc::now(),
+        };
+        window
+            .update(cx, |shell, _, cx| {
+                shell.state.update(cx, |state, _| {
+                    state.apply_spaces(vec![space("one"), space("two")]);
+                });
+                shell.settings.space_filter = None;
+                shell.open_new_session(Some("two".into()), cx);
+                let state = shell.state.read(cx);
+                assert!(state.selected_chat.is_none());
+                assert_eq!(state.selected_space.as_deref(), Some("two"));
+
+                // The explicit project wins over a standing filter.
+                shell.settings.space_filter = Some("one".into());
+                shell.open_new_session(Some("two".into()), cx);
+                assert_eq!(shell.state.read(cx).selected_space.as_deref(), Some("two"));
+            })
+            .unwrap();
+    }
+
     #[cfg(any(target_os = "macos", target_os = "linux"))]
     #[gpui::test]
     fn transcript_links_open_new_tabs_and_reject_stale_sessions(cx: &mut TestAppContext) {
diff --git a/crates/ui/src/shell/command_palette.rs b/crates/ui/src/shell/command_palette.rs
index 11141efc0e..d59d702240 100644
--- a/crates/ui/src/shell/command_palette.rs
+++ b/crates/ui/src/shell/command_palette.rs
@@ -205,7 +205,7 @@ impl Shell {
         }
         self.close_command_palette(window, cx);
         match entry {
-            Entry::NewChat => self.open_new_session(cx),
+            Entry::NewChat => self.open_new_session(None, cx),
             Entry::NewProject => self.open_add_space(cx),
             Entry::Settings => self.open_last_settings(cx),
             Entry::Theme(_) => unreachable!(),
diff --git a/crates/ui/src/shell/spaces.rs b/crates/ui/src/shell/spaces.rs
index 5796e7922a..710b3815ea 100644
--- a/crates/ui/src/shell/spaces.rs
+++ b/crates/ui/src/shell/spaces.rs
@@ -2106,7 +2106,12 @@ pub(super) fn sidebar_separator(theme: &Theme) -> gpui::Div {
     div().h(px(1.0)).bg(theme.border.opacity(0.6))
 }
 
-fn sidebar_disclosure_header(theme: &Theme, label: SharedString, chevron: AnyElement) -> gpui::Div {
+fn sidebar_disclosure_header(
+    theme: &Theme,
+    label: SharedString,
+    action: Option<AnyElement>,
+    chevron: AnyElement,
+) -> gpui::Div {
     div()
         .flex()
         .flex_row()
@@ -2125,6 +2130,7 @@ fn sidebar_disclosure_header(theme: &Theme, label: SharedString, chevron: AnyEle
                 .child(label),
         ))
         .child(div().flex_1())
+        .children(action)
         .child(chevron)
 }
 
@@ -4933,7 +4939,46 @@ impl Shell {
             let chevron = self.sidebar_disclosure_chevron(&motion_key, !collapsed, theme);
             let toggle_key = collapse_key.clone();
             let toggle_motion_key = motion_key.clone();
-            let header = sidebar_disclosure_header(theme, visible_label, chevron)
+            // A real project's group gets a hover-revealed `+` that opens a new
+            // chat homed on it.
+            let group_name = SharedString::from(format!("sidebar-group-hover-{collapse_key}"));
+            let new_chat_button = (self.settings.sidebar_organization
+                == SidebarOrganization::ByProject
+                && self.state.read(cx).space_row(&key).is_some())
+            .then(|| {
+                let project = key.clone();
+                div()
+                    .id(SharedString::from(format!(
+                        "sidebar-group-new-chat-{collapse_key}"
+                    )))
+                    .size(px(20.0))
+                    .flex_none()
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .rounded(px(4.0))
+                    .cursor_pointer()
+                    .role(gpui::Role::Button)
+                    .aria_label("New chat in project")
+                    .opacity(0.0)
+                    .group_hover(group_name.clone(), |style| style.opacity(1.0))
+                    .hover(|el| el.bg(theme.glass_hover()))
+                    .on_click(cx.listener(move |this, _, _, cx| {
+                        cx.stop_propagation();
+                        this.open_new_session(Some(project.clone()), cx);
+                    }))
+                    .tooltip(crate::settings::widgets::text_tooltip_above(
+                        "New chat in project",
+                    ))
+                    .child(
+                        icon(icons::PLUS)
+                            .size(px(14.0))
+                            .text_color(theme.text_muted),
+                    )
+                    .into_any_element()
+            });
+            let header = sidebar_disclosure_header(theme, visible_label, new_chat_button, chevron)
+                .group(group_name)
                 .id(SharedString::from(format!("sidebar-group-{collapse_key}")))
                 .on_click(cx.listener(move |this, _, _, cx| {
                     let was_open = !this.sidebar_collapsed_groups.contains(&toggle_key);
@@ -4993,7 +5038,7 @@ impl Shell {
             format!("Pinned ({})", items.len()).into()
         };
         let chevron = self.sidebar_disclosure_chevron("pinned", open, theme);
-        let header = sidebar_disclosure_header(theme, label, chevron)
+        let header = sidebar_disclosure_header(theme, label, None, chevron)
             .id("pinned-toggle")
             .debug_selector(|| "pinned-toggle".into())
             .on_drag_move::<SidebarSessionDrag>(cx.listener(
@@ -5074,7 +5119,7 @@ impl Shell {
             format!("Sessions ({count})").into()
         };
         let chevron = self.sidebar_disclosure_chevron("sessions", open, theme);
-        let header = sidebar_disclosure_header(theme, label, chevron)
+        let header = sidebar_disclosure_header(theme, label, None, chevron)
             .id("sessions-toggle")
             .debug_selector(|| "sessions-toggle".into())
             .on_drag_move::<SidebarSessionDrag>(cx.listener(
@@ -5213,7 +5258,7 @@ impl Shell {
             format!("Archived ({total})").into()
         };
         let chevron = self.sidebar_disclosure_chevron("archived", open, theme);
-        let header = sidebar_disclosure_header(theme, label, chevron)
+        let header = sidebar_disclosure_header(theme, label, None, chevron)
             .id("archived-toggle")
             .on_click(cx.listener(move |this, _, _, cx| {
                 let was_open = this.archived_open;
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index 86939861e9..e85664b31b 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -219,7 +219,10 @@ impl Shell {
     /// A new chat always starts with the terminal hidden: when the drawer is
     /// open it just hides (detach, not close — the source chat's tabs and
     /// PTYs survive for the return trip).
-    pub(super) fn open_new_session(&mut self, cx: &mut Context<Self>) {
+    ///
+    /// `project` (the per-project `+` on a sidebar group header) homes the
+    /// canvas on that project and wins over the sidebar filter.
+    pub(super) fn open_new_session(&mut self, project: Option<String>, cx: &mut Context<Self>) {
         self.command_palette = None;
         self.route = Route::Chat;
         self.focus_composer(cx);
@@ -239,9 +242,8 @@ impl Shell {
         }
         let target = {
             let state = self.state.read(cx);
-            self.settings
-                .space_filter
-                .clone()
+            project
+                .or_else(|| self.settings.space_filter.clone())
                 .filter(|id| state.space_row(id).is_some())
         };
         let defaults = crate::settings::composer::ComposerDefaults::load(&self.data_dir);

From 9e1a11158b0626237c814f4bd36f5948483ed797 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Sat, 3 Oct 2026 02:55:54 -0300
Subject: [PATCH 45/74] Render Mermaid diagrams in chat replies (#760)

* Render Mermaid diagrams in chat replies

Assistant replies now draw ```mermaid fences as diagrams with the file
preview's engine, fence frame, source toggle, Copy action and lightbox.
Inline images in chat keep their text rendering.

Streaming never renders a fence that may still be growing: only blocks a
later row of the same reply follows, or blocks of a completed reply,
request a diagram, so per-token commits start no render work. Until a
diagram is ready the fence shows its source, and a failed render keeps
the source with the engine's diagnostic in a header marker.

Rows request their fences while laying out, so only painted diagrams
are rendered, one at a time off the UI thread; requests whose rows
scrolled away are dropped. Results are retained under a byte budget,
least recently painted first out. A swap remeasures only the rows
painting it and uses the existing layout signals, so the bottom pin
follows and the own-turn runway absorbs the change without moving the
sent prompt.

* Account prepared SVGs at their current raster, not the largest possible

decode_image reserved the largest preview any view could request (900x480
at 4x density) for every SVG and Mermaid diagram, so a 177x348 class
diagram counted 7.6 MiB against the 64 MiB media budgets. The file
preview stopped drawing diagrams after about eight per document, the chat
cache retained about eight, and the lightbox had little room left to
enlarge.

Media now counts its source plus the CPU and GPU copies of the raster it
holds. Since admission no longer reserves headroom, the file preview and
the chat diagram cache re-check their budget before a larger re-raster
(MediaImage::preview_within); a variant that does not fit keeps the
current raster.

* Draw Mermaid diagrams in Zeron's style

Render diagrams on a transparent canvas so they sit on the fence body,
with rounded hairline cards for nodes, muted labels and connectors, and a
soft accent tint on default decisions, sequence notes and activations.
Gantt bars take their hues from the accent and gridlines use the theme
border. Explicit style and classDef colors are kept. Tighter spacing keeps
labels larger once a diagram is scaled to the reading column, and the
lightbox draws diagrams on a plate in the fence body color.

* Gate Linux-only Mermaid cache test helpers

ready_count and ready_media serve the transcript tests, which only compile
on Linux, so they were dead code (with a warning) on macOS and Windows.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/attachments.rs            |  19 +-
 crates/ui/src/files/image_preview.rs    |   1 +
 crates/ui/src/files/markdown_preview.rs | 175 ++++----
 crates/ui/src/image_media.rs            |  88 +++-
 crates/ui/src/image_viewer.rs           |  13 +
 crates/ui/src/markdown/mermaid.rs       | 255 ++++++++++--
 crates/ui/src/markdown/mermaid_cache.rs | 366 +++++++++++++++++
 crates/ui/src/markdown/mod.rs           |   1 +
 crates/ui/src/markdown/render.rs        |  87 +++-
 crates/ui/src/transcript.rs             | 512 +++++++++++++++++++++++-
 docs/markdown-preview.md                |  24 +-
 11 files changed, 1399 insertions(+), 142 deletions(-)
 create mode 100644 crates/ui/src/markdown/mermaid_cache.rs

diff --git a/crates/ui/src/attachments.rs b/crates/ui/src/attachments.rs
index c5483bf1f3..1f3078cafc 100644
--- a/crates/ui/src/attachments.rs
+++ b/crates/ui/src/attachments.rs
@@ -956,6 +956,8 @@ pub struct PreviewImage {
     pub name: SharedString,
     pub image: Arc<Image>,
     pub(crate) viewer: crate::image_viewer::ImageView,
+    /// Fill behind an image drawn on a transparent canvas (diagrams).
+    pub(crate) plate: Option<gpui::Hsla>,
 }
 
 impl PreviewImage {
@@ -964,8 +966,14 @@ impl PreviewImage {
             name: name.into(),
             image,
             viewer: Default::default(),
+            plate: None,
         }
     }
+
+    pub(crate) fn with_plate(mut self, plate: gpui::Hsla) -> Self {
+        self.plate = Some(plate);
+        self
+    }
 }
 
 /// Shared image viewer over a dim scrim. Escape and a click close it;
@@ -1006,9 +1014,14 @@ pub(crate) fn lightbox_with_size(
             })
     });
     let content = match natural_size {
-        Some(natural) => preview
-            .viewer
-            .render(preview.image.clone(), natural, None, window, cx),
+        Some(natural) => preview.viewer.render(
+            preview.image.clone(),
+            natural,
+            None,
+            preview.plate,
+            window,
+            cx,
+        ),
         None => div()
             .text_color(ink(0.6))
             .child("Loading image…")
diff --git a/crates/ui/src/files/image_preview.rs b/crates/ui/src/files/image_preview.rs
index d85ebf1c02..88d23e9dfb 100644
--- a/crates/ui/src/files/image_preview.rs
+++ b/crates/ui/src/files/image_preview.rs
@@ -205,6 +205,7 @@ impl Render for ImagePreview {
                 display.image,
                 gpui::size(px(source.width), px(source.height)),
                 None,
+                None,
                 window,
                 cx,
             ));
diff --git a/crates/ui/src/files/markdown_preview.rs b/crates/ui/src/files/markdown_preview.rs
index 51fc1975d3..dfe7a7ab51 100644
--- a/crates/ui/src/files/markdown_preview.rs
+++ b/crates/ui/src/files/markdown_preview.rs
@@ -239,14 +239,29 @@ impl MarkdownPreview {
             480.0,
         );
         let mut retired = Vec::new();
+        // Admission accounts current rasters, so a sharper one must still fit
+        // the document budget.
+        let mut used: usize = self
+            .images
+            .values()
+            .chain(self.diagrams.values())
+            .filter_map(|m| m.as_ref().ok())
+            .map(|m| m.bytes)
+            .sum();
         for media in self
             .images
             .values_mut()
             .chain(self.diagrams.values_mut())
             .filter_map(|m| m.as_mut().ok())
         {
-            let next = media.preview_for_view(target, window.scale_factor());
+            let others = used - media.bytes;
+            let next = media.preview_within(
+                target,
+                window.scale_factor(),
+                MAX_MEDIA_BYTES.saturating_sub(others),
+            );
             if !Arc::ptr_eq(&media.image, &next.image) {
+                used = others + next.bytes;
                 retired.push(std::mem::replace(media, next));
                 self.media_dirty = true;
             }
@@ -966,38 +981,22 @@ impl MarkdownPreview {
         loaded: &crate::image_media::MediaImage,
         id: gpui::SharedString,
         name: String,
+        plate: Option<gpui::Hsla>,
         weak: gpui::WeakEntity<Self>,
     ) -> AnyElement {
-        use gpui::StyledImage as _;
-        let preview = crate::attachments::PreviewImage::new(name, loaded.image.clone());
+        let mut preview = crate::attachments::PreviewImage::new(name, loaded.image.clone());
+        preview.plate = plate;
         let source = loaded.clone();
-        div()
-            .id(id)
-            .w_full()
-            .max_w(px(loaded.width))
-            .mx_auto()
-            .max_h(px(480.0))
-            .aspect_ratio(loaded.width / loaded.height)
-            .cursor_pointer()
-            .role(gpui::Role::Button)
-            .aria_label("Enlarge image")
-            .on_click(move |_, window, cx| {
-                cx.stop_propagation();
-                let _ = weak.update(cx, |view, cx| {
-                    view.close_media_preview(cx);
-                    view.zoom_source = Some(source.clone());
-                    preview.viewer.reset();
-                    view.preview_image = Some(preview.clone());
-                    window.focus(&view.preview_focus, cx);
-                    cx.notify();
-                });
-            })
-            .child(
-                gpui::img(loaded.image.clone())
-                    .size_full()
-                    .object_fit(gpui::ObjectFit::Contain),
-            )
-            .into_any_element()
+        crate::image_media::preview_element(loaded, id, move |window, cx| {
+            let _ = weak.update(cx, |view, cx| {
+                view.close_media_preview(cx);
+                view.zoom_source = Some(source.clone());
+                preview.viewer.reset();
+                view.preview_image = Some(preview.clone());
+                window.focus(&view.preview_focus, cx);
+                cx.notify();
+            });
+        })
     }
 
     #[cfg(test)]
@@ -1129,6 +1128,7 @@ impl MarkdownPreview {
                                 loaded,
                                 format!("{id}-image").into(),
                                 "Mermaid diagram".into(),
+                                Some(crate::markdown::mermaid::Palette::plate(theme)),
                                 diagram_owner.clone(),
                             ),
                             Some(Err(error)) => div()
@@ -1147,7 +1147,7 @@ impl MarkdownPreview {
                                 })
                                 .into_any_element(),
                         };
-                        render::DiagramUi {
+                        render::DiagramView::Diagram(render::DiagramUi {
                             body,
                             show_source: source_shown,
                             toggle_source: Rc::new(move |_, cx| {
@@ -1159,16 +1159,13 @@ impl MarkdownPreview {
                                     cx.notify();
                                 });
                             }),
-                        }
+                        })
                     })),
-                    image: Rc::new(move |image, id, theme| match images.get(&image.source) {
-                        Some(Ok(loaded)) => {
-                            let mut el =
-                                div()
-                                    .flex()
-                                    .flex_col()
-                                    .gap(px(4.0))
-                                    .child(Self::media_element(
+                    image: Some(Rc::new(move |image, id, theme| {
+                        match images.get(&image.source) {
+                            Some(Ok(loaded)) => {
+                                let mut el = div().flex().flex_col().gap(px(4.0)).child(
+                                    Self::media_element(
                                         loaded,
                                         id,
                                         if image.alt.is_empty() {
@@ -1176,12 +1173,17 @@ impl MarkdownPreview {
                                         } else {
                                             image.alt.clone()
                                         },
+                                        None,
                                         image_owner.clone(),
-                                    ));
-                            if let Some(target) = image.link.clone() {
-                                let link = image_link.clone();
-                                el = el.child(
-                                    super::toolbar_button("markdown-image-link", "Open image link")
+                                    ),
+                                );
+                                if let Some(target) = image.link.clone() {
+                                    let link = image_link.clone();
+                                    el = el.child(
+                                        super::toolbar_button(
+                                            "markdown-image-link",
+                                            "Open image link",
+                                        )
                                         .on_click(move |_, window, cx| {
                                             render::activate_link(
                                                 render::LinkTarget::new(&target, &target),
@@ -1196,51 +1198,52 @@ impl MarkdownPreview {
                                                 .size(px(crate::surface_chrome::ICON_SIZE))
                                                 .text_color(theme.text_muted),
                                         ),
-                                );
+                                    );
+                                }
+                                el.into_any_element()
                             }
-                            el.into_any_element()
-                        }
-                        state => {
-                            let text = if image.source.starts_with("https://")
-                                || image.source.starts_with("http://")
-                            {
-                                format!("{} — {}", image.alt, image.source)
-                            } else {
-                                format!(
-                                    "{} — {}",
-                                    image.alt,
-                                    state
-                                        .and_then(|s| s.as_ref().err())
-                                        .map(String::as_str)
-                                        .unwrap_or(if image_allowed.contains(&image.source) {
-                                            "Loading image…"
-                                        } else {
-                                            "Document image preview limit reached"
+                            state => {
+                                let text = if image.source.starts_with("https://")
+                                    || image.source.starts_with("http://")
+                                {
+                                    format!("{} — {}", image.alt, image.source)
+                                } else {
+                                    format!(
+                                        "{} — {}",
+                                        image.alt,
+                                        state
+                                            .and_then(|s| s.as_ref().err())
+                                            .map(String::as_str)
+                                            .unwrap_or(if image_allowed.contains(&image.source) {
+                                                "Loading image…"
+                                            } else {
+                                                "Document image preview limit reached"
+                                            })
+                                    )
+                                };
+                                let target = image.source.clone();
+                                let external =
+                                    target.starts_with("https://") || target.starts_with("http://");
+                                div()
+                                    .id(id)
+                                    .text_color(theme.text_muted)
+                                    .child(text)
+                                    .when(external, |el| {
+                                        let link = image_link.clone();
+                                        el.cursor_pointer().on_click(move |_, window, cx| {
+                                            render::activate_link(
+                                                render::LinkTarget::new(&target, &target),
+                                                render::LinkAction::Primary,
+                                                Some(&link),
+                                                window,
+                                                cx,
+                                            );
                                         })
-                                )
-                            };
-                            let target = image.source.clone();
-                            let external =
-                                target.starts_with("https://") || target.starts_with("http://");
-                            div()
-                                .id(id)
-                                .text_color(theme.text_muted)
-                                .child(text)
-                                .when(external, |el| {
-                                    let link = image_link.clone();
-                                    el.cursor_pointer().on_click(move |_, window, cx| {
-                                        render::activate_link(
-                                            render::LinkTarget::new(&target, &target),
-                                            render::LinkAction::Primary,
-                                            Some(&link),
-                                            window,
-                                            cx,
-                                        );
                                     })
-                                })
-                                .into_any_element()
+                                    .into_any_element()
+                            }
                         }
-                    }),
+                    })),
                 });
                 opts.link = Some(link.clone());
                 opts.copy = Some(self.copy_ui_for(&opts.row_key, cx));
diff --git a/crates/ui/src/image_media.rs b/crates/ui/src/image_media.rs
index f89605df8e..7f862be142 100644
--- a/crates/ui/src/image_media.rs
+++ b/crates/ui/src/image_media.rs
@@ -60,6 +60,12 @@ fn raster_size(
     size
 }
 
+/// Memory a prepared SVG holds: its source and wrapper copies, plus both the
+/// CPU pixels and GPU texture of one raster.
+fn svg_retained_bytes(svg: &str, raster: (u32, u32)) -> usize {
+    svg.len() * 2 + 1024 + raster.0 as usize * raster.1 as usize * 8
+}
+
 impl MediaImage {
     /// Preserve the sanitized vector source; only the outer raster viewport changes.
     pub(crate) fn for_view(&self, viewport: (f32, f32), dpi: f32, pixels: usize) -> Self {
@@ -82,14 +88,25 @@ impl MediaImage {
             image: Arc::new(Image::from_bytes(ImageFormat::Svg, wrapper.into_bytes())),
             width: self.width,
             height: self.height,
-            bytes: self
-                .bytes
-                .max(svg.len() * 2 + 1024 + size.0 as usize * size.1 as usize * 8),
+            bytes: svg_retained_bytes(svg, size),
             svg: self.svg.clone(),
             raster_size: Some(size),
         }
     }
 
+    /// Re-rasterize for a new view only when the variant fits the memory the
+    /// owner can still spend (`available`, excluding this media). A larger
+    /// raster that does not fit keeps the current one: slightly softer, never
+    /// over budget.
+    pub(crate) fn preview_within(&self, viewport: (f32, f32), dpi: f32, available: usize) -> Self {
+        let next = self.preview_for_view(viewport, dpi);
+        if next.bytes > self.bytes && next.bytes > available {
+            self.clone()
+        } else {
+            next
+        }
+    }
+
     pub(crate) fn preview_for_view(&self, viewport: (f32, f32), dpi: f32) -> Self {
         self.for_view(viewport, dpi, PREVIEW_PIXELS)
     }
@@ -117,6 +134,36 @@ impl MediaImage {
     }
 }
 
+/// Prepared media centered at its natural size within the reading column,
+/// capped at 480px tall. A click requests the enlarged lightbox.
+pub(crate) fn preview_element(
+    loaded: &MediaImage,
+    id: gpui::SharedString,
+    on_click: impl Fn(&mut gpui::Window, &mut gpui::App) + 'static,
+) -> gpui::AnyElement {
+    use gpui::{InteractiveElement as _, IntoElement as _, StyledImage as _, prelude::*};
+    gpui::div()
+        .id(id)
+        .w_full()
+        .max_w(gpui::px(loaded.width))
+        .mx_auto()
+        .max_h(gpui::px(480.0))
+        .aspect_ratio(loaded.width / loaded.height)
+        .cursor_pointer()
+        .role(gpui::Role::Button)
+        .aria_label("Enlarge image")
+        .on_click(move |_, window, cx| {
+            cx.stop_propagation();
+            on_click(window, cx);
+        })
+        .child(
+            gpui::img(loaded.image.clone())
+                .size_full()
+                .object_fit(gpui::ObjectFit::Contain),
+        )
+        .into_any_element()
+}
+
 pub(crate) fn svg_options() -> usvg::Options<'static> {
     static FONTS: OnceLock<Arc<usvg::fontdb::Database>> = OnceLock::new();
     let fonts = FONTS
@@ -157,15 +204,14 @@ pub(crate) fn decode_image(mime: &str, bytes: Vec<u8>) -> Result<MediaImage, Str
         if svg.len() > zeron_proto::MAX_WORKSPACE_IMAGE_BYTES {
             return Err("Prepared SVG exceeds preview size limit".into());
         }
-        let maximum = raster_size(width, height, (900.0, 480.0), 4.0, PREVIEW_PIXELS);
-        // Reserve the largest admitted preview across supported display densities,
-        // including both CPU pixels and GPU texture, plus source and wrapper.
-        let retained = svg.len() * 2 + 1024 + maximum.0 as usize * maximum.1 as usize * 8;
+        // Account the raster that exists, not the largest one any view could
+        // request: owners re-check their budget before a larger re-raster
+        // (`MediaImage::preview_within`).
         let media = MediaImage {
             image: Arc::new(Image::from_bytes(ImageFormat::Svg, Vec::new())),
             width,
             height,
-            bytes: retained,
+            bytes: svg_retained_bytes(&svg, (0, 0)),
             svg: Some(Arc::from(svg)),
             raster_size: None,
         };
@@ -351,6 +397,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn svg_accounting_follows_the_current_raster_and_upgrades_respect_budget() {
+        let media = decode_image(
+            "image/svg+xml",
+            br#"<svg xmlns="http://www.w3.org/2000/svg" width="200" height="100"><rect width="200" height="100"/></svg>"#.to_vec(),
+        )
+        .unwrap();
+        let exact = |m: &MediaImage| {
+            let (w, h) = m.raster_size.unwrap();
+            m.svg.as_ref().unwrap().len() * 2 + 1024 + w as usize * h as usize * 8
+        };
+        // A small diagram no longer reserves the largest preview any view
+        // could ask for (900x480 at 4x).
+        assert_eq!(media.bytes, exact(&media));
+        assert!(media.bytes < 1024 * 1024);
+        let sharper = media.preview_within((900.0, 480.0), 4.0, usize::MAX);
+        assert!(sharper.bytes > media.bytes);
+        assert_eq!(sharper.bytes, exact(&sharper));
+        // Without room for the larger raster, the current one stays.
+        let held = media.preview_within((900.0, 480.0), 4.0, media.bytes);
+        assert!(Arc::ptr_eq(&held.image, &media.image));
+        // A smaller raster frees memory and is always taken.
+        let smaller = sharper.preview_within((100.0, 50.0), 1.0, 0);
+        assert!(smaller.bytes < sharper.bytes);
+    }
+
     #[test]
     fn extreme_aspect_ratios_stay_inside_the_pixel_budget() {
         for (w, h) in [(1e20, 1.0), (1.0, 1e20)] {
diff --git a/crates/ui/src/image_viewer.rs b/crates/ui/src/image_viewer.rs
index b36b337557..10bbbda8a3 100644
--- a/crates/ui/src/image_viewer.rs
+++ b/crates/ui/src/image_viewer.rs
@@ -207,6 +207,7 @@ impl ImageView {
         image: Arc<Image>,
         natural: Size<Pixels>,
         on_image_click: Option<ImageClick>,
+        plate: Option<gpui::Hsla>,
         _window: &mut Window,
         _cx: &mut App,
     ) -> AnyElement {
@@ -283,6 +284,18 @@ impl ImageView {
                     on_click(window, cx);
                 }
             })
+            .when_some(plate, |viewport, plate| {
+                viewport.child(
+                    div()
+                        .absolute()
+                        .left(px(origin.x))
+                        .top(px(origin.y))
+                        .w(px(natural.width * geometry.scale))
+                        .h(px(natural.height * geometry.scale))
+                        .rounded(px(10.0))
+                        .bg(plate),
+                )
+            })
             .child(
                 gpui::img(image)
                     .absolute()
diff --git a/crates/ui/src/markdown/mermaid.rs b/crates/ui/src/markdown/mermaid.rs
index 9cce173a6c..a22b6ea4df 100644
--- a/crates/ui/src/markdown/mermaid.rs
+++ b/crates/ui/src/markdown/mermaid.rs
@@ -8,16 +8,23 @@ pub const MAX_SOURCE_BYTES: usize = 16 * 1024;
 // CPU work across previews; UI owners discard results from superseded revisions.
 static RENDER_LOCK: Mutex<()> = Mutex::new(());
 
+/// Zeron's diagram style. The canvas is left transparent so the diagram sits
+/// on its fence body; `canvas` is that body's opaque approximation, used where
+/// the engine needs a solid mask (edge label pills, hollow markers).
 #[derive(Clone)]
 pub struct Palette {
     dark: bool,
     font: String,
-    background: String,
-    raised: String,
+    canvas: String,
+    node: String,
+    group: String,
     text: String,
-    muted: String,
+    label: String,
+    line: String,
     border: String,
-    accent: String,
+    grid: String,
+    accent_line: String,
+    accent_wash: String,
 }
 
 fn color(color: gpui::Hsla, background: gpui::Hsla) -> String {
@@ -36,17 +43,36 @@ fn color(color: gpui::Hsla, background: gpui::Hsla) -> String {
 
 impl Palette {
     pub fn from_theme(theme: &Theme) -> Self {
+        let dark = theme.appearance.is_dark();
+        let canvas = Self::plate(theme);
+        // Nodes are cards lifted off the fence: white in light, one ink step
+        // up in dark, where the panel is already the deepest plane.
+        let node = if dark {
+            canvas.blend(theme.ink(0.06))
+        } else {
+            theme.bg
+        };
         Self {
-            dark: theme.appearance.is_dark(),
+            dark,
             font: theme.font_sans.to_string(),
-            background: color(theme.surface, theme.bg),
-            raised: color(theme.surface_raised, theme.bg),
-            text: color(theme.text, theme.bg),
-            muted: color(theme.text_muted, theme.bg),
-            border: color(theme.border_strong, theme.bg),
-            accent: color(theme.accent, theme.bg),
+            canvas: color(canvas, theme.bg),
+            node: color(node, canvas),
+            group: color(theme.ink(0.03), canvas),
+            text: color(theme.text, node),
+            label: color(theme.text_muted, canvas),
+            line: color(theme.text_faint, canvas),
+            border: color(theme.border_strong, canvas),
+            grid: color(theme.border, canvas),
+            accent_line: color(theme.accent.opacity(0.6), canvas),
+            accent_wash: color(theme.accent.opacity(0.12), node),
         }
     }
+
+    /// The fence body, an ink wash over the panel (see `code_block_frame`).
+    /// Also the fill behind a diagram shown off its fence, as in the lightbox.
+    pub fn plate(theme: &Theme) -> gpui::Hsla {
+        theme.bg.blend(theme.ink(0.035))
+    }
 }
 
 pub fn render(source: &str, palette: &Palette) -> Result<String, String> {
@@ -67,29 +93,42 @@ pub fn render(source: &str, palette: &Palette) -> Result<String, String> {
         } else {
             mermaid_rs_renderer::Theme::modern()
         };
+        // A denser layout than the engine's default: diagrams are scaled to the
+        // reading column, so slack spacing shrinks the labels.
+        options.layout.node_spacing = 36.0;
+        options.layout.rank_spacing = 40.0;
+        options.layout.node_padding_x = 18.0;
+        options.layout.node_padding_y = 10.0;
         let theme = &mut options.theme;
         theme.font_family = palette.font.clone();
         theme.font_size = 14.0;
-        theme.background = palette.background.clone();
-        theme.primary_color = palette.raised.clone();
+        theme.background = palette.canvas.clone();
+        theme.primary_color = palette.node.clone();
         theme.primary_text_color = palette.text.clone();
         theme.primary_border_color = palette.border.clone();
-        theme.text_color = palette.text.clone();
-        theme.line_color = palette.muted.clone();
-        theme.secondary_color = palette.raised.clone();
-        theme.tertiary_color = palette.raised.clone();
-        theme.edge_label_background = palette.background.clone();
-        theme.cluster_background = palette.background.clone();
+        theme.text_color = palette.label.clone();
+        theme.line_color = palette.line.clone();
+        theme.secondary_color = palette.node.clone();
+        theme.tertiary_color = palette.group.clone();
+        theme.edge_label_background = palette.canvas.clone();
+        theme.cluster_background = palette.group.clone();
         theme.cluster_border = palette.border.clone();
-        theme.sequence_actor_fill = palette.raised.clone();
+        theme.sequence_actor_fill = palette.node.clone();
         theme.sequence_actor_border = palette.border.clone();
-        theme.sequence_actor_line = palette.muted.clone();
-        theme.sequence_note_fill = palette.raised.clone();
-        theme.sequence_note_border = palette.border.clone();
-        theme.sequence_activation_fill = palette.accent.clone();
-        theme.sequence_activation_border = palette.border.clone();
+        theme.sequence_actor_line = palette.border.clone();
+        theme.sequence_note_fill = palette.accent_wash.clone();
+        theme.sequence_note_border = palette.accent_line.clone();
+        theme.sequence_activation_fill = palette.accent_wash.clone();
+        theme.sequence_activation_border = palette.accent_line.clone();
+        if diagram_keyword(source) == Some("gantt") {
+            // Gantt derives its bar hues from this color; a neutral gray would
+            // turn every section red. The softened accent keeps bar labels
+            // legible in both appearances.
+            theme.primary_border_color = palette.accent_line.clone();
+        }
         let svg =
             mermaid_rs_renderer::render_with_options(source, options).map_err(|e| e.to_string())?;
+        let svg = restyle(svg, palette);
         if svg.len() > 2 * 1024 * 1024 {
             return Err("Diagram output exceeds preview size limit".into());
         }
@@ -98,6 +137,128 @@ pub fn render(source: &str, palette: &Palette) -> Result<String, String> {
     .unwrap_or_else(|_| Err("Diagram could not be rendered".into()))
 }
 
+/// The diagram type: the first word after any front matter and comments.
+fn diagram_keyword(source: &str) -> Option<&str> {
+    let mut lines = source
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .peekable();
+    if lines.next_if_eq(&"---").is_some() {
+        lines.by_ref().find(|line| *line == "---");
+    }
+    lines
+        .find(|line| !line.starts_with("%%"))
+        .and_then(|line| line.split_whitespace().next())
+}
+
+/// Finishing touches the engine's theme cannot express, applied to its
+/// pinned output: a transparent canvas, softer node corners, cards for
+/// boxes the engine fills with its background, decisions in the accent and
+/// themed Gantt gridlines. Only elements still carrying the palette's own
+/// colors change, so explicit `style`/`classDef` colors survive.
+fn restyle(svg: String, palette: &Palette) -> String {
+    let canvas_fill = format!(" fill=\"{}\"", palette.canvas);
+    let node_fill = format!(" fill=\"{}\"", palette.node);
+    let border_stroke = format!(" stroke=\"{}\"", palette.border);
+    let mut out = String::with_capacity(svg.len());
+    let mut rest = svg.as_str();
+    while let Some(start) = rest.find('<') {
+        out.push_str(&rest[..start]);
+        rest = &rest[start..];
+        let Some(end) = rest.find('>') else { break };
+        let tag = &rest[..=end];
+        rest = &rest[end + 1..];
+        if is_canvas(tag, palette) {
+            continue;
+        }
+        if tag.starts_with("<polygon ") && is_default_diamond(tag, palette) {
+            out.push_str(
+                &tag.replacen(&node_fill, &format!(" fill=\"{}\"", palette.accent_wash), 1)
+                    .replacen(
+                        &border_stroke,
+                        &format!(" stroke=\"{}\"", palette.accent_line),
+                        1,
+                    ),
+            );
+        } else if tag.starts_with("<rect ") {
+            let mut tag = tag.replacen(" rx=\"3\" ry=\"3\" ", " rx=\"8\" ry=\"8\" ", 1);
+            if tag.contains(&border_stroke) {
+                tag = tag.replacen(&canvas_fill, &node_fill, 1);
+            }
+            out.push_str(&tag);
+        } else if tag.starts_with("<line ") {
+            out.push_str(&tag.replacen(
+                " stroke=\"#E2E8F0\"",
+                &format!(" stroke=\"{}\"", palette.grid),
+                1,
+            ));
+        } else {
+            out.push_str(tag);
+        }
+    }
+    out.push_str(rest);
+    out
+}
+
+/// `name="value"` pairs of a start tag, as the engine writes them.
+fn attributes(tag: &str) -> Vec<(&str, &str)> {
+    let parts: Vec<_> = tag.split('"').collect();
+    parts
+        .as_chunks::<2>()
+        .0
+        .iter()
+        .filter_map(|[name, value]| {
+            let name = name.trim_end().strip_suffix('=')?;
+            Some((name.rsplit(' ').next()?, *value))
+        })
+        .collect()
+}
+
+/// A full-bleed background: a plain rectangle in the canvas color.
+fn is_canvas(tag: &str, palette: &Palette) -> bool {
+    if !tag.starts_with("<rect ") {
+        return false;
+    }
+    let mut fill = None;
+    for (name, value) in attributes(tag) {
+        match name {
+            "x" | "y" | "width" | "height" => {}
+            "fill" => fill = Some(value),
+            _ => return false,
+        }
+    }
+    fill == Some(palette.canvas.as_str())
+}
+
+fn is_default_diamond(tag: &str, palette: &Palette) -> bool {
+    let attrs = attributes(tag);
+    let get = |key: &str| attrs.iter().find(|(name, _)| *name == key).map(|(_, v)| *v);
+    if get("fill") != Some(palette.node.as_str()) || get("stroke") != Some(palette.border.as_str())
+    {
+        return false;
+    }
+    let Some(points) = get("points") else {
+        return false;
+    };
+    let points: Vec<(f32, f32)> = points
+        .split_whitespace()
+        .filter_map(|point| {
+            let (x, y) = point.split_once(',')?;
+            Some((x.parse().ok()?, y.parse().ok()?))
+        })
+        .collect();
+    let [top, right, bottom, left] = points[..] else {
+        return false;
+    };
+    (top.0 - bottom.0).abs() < 0.05
+        && (left.1 - right.1).abs() < 0.05
+        && left.0 < top.0
+        && top.0 < right.0
+        && top.1 < left.1
+        && left.1 < bottom.1
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -189,4 +350,48 @@ mod tests {
         assert!(render(&"x".repeat(MAX_SOURCE_BYTES + 1), &palette).is_err());
         assert!(render("flowchart TD\nA[Hola<br/>mundo] --> B[Fin]", &palette).is_ok());
     }
+
+    #[test]
+    fn diagrams_take_zeron_style_and_keep_explicit_colors() {
+        for theme in [Theme::light(), Theme::dark()] {
+            let palette = Palette::from_theme(&theme);
+            let svg = render(
+                "flowchart TD\nA[Inicio] --> B{¿Listo?}\nB --> C[Fin]\nB --> D{Otra}\nstyle D fill:#dbeafe,stroke:#2563eb",
+                &palette,
+            )
+            .unwrap();
+            // The fence body shows through: no full-bleed background remains.
+            assert!(!svg.contains(&format!("fill=\"{}\"/>", palette.canvas)));
+            assert!(svg.contains(" rx=\"8\" ry=\"8\" "));
+            assert!(!svg.contains(" rx=\"3\" ry=\"3\" "));
+            let diamonds: Vec<_> = svg.match_indices("<polygon ").collect();
+            let accented = svg
+                .matches(&format!(
+                    "fill=\"{}\" stroke=\"{}\"",
+                    palette.accent_wash, palette.accent_line
+                ))
+                .count();
+            assert!(diamonds.len() >= 2);
+            assert_eq!(accented, 1, "only the default-colored decision is tinted");
+            assert!(svg.contains("fill=\"#dbeafe\" stroke=\"#2563eb\""));
+
+            let gantt = render(
+                "%% plan\ngantt\ndateFormat YYYY-MM-DD\nsection A\nTask :2026-09-08, 2d",
+                &palette,
+            )
+            .unwrap();
+            assert!(!gantt.contains("#E2E8F0"));
+        }
+    }
+
+    #[test]
+    fn diagram_keyword_skips_front_matter_and_comments() {
+        assert_eq!(diagram_keyword("gantt\n  title X"), Some("gantt"));
+        assert_eq!(
+            diagram_keyword("---\ntitle: Plan\n---\n%% note\n\n gantt"),
+            Some("gantt")
+        );
+        assert_eq!(diagram_keyword("flowchart LR; A-->B"), Some("flowchart"));
+        assert_eq!(diagram_keyword("  \n%% only"), None);
+    }
 }
diff --git a/crates/ui/src/markdown/mermaid_cache.rs b/crates/ui/src/markdown/mermaid_cache.rs
new file mode 100644
index 0000000000..b64f5c27e1
--- /dev/null
+++ b/crates/ui/src/markdown/mermaid_cache.rs
@@ -0,0 +1,366 @@
+//! Lazily rendered Mermaid diagrams for a surface that discovers its fences
+//! while painting (the agent transcript).
+//!
+//! Rows request their fences as they lay out, so only painted diagrams cost
+//! anything. The owner renders one requested source at a time on a background
+//! executor and drops requests whose rows left the viewport before their turn.
+//! Results are retained under a byte budget, least recently painted first out;
+//! an evicted diagram simply renders again when its row returns. Diagrams
+//! painted in the latest two passes are never evicted, so the budget is soft
+//! only when more diagrams than it admits are on screen at once.
+use crate::image_media::MediaImage;
+use gpui::SharedString;
+use std::collections::{HashMap, HashSet};
+
+pub(crate) const MAX_RETAINED_BYTES: usize = 64 * 1024 * 1024;
+const MAX_ENTRIES: usize = 64;
+
+pub(crate) enum Lookup {
+    Pending,
+    Ready(MediaImage),
+    Failed(SharedString),
+}
+
+enum State {
+    Pending,
+    Ready(MediaImage),
+    Failed(SharedString),
+}
+
+struct Entry {
+    state: State,
+    /// Paint pass that last requested this source.
+    used: u64,
+    /// Rows that painted this source, remeasured when its result lands.
+    rows: Vec<SharedString>,
+}
+
+#[derive(Default)]
+pub(crate) struct MermaidCache {
+    entries: HashMap<String, Entry>,
+    frame: u64,
+    style: Option<u32>,
+    view: Option<((f32, f32), f32)>,
+    new_requests: bool,
+    /// Diagram frames switched to their source, keyed by frame id.
+    source_visible: HashSet<SharedString>,
+}
+
+/// The renderer keys a diagram frame `"{row_key}-mermaid-{ix}"`.
+pub(crate) fn frame_row(frame_id: &str) -> &str {
+    frame_id
+        .rsplit_once("-mermaid-")
+        .map_or(frame_id, |(row, _)| row)
+}
+
+impl MermaidCache {
+    /// Start a paint pass. A theme change discards every diagram, since the
+    /// palette is baked into the generated SVG; the media is returned for
+    /// release.
+    pub(crate) fn begin_frame(&mut self, style: u32) -> Vec<MediaImage> {
+        self.frame += 1;
+        if self.style == Some(style) {
+            return Vec::new();
+        }
+        self.style = Some(style);
+        self.drain()
+    }
+
+    /// Rasterize retained diagrams for the column width and display density.
+    /// Returns superseded rasters for release.
+    pub(crate) fn set_view(&mut self, target: (f32, f32), scale: f32) -> Vec<MediaImage> {
+        if self.view == Some((target, scale)) {
+            return Vec::new();
+        }
+        self.view = Some((target, scale));
+        let mut retired = Vec::new();
+        let mut used = self.retained_bytes();
+        for entry in self.entries.values_mut() {
+            if let State::Ready(media) = &mut entry.state {
+                let others = used - media.bytes;
+                let next =
+                    media.preview_within(target, scale, MAX_RETAINED_BYTES.saturating_sub(others));
+                if !std::sync::Arc::ptr_eq(&media.image, &next.image) {
+                    used = others + next.bytes;
+                    retired.push(std::mem::replace(media, next));
+                }
+            }
+        }
+        retired
+    }
+
+    /// Look up a fence painted in the current pass, queueing it if unseen.
+    pub(crate) fn request(&mut self, code: &str, frame_id: &str) -> Lookup {
+        let frame = self.frame;
+        let entry = match self.entries.get_mut(code) {
+            Some(entry) => entry,
+            None => {
+                self.new_requests = true;
+                self.entries.entry(code.to_owned()).or_insert(Entry {
+                    state: State::Pending,
+                    used: frame,
+                    rows: Vec::new(),
+                })
+            }
+        };
+        entry.used = frame;
+        let row = frame_row(frame_id);
+        if !entry.rows.iter().any(|known| known == row) {
+            entry.rows.push(row.to_owned().into());
+        }
+        match &entry.state {
+            State::Pending => Lookup::Pending,
+            State::Ready(media) => Lookup::Ready(media.clone()),
+            State::Failed(reason) => Lookup::Failed(reason.clone()),
+        }
+    }
+
+    /// Whether a fence was requested since the last call.
+    pub(crate) fn take_new_requests(&mut self) -> bool {
+        std::mem::take(&mut self.new_requests)
+    }
+
+    /// The next source to render. Requests not repainted in the latest two
+    /// passes belong to rows that scrolled away; they are forgotten and
+    /// requested again if their row returns. Two passes, because a request
+    /// can be made while the current pass has only laid out some of its rows.
+    pub(crate) fn next_job(&mut self) -> Option<String> {
+        let frame = self.frame;
+        self.entries.retain(|_, entry| {
+            !matches!(entry.state, State::Pending) || frame.saturating_sub(entry.used) <= 1
+        });
+        self.entries
+            .iter()
+            .filter(|(_, entry)| matches!(entry.state, State::Pending))
+            .max_by_key(|(_, entry)| entry.used)
+            .map(|(code, _)| code.clone())
+    }
+
+    /// Store a finished render. Returns the rows that painted it (to
+    /// remeasure) and evicted media (to release); `None` when the result is
+    /// obsolete because the theme changed while it rendered.
+    pub(crate) fn finish(
+        &mut self,
+        code: String,
+        style: u32,
+        result: Result<MediaImage, String>,
+    ) -> Option<(Vec<SharedString>, Vec<MediaImage>)> {
+        if self.style != Some(style) {
+            return None;
+        }
+        let state = match result {
+            Ok(media) => State::Ready(match self.view {
+                Some((target, scale)) => media.preview_for_view(target, scale),
+                None => media,
+            }),
+            Err(reason) => State::Failed(reason.into()),
+        };
+        let frame = self.frame;
+        let entry = self.entries.entry(code).or_insert(Entry {
+            state: State::Pending,
+            used: frame,
+            rows: Vec::new(),
+        });
+        entry.state = state;
+        let rows = entry.rows.clone();
+        Some((rows, self.evict()))
+    }
+
+    /// Release settled diagrams least recently painted first until the
+    /// retained memory and entry count fit their limits.
+    fn evict(&mut self) -> Vec<MediaImage> {
+        let mut released = Vec::new();
+        let frame = self.frame;
+        while self.retained_bytes() > MAX_RETAINED_BYTES || self.entries.len() > MAX_ENTRIES {
+            let Some(code) = self
+                .entries
+                .iter()
+                .filter(|(_, entry)| {
+                    !matches!(entry.state, State::Pending) && frame.saturating_sub(entry.used) > 1
+                })
+                .min_by_key(|(_, entry)| entry.used)
+                .map(|(code, _)| code.clone())
+            else {
+                break;
+            };
+            if let Some(Entry {
+                state: State::Ready(media),
+                ..
+            }) = self.entries.remove(&code)
+            {
+                released.push(media);
+            }
+        }
+        released
+    }
+
+    pub(crate) fn retained_bytes(&self) -> usize {
+        self.entries
+            .values()
+            .filter_map(|entry| match &entry.state {
+                State::Ready(media) => Some(media.bytes),
+                _ => None,
+            })
+            .sum()
+    }
+
+    /// Forget every diagram, returning retained media for release.
+    pub(crate) fn drain(&mut self) -> Vec<MediaImage> {
+        self.entries
+            .drain()
+            .filter_map(|(_, entry)| match entry.state {
+                State::Ready(media) => Some(media),
+                _ => None,
+            })
+            .collect()
+    }
+
+    pub(crate) fn source_visible(&self, frame_id: &str) -> bool {
+        self.source_visible.contains(frame_id)
+    }
+
+    pub(crate) fn toggle_source(&mut self, frame_id: &SharedString) {
+        if !self.source_visible.remove(frame_id) {
+            self.source_visible.insert(frame_id.clone());
+        }
+    }
+
+    // Used by the transcript tests, which only run on Linux.
+    #[cfg(all(test, target_os = "linux"))]
+    pub(crate) fn ready_count(&self) -> usize {
+        self.entries
+            .values()
+            .filter(|entry| matches!(entry.state, State::Ready(_)))
+            .count()
+    }
+
+    #[cfg(all(test, target_os = "linux"))]
+    pub(crate) fn ready_media(&self) -> Option<MediaImage> {
+        self.entries.values().find_map(|entry| match &entry.state {
+            State::Ready(media) => Some(media.clone()),
+            _ => None,
+        })
+    }
+
+    pub(crate) fn has_source_toggles(&self) -> bool {
+        !self.source_visible.is_empty()
+    }
+
+    /// Keep source toggles only for frames whose row still exists.
+    pub(crate) fn retain_rows(&mut self, rows: &HashSet<&str>) {
+        self.source_visible
+            .retain(|frame_id| rows.contains(frame_row(frame_id)));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn media(width: u32) -> MediaImage {
+        crate::image_media::decode_image(
+            "image/svg+xml",
+            format!(
+                r#"<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="40"><rect width="{width}" height="40"/></svg>"#
+            )
+            .into_bytes(),
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn requests_queue_once_and_track_their_rows() {
+        let mut cache = MermaidCache::default();
+        assert!(cache.begin_frame(1).is_empty());
+        assert!(matches!(
+            cache.request("graph TD; A-->B", "chat#p.0-mermaid-3"),
+            Lookup::Pending
+        ));
+        assert!(matches!(
+            cache.request("graph TD; A-->B", "chat#p.2-mermaid-0"),
+            Lookup::Pending
+        ));
+        assert!(cache.take_new_requests());
+        assert!(!cache.take_new_requests());
+        let code = cache.next_job().unwrap();
+        let (rows, released) = cache.finish(code, 1, Ok(media(80))).unwrap();
+        assert_eq!(rows, ["chat#p.0", "chat#p.2"]);
+        assert!(released.is_empty());
+        assert!(matches!(
+            cache.request("graph TD; A-->B", "chat#p.0-mermaid-3"),
+            Lookup::Ready(_)
+        ));
+        assert!(!cache.take_new_requests());
+        assert!(cache.next_job().is_none());
+    }
+
+    #[test]
+    fn requests_that_scrolled_away_are_dropped_before_rendering() {
+        let mut cache = MermaidCache::default();
+        cache.begin_frame(1);
+        cache.request("a", "row-mermaid-0");
+        cache.begin_frame(1);
+        cache.request("b", "row2-mermaid-0");
+        // `a` was painted in the previous pass: still eligible.
+        assert!(cache.next_job().is_some());
+        cache.begin_frame(1);
+        cache.request("b", "row2-mermaid-0");
+        assert_eq!(cache.next_job().as_deref(), Some("b"));
+        cache.finish("b".into(), 1, Err("bad".into()));
+        assert!(cache.next_job().is_none());
+        assert!(matches!(
+            cache.request("b", "row2-mermaid-0"),
+            Lookup::Failed(_)
+        ));
+    }
+
+    #[test]
+    fn theme_changes_discard_diagrams_and_obsolete_results() {
+        let mut cache = MermaidCache::default();
+        cache.begin_frame(1);
+        cache.request("a", "row-mermaid-0");
+        cache.finish("a".into(), 1, Ok(media(80)));
+        assert_eq!(cache.begin_frame(2).len(), 1);
+        assert!(matches!(
+            cache.request("a", "row-mermaid-0"),
+            Lookup::Pending
+        ));
+        assert!(cache.finish("a".into(), 1, Ok(media(80))).is_none());
+        assert!(matches!(
+            cache.request("a", "row-mermaid-0"),
+            Lookup::Pending
+        ));
+    }
+
+    #[test]
+    fn eviction_spares_diagrams_painted_in_the_latest_passes() {
+        let mut cache = MermaidCache::default();
+        for ix in 0..MAX_ENTRIES {
+            cache.begin_frame(1);
+            let code = format!("graph {ix}");
+            cache.request(&code, &format!("row{ix}-mermaid-0"));
+            cache.finish(code, 1, Err("bad".into()));
+        }
+        cache.begin_frame(1);
+        cache.begin_frame(1);
+        cache.request("graph 0", "row0-mermaid-0");
+        cache.request("fresh", "fresh-mermaid-0");
+        cache.finish("fresh".into(), 1, Ok(media(80)));
+        assert_eq!(cache.entries.len(), MAX_ENTRIES);
+        assert!(cache.entries.contains_key("graph 0"));
+        assert!(cache.entries.contains_key("fresh"));
+        assert!(!cache.entries.contains_key("graph 1"));
+    }
+
+    #[test]
+    fn source_toggles_follow_their_rows() {
+        let mut cache = MermaidCache::default();
+        let frame: SharedString = "chat#p.0-mermaid-2".into();
+        cache.toggle_source(&frame);
+        assert!(cache.source_visible(&frame));
+        cache.retain_rows(&HashSet::from(["chat#p.0"]));
+        assert!(cache.source_visible(&frame));
+        cache.retain_rows(&HashSet::from(["chat#p.1"]));
+        assert!(!cache.source_visible(&frame));
+    }
+}
diff --git a/crates/ui/src/markdown/mod.rs b/crates/ui/src/markdown/mod.rs
index 11c952ff40..f7302481d8 100644
--- a/crates/ui/src/markdown/mod.rs
+++ b/crates/ui/src/markdown/mod.rs
@@ -27,3 +27,4 @@ pub mod veil;
 pub use parser::{Block, BlockTree, IncrementalParser, InlineRun, InlineStyle, parse_full};
 
 pub mod mermaid;
+pub(crate) mod mermaid_cache;
diff --git a/crates/ui/src/markdown/render.rs b/crates/ui/src/markdown/render.rs
index 7faa45f52e..ceb642fa21 100644
--- a/crates/ui/src/markdown/render.rs
+++ b/crates/ui/src/markdown/render.rs
@@ -109,8 +109,18 @@ pub struct TaskUi {
 
 #[derive(Clone)]
 pub struct MediaUi {
-    pub diagram: Option<Rc<dyn Fn(&str, SharedString, &Theme) -> DiagramUi>>,
-    pub image: Rc<dyn Fn(&super::parser::InlineImage, SharedString, &Theme) -> AnyElement>,
+    pub diagram: Option<Rc<dyn Fn(&str, SharedString, &Theme) -> DiagramView>>,
+    /// `None` keeps inline images in their ordinary text rendering.
+    pub image: Option<Rc<dyn Fn(&super::parser::InlineImage, SharedString, &Theme) -> AnyElement>>,
+}
+
+/// How a Mermaid fence presents itself on the owning surface.
+pub enum DiagramView {
+    /// The ordinary source fence, unchanged (no diagram is available yet).
+    Source,
+    /// The source fence, flagged with the reason it cannot be drawn.
+    Failed(SharedString),
+    Diagram(DiagramUi),
 }
 
 pub struct DiagramUi {
@@ -366,7 +376,7 @@ impl Render for CodeScrollbarDragGhost {
     }
 }
 
-struct CodeBlockTooltip(&'static str);
+struct CodeBlockTooltip(SharedString);
 
 impl Render for CodeBlockTooltip {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
@@ -379,9 +389,10 @@ impl Render for CodeBlockTooltip {
             .border_color(theme.border_strong)
             .bg(theme.surface_raised)
             .shadow_md()
+            .max_w(px(360.0))
             .text_size(px(11.0))
             .text_color(theme.text)
-            .child(self.0)
+            .child(self.0.clone())
     }
 }
 
@@ -917,7 +928,10 @@ fn render_table(
                 TableAlign::Center => cell.text_center(),
                 TableAlign::Right => cell.text_right(),
             };
-            if opts.media.is_some()
+            if opts
+                .media
+                .as_ref()
+                .is_some_and(|media| media.image.is_some())
                 && all[r]
                     .get(c)
                     .is_some_and(|runs| runs.iter().any(|run| run.style.image.is_some()))
@@ -1805,7 +1819,7 @@ fn text_element(
     opts: &RenderOptions,
     theme: &Theme,
 ) -> AnyElement {
-    if let Some(media) = &opts.media {
+    if let Some(image_ui) = opts.media.as_ref().and_then(|media| media.image.as_ref()) {
         if runs.iter().any(|run| run.style.image.is_some()) {
             let mut elements = Vec::new();
             let mut start = 0;
@@ -1823,7 +1837,7 @@ fn text_element(
                             theme,
                         ));
                     }
-                    elements.push((media.image)(
+                    elements.push(image_ui(
                         image,
                         format!("{}-image-{ix}-{index}", opts.row_key).into(),
                         theme,
@@ -2020,7 +2034,27 @@ fn render_code_block(
     if language.is_some_and(|l| l.eq_ignore_ascii_case("mermaid")) {
         if let Some(handler) = opts.media.as_ref().and_then(|media| media.diagram.as_ref()) {
             let frame_id: SharedString = format!("{}-mermaid-{ix}", opts.row_key).into();
-            let diagram = handler(code, frame_id.clone(), theme);
+            let diagram = match handler(code, frame_id.clone(), theme) {
+                DiagramView::Source => {
+                    return render_code_block_source(
+                        language, code, top_ix, ix, opts, theme, highlight,
+                    );
+                }
+                DiagramView::Failed(reason) => {
+                    let notice = code_notice(format!("{frame_id}-failure").into(), reason, theme);
+                    return render_code_block_source_with_actions(
+                        language,
+                        code,
+                        top_ix,
+                        ix,
+                        opts,
+                        theme,
+                        highlight,
+                        vec![notice],
+                    );
+                }
+                DiagramView::Diagram(diagram) => diagram,
+            };
             let toggle = diagram.toggle_source.clone();
             let toggle_action = code_icon_action(
                 format!("{frame_id}-source-toggle").into(),
@@ -2084,7 +2118,7 @@ fn code_icon_action(
             cx.stop_propagation();
             handler(window, cx);
         })
-        .tooltip(move |_, cx| cx.new(move |_| CodeBlockTooltip(label)).into())
+        .tooltip(move |_, cx| cx.new(move |_| CodeBlockTooltip(label.into())).into())
         .child(
             crate::icons::icon(icon_path)
                 .size(px(13.0))
@@ -2093,6 +2127,26 @@ fn code_icon_action(
         .into_any_element()
 }
 
+/// A passive header marker whose tooltip explains why a fence stays source.
+fn code_notice(id: SharedString, message: SharedString, theme: &Theme) -> AnyElement {
+    div()
+        .id(id)
+        .size(px(CODE_ACTION_SIZE))
+        .flex()
+        .items_center()
+        .justify_center()
+        .tooltip(move |_, cx| {
+            let message = message.clone();
+            cx.new(move |_| CodeBlockTooltip(message)).into()
+        })
+        .child(
+            crate::icons::icon(crate::icons::DANGER_TRIANGLE)
+                .size(px(13.0))
+                .text_color(theme.warning_muted),
+        )
+        .into_any_element()
+}
+
 fn code_copy_button(
     code: &str,
     ix: usize,
@@ -2126,7 +2180,7 @@ fn code_copy_button(
                 cx.stop_propagation();
                 handler(ix, code_text.clone(), window, cx);
             })
-            .tooltip(|_, cx| cx.new(|_| CodeBlockTooltip("Copy code")).into())
+            .tooltip(|_, cx| cx.new(|_| CodeBlockTooltip("Copy code".into())).into())
             .child(
                 crate::icons::icon(if copied {
                     crate::icons::CHECK
@@ -2314,11 +2368,14 @@ fn render_code_block_source_with_actions(
             })
             .tooltip(move |_, cx| {
                 cx.new(move |_| {
-                    CodeBlockTooltip(if fit_content {
-                        "Use horizontal scrolling"
-                    } else {
-                        "Fit content"
-                    })
+                    CodeBlockTooltip(
+                        if fit_content {
+                            "Use horizontal scrolling"
+                        } else {
+                            "Fit content"
+                        }
+                        .into(),
+                    )
                 })
                 .into()
             })
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index eb03fc3f7e..56072f2ce6 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -42,6 +42,7 @@ use gpui::{
 use zeron_doc::{MessagePart, MessageRole, MessageStatus, SessionMessageEntry, SubagentStatus};
 use zeron_proto::ToolCall;
 
+use crate::markdown::mermaid_cache::{self, MermaidCache};
 use crate::markdown::parser::{
     Block, BlockTree, IncrementalParser, InlineRun, InlineStyle, parse_full,
 };
@@ -3260,6 +3261,17 @@ pub struct Transcript {
     /// Focused while the lightbox is open so Escape reaches it.
     attachment_preview_focus: gpui::FocusHandle,
     attachment_preview_return_focus: Option<gpui::FocusHandle>,
+    /// Mermaid fences drawn as diagrams in settled Markdown blocks. Each
+    /// row's media handler requests its fences while laying out, so only
+    /// painted diagrams are rendered (see [`MermaidCache`]).
+    diagrams: Rc<RefCell<MermaidCache>>,
+    /// The media handler over `diagrams`, built once and shared by every row.
+    diagram_media: Option<render::MediaUi>,
+    /// The single serialized diagram render loop, while requests remain.
+    diagram_worker: Option<Task<()>>,
+    /// Prepared diagram shown in the lightbox: its natural size frames the
+    /// enlarged raster, which is released when the lightbox closes.
+    diagram_zoom: Option<crate::image_media::MediaImage>,
     /// In-flight ReadAttachmentChunk loads, keyed by device, path and validation
     /// policy; results land in the global attachment cache.
     attachment_loads: HashMap<crate::attachments::AttachmentKey, Task<()>>,
@@ -3435,6 +3447,11 @@ impl Transcript {
             .ok();
         });
         let observe = cx.observe(&state, |this: &mut Self, _, cx| this.sync(cx));
+        cx.on_release(|this: &mut Self, cx| {
+            this.close_diagram_zoom(cx);
+            crate::image_media::release_media(this.diagrams.borrow_mut().drain(), cx);
+        })
+        .detach();
         let text_changes = cx.subscribe(
             &state,
             |this: &mut Self, state, event: &crate::state::TranscriptTextChanged, cx| {
@@ -3535,6 +3552,10 @@ impl Transcript {
             attachment_preview: None,
             attachment_preview_focus: cx.focus_handle(),
             attachment_preview_return_focus: None,
+            diagrams: Rc::default(),
+            diagram_media: None,
+            diagram_worker: None,
+            diagram_zoom: None,
             attachment_loads: HashMap::new(),
             attachment_retries: HashMap::new(),
             blob_details: HashMap::new(),
@@ -4918,6 +4939,11 @@ impl Transcript {
             .collect();
         self.code_fences
             .retain(|key, _| active_code_fences.contains(key));
+        // Diagram source toggles follow the same stable row identity.
+        if self.diagrams.borrow().has_source_toggles() {
+            let row_ids: HashSet<&str> = new_rows.iter().map(|row| row.id.as_ref()).collect();
+            self.diagrams.borrow_mut().retain_rows(&row_ids);
+        }
 
         // Text already streamed before this (re)attach is the veil BASELINE:
         // its rows' veils seed instead of fading (render creates them from
@@ -5822,6 +5848,180 @@ impl Transcript {
             .into_any_element()
     }
 
+    /// Media wiring for settled Markdown: Mermaid fences become diagrams
+    /// once rendered and keep their source until then (or on failure).
+    /// Inline images keep their ordinary chat rendering.
+    fn diagram_media(&mut self, cx: &Context<Self>) -> render::MediaUi {
+        let cache = self.diagrams.clone();
+        let owner = cx.weak_entity();
+        let media = self.diagram_media.get_or_insert_with(|| render::MediaUi {
+            image: None,
+            diagram: Some(Rc::new(move |code, id, _theme| {
+                let lookup = cache.borrow_mut().request(code, &id);
+                match lookup {
+                    mermaid_cache::Lookup::Pending => render::DiagramView::Source,
+                    mermaid_cache::Lookup::Failed(reason) => render::DiagramView::Failed(reason),
+                    mermaid_cache::Lookup::Ready(media) => {
+                        let show_source = cache.borrow().source_visible(&id);
+                        let body = if show_source {
+                            gpui::Empty.into_any_element()
+                        } else {
+                            let open = owner.clone();
+                            let source = media.clone();
+                            crate::image_media::preview_element(
+                                &media,
+                                format!("{id}-image").into(),
+                                move |window, cx| {
+                                    let _ = open.update(cx, |this, cx| {
+                                        this.open_diagram_preview(source.clone(), window, cx)
+                                    });
+                                },
+                            )
+                        };
+                        let toggle = owner.clone();
+                        render::DiagramView::Diagram(render::DiagramUi {
+                            body,
+                            show_source,
+                            toggle_source: Rc::new(move |_, cx| {
+                                let _ = toggle.update(cx, |this, cx| {
+                                    this.diagrams.borrow_mut().toggle_source(&id);
+                                    let row = mermaid_cache::frame_row(&id).to_owned();
+                                    this.diagram_layout_changed(&[row.into()], cx);
+                                });
+                            }),
+                        })
+                    }
+                }
+            })),
+        });
+        media.clone()
+    }
+
+    /// Render requested diagrams one at a time off the UI thread. The loop
+    /// picks its next source between renders, so rows that scrolled away in
+    /// the meantime are skipped rather than queued.
+    fn ensure_diagram_worker(&mut self, cx: &mut Context<Self>) {
+        if self.diagram_worker.is_some() || !self.diagrams.borrow_mut().take_new_requests() {
+            return;
+        }
+        self.diagram_worker = Some(cx.spawn(async move |this, cx| {
+            loop {
+                let job = this.update(cx, |this, cx| {
+                    let job = this.diagrams.borrow_mut().next_job();
+                    if job.is_none() {
+                        this.diagram_worker = None;
+                    }
+                    job.map(|code| {
+                        (
+                            code,
+                            crate::markdown::mermaid::Palette::from_theme(Theme::of(cx)),
+                            crate::theme::style_generation(),
+                        )
+                    })
+                });
+                let Ok(Some((code, palette, style))) = job else {
+                    return;
+                };
+                let source = code.clone();
+                let result = cx
+                    .background_executor()
+                    .spawn(async move {
+                        let svg = crate::markdown::mermaid::render(&source, &palette)?;
+                        crate::image_media::decode_image("image/svg+xml", svg.into_bytes())
+                    })
+                    .await;
+                if this
+                    .update(cx, |this, cx| this.finish_diagram(code, style, result, cx))
+                    .is_err()
+                {
+                    return;
+                }
+            }
+        }));
+    }
+
+    fn finish_diagram(
+        &mut self,
+        code: String,
+        style: u32,
+        result: Result<crate::image_media::MediaImage, String>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some((rows, released)) = self.diagrams.borrow_mut().finish(code, style, result) else {
+            return;
+        };
+        crate::image_media::release_media(released, cx);
+        self.diagram_layout_changed(&rows, cx);
+    }
+
+    /// A diagram replaced its source (or the reverse): remeasure the rows
+    /// painting it and let the bottom pin and the own-turn runway absorb the
+    /// height change, exactly like any other layout-affecting row update.
+    fn diagram_layout_changed(&mut self, rows: &[SharedString], cx: &mut Context<Self>) {
+        let mut changed = false;
+        for (ix, row) in self.rows.iter().enumerate() {
+            if rows.contains(&row.id) {
+                self.list.remeasure_items(ix..ix + 1);
+                changed = true;
+            }
+        }
+        if !changed {
+            return;
+        }
+        self.viewport_layout_revision = self.viewport_layout_revision.wrapping_add(1);
+        if self.pinned {
+            self.wake_spring();
+        }
+        if self.own_turn.is_some() {
+            self.own_turn_kick = true;
+        }
+        cx.notify();
+    }
+
+    /// Open a diagram in the shared lightbox, rasterized for the window
+    /// within the memory the retained diagrams leave available.
+    fn open_diagram_preview(
+        &mut self,
+        source: crate::image_media::MediaImage,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.close_diagram_zoom(cx);
+        let viewport = window.viewport_size();
+        let available = mermaid_cache::MAX_RETAINED_BYTES
+            .saturating_sub(self.diagrams.borrow().retained_bytes());
+        let enlarged = source.enlarged(
+            (
+                f32::from(viewport.width) * 0.9,
+                f32::from(viewport.height) * 0.85,
+            ),
+            window.scale_factor(),
+            available,
+            None,
+        );
+        self.attachment_preview_return_focus = window.focused(cx);
+        self.attachment_preview = Some(
+            crate::attachments::PreviewImage::new("Mermaid diagram", enlarged.image)
+                .with_plate(crate::markdown::mermaid::Palette::plate(Theme::of(cx))),
+        );
+        self.diagram_zoom = Some(source);
+        window.focus(&self.attachment_preview_focus, cx);
+        cx.notify();
+    }
+
+    /// Release a diagram lightbox's dedicated raster. The row's own preview
+    /// stays with the diagram cache.
+    fn close_diagram_zoom(&mut self, cx: &mut gpui::App) {
+        let Some(source) = self.diagram_zoom.take() else {
+            return;
+        };
+        if let Some(preview) = self.attachment_preview.take()
+            && !Arc::ptr_eq(&preview.image, &source.image)
+        {
+            cx.defer(move |cx| gpui::ImageSource::Image(preview.image).evict(None, cx));
+        }
+    }
+
     fn render_generated_image(
         &mut self,
         row_id: &SharedString,
@@ -6494,7 +6694,7 @@ impl Transcript {
                 let code = self.code_uis_for(&row.id, &top.block, *block_ix, cx);
                 let opts = RenderOptions {
                     tasks: None,
-                    media: None,
+                    media: Some(self.diagram_media(cx)),
                     row_key: row.id.clone(),
                     veil: None,
                     cache: (!render_cache_disabled()).then(|| self.render_cache.clone()),
@@ -6553,9 +6753,18 @@ impl Transcript {
                         })
                         .clone()
                 });
+                // A streaming fence may still be growing, so only blocks the
+                // reply has already moved past draw diagrams: a later row of
+                // the same entry proves this block is complete. The tail
+                // keeps its source until the next block or completion, and
+                // per-token commits never start a render.
+                let settled = self
+                    .rows
+                    .get(ix + 1)
+                    .is_some_and(|next| next.entry_id == row.entry_id);
                 let opts = RenderOptions {
                     tasks: None,
-                    media: None,
+                    media: settled.then(|| self.diagram_media(cx)),
                     row_key: row.id.clone(),
                     veil: veil.clone(),
                     cache: (!render_cache_disabled()).then(|| self.render_cache.clone()),
@@ -6575,6 +6784,8 @@ impl Transcript {
                         let seed_opts = RenderOptions {
                             cache: None,
                             link: None,
+                            // Seed fences as source text, never request diagrams.
+                            media: None,
                             ..opts.clone()
                         };
                         let _ = render::render_block(
@@ -6642,6 +6853,8 @@ impl Transcript {
             RowKind::ErrorChip { message } => error_chip(message.clone(), &theme),
             RowKind::ForkMarker { source_title, .. } => fork_marker(source_title.clone(), &theme),
         };
+        // Diagram fences this row just requested start rendering after layout.
+        self.ensure_diagram_worker(cx);
 
         // Hover-revealed metadata strip: a RESERVED 32px lane under the
         // entry's last row. Timestamp, copy action, and copied feedback only
@@ -8900,6 +9113,23 @@ impl Render for Transcript {
         // Release gpui-side decoded copies of any images the attachment LRU
         // evicted since the last frame (no-op when nothing was evicted).
         crate::attachments::flush_evicted(Some(window), cx);
+        // Diagram requests are scoped to paint passes; rasters follow the
+        // reading column and display density (a no-op while both hold).
+        let released_diagrams = {
+            let mut diagrams = self.diagrams.borrow_mut();
+            let mut released = diagrams.begin_frame(crate::theme::style_generation());
+            let list_width = f32::from(self.list.viewport_bounds().size.width);
+            let column = if list_width > 0.0 {
+                self.content_width.min(list_width)
+            } else {
+                self.content_width
+            };
+            released.extend(diagrams.set_view((column.max(1.0), 480.0), window.scale_factor()));
+            released
+        };
+        if !released_diagrams.is_empty() {
+            crate::image_media::release_media(released_diagrams, cx);
+        }
         // Own-turn driver: measurements are only authoritative after layout,
         // so reservation sizing, the send glide, and the outgrown-handoff
         // each advance at most once per requested frame. Scheduled on every
@@ -9046,12 +9276,19 @@ impl Render for Transcript {
         // (AttachmentPreviewDialog: bare lightbox, click closes).
         if let Some(preview) = self.attachment_preview.clone() {
             let weak = cx.weak_entity();
-            return root.child(crate::attachments::lightbox(
+            // A diagram's enlarged raster is framed by its natural size.
+            let natural_size = self
+                .diagram_zoom
+                .as_ref()
+                .map(|source| size(px(source.width), px(source.height)));
+            return root.child(crate::attachments::lightbox_with_size(
                 window,
                 &preview,
                 &self.attachment_preview_focus,
+                natural_size,
                 move |window, cx| {
                     if let Ok(focus) = weak.update(cx, |this, cx| {
+                        this.close_diagram_zoom(cx);
                         this.attachment_preview = None;
                         cx.notify();
                         this.attachment_preview_return_focus.take()
@@ -13072,6 +13309,275 @@ mod tests {
             });
         }
 
+        /// Run the next queued diagram synchronously, as the worker would.
+        fn render_next_diagram(transcript: &Entity<Transcript>, cx: &mut gpui::App) -> bool {
+            transcript.update(cx, |this, cx| {
+                let Some(code) = this.diagrams.borrow_mut().next_job() else {
+                    return false;
+                };
+                let palette = crate::markdown::mermaid::Palette::from_theme(Theme::of(cx));
+                let result = crate::markdown::mermaid::render(&code, &palette).and_then(|svg| {
+                    crate::image_media::decode_image("image/svg+xml", svg.into_bytes())
+                });
+                assert!(result.is_ok(), "fixture diagram must render");
+                this.finish_diagram(code, crate::theme::style_generation(), result, cx);
+                true
+            })
+        }
+
+        const MERMAID_FENCE: &str =
+            "```mermaid\nflowchart TD\n    A[Request] --> B[Plan]\n    B --> C[Done]\n```\n";
+
+        #[test]
+        fn mermaid_streaming_tail_keeps_source_until_the_reply_moves_past_it() {
+            with_window(|transcript, window, cx| {
+                let reply = |status, text: String| {
+                    vec![
+                        prompt("prompt"),
+                        assistant("reply", status, vec![text_part("text", &text)]),
+                    ]
+                };
+                let mut text = String::from("Intro.\n\n");
+                // Token-sized commits through the open fence, then the closed
+                // fence while it is still the reply's tail.
+                for token in MERMAID_FENCE.split_inclusive([' ', '\n']) {
+                    text.push_str(token);
+                    transcript.update(cx, |this, cx| {
+                        this.rail_enabled = false;
+                        feed(this, reply(MessageStatus::Streaming, text.clone()), cx)
+                    });
+                    tick(&transcript, window, cx);
+                    let this = transcript.read(cx);
+                    assert!(
+                        this.diagram_worker.is_none(),
+                        "a streaming tail fence must not start a render"
+                    );
+                    assert!(this.diagrams.borrow_mut().next_job().is_none());
+                }
+                // Enough reply after the fence that the viewport can anchor on
+                // it without clamping back to the end.
+                text.push_str(&format!(
+                    "\nAfter the diagram. {}",
+                    "More detail. ".repeat(300)
+                ));
+                transcript.update(cx, |this, cx| {
+                    feed(this, reply(MessageStatus::Streaming, text.clone()), cx)
+                });
+                draw(window, cx);
+                assert!(
+                    transcript.read(cx).diagram_worker.is_some(),
+                    "a fence followed by more reply renders"
+                );
+                // A pinned end is glued, where rows report no bounds; read
+                // them with the viewport anchored at the diagram row instead.
+                transcript.update(cx, |this, cx| {
+                    this.pinned = false;
+                    let ix = this
+                        .rows
+                        .iter()
+                        .position(|row| row.id.as_ref() == "reply#text.1")
+                        .unwrap();
+                    this.list.scroll_to(ListOffset {
+                        item_ix: ix,
+                        offset_in_item: px(0.0),
+                    });
+                    cx.notify();
+                });
+                draw(window, cx);
+                let fence_height = |cx: &gpui::App| {
+                    let this = transcript.read(cx);
+                    let ix = this
+                        .rows
+                        .iter()
+                        .position(|row| row.id.as_ref() == "reply#text.1")
+                        .unwrap();
+                    this.list.bounds_for_item(ix).unwrap().size.height
+                };
+                let source_height = fence_height(cx);
+                assert!(render_next_diagram(&transcript, cx));
+                assert!(
+                    !render_next_diagram(&transcript, cx),
+                    "one request per source"
+                );
+                draw(window, cx);
+                assert_ne!(
+                    fence_height(cx),
+                    source_height,
+                    "the diagram replaced its source"
+                );
+                let frame: SharedString = "reply#text.1-mermaid-1".into();
+                transcript.update(cx, |this, cx| {
+                    assert_eq!(this.diagrams.borrow().ready_count(), 1);
+                    this.diagrams.borrow_mut().toggle_source(&frame);
+                    this.diagram_layout_changed(&["reply#text.1".into()], cx);
+                });
+                draw(window, cx);
+                assert_eq!(
+                    fence_height(cx),
+                    source_height,
+                    "the toggle restores the source"
+                );
+                // Completion keeps row identity, the rendered diagram and
+                // the reader's source toggle; nothing renders again.
+                transcript.update(cx, |this, cx| {
+                    feed(this, reply(MessageStatus::Complete, text.clone()), cx)
+                });
+                draw(window, cx);
+                let this = transcript.read(cx);
+                assert!(this.diagrams.borrow().source_visible(&frame));
+                assert!(this.diagrams.borrow_mut().next_job().is_none());
+            });
+        }
+
+        #[test]
+        fn mermaid_diagram_swap_keeps_a_pinned_stream_at_the_bottom() {
+            with_window(|transcript, window, cx| {
+                let intro = "A paragraph that explains the result in detail. ".repeat(12);
+                let reply = |status, tail: &str| {
+                    let mut text = String::new();
+                    for section in 0..8 {
+                        text.push_str(&format!("Section {section}. {intro}\n\n"));
+                    }
+                    text.push_str(MERMAID_FENCE);
+                    text.push_str(tail);
+                    vec![
+                        prompt("prompt"),
+                        assistant("reply", status, vec![text_part("text", &text)]),
+                    ]
+                };
+                transcript.update(cx, |this, cx| {
+                    this.rail_enabled = false;
+                    feed(
+                        this,
+                        reply(MessageStatus::Streaming, "\nAfter the diagram."),
+                        cx,
+                    )
+                });
+                for _ in 0..50 {
+                    tick(&transcript, window, cx);
+                }
+                let this = transcript.read(cx);
+                assert!(this.pinned);
+                assert!(
+                    this.list.max_offset_for_scrollbar().y > px(100.0),
+                    "must overflow"
+                );
+                assert!(this.distance_from_bottom() <= 1.0);
+                assert!(render_next_diagram(&transcript, cx));
+                for _ in 0..50 {
+                    tick(&transcript, window, cx);
+                }
+                let this = transcript.read(cx);
+                assert!(this.pinned, "a diagram swap is not user input");
+                assert!(this.distance_from_bottom() <= 1.0, "pin follows the swap");
+                // More streaming after the swap keeps following.
+                transcript.update(cx, |this, cx| {
+                    feed(
+                        this,
+                        reply(
+                            MessageStatus::Streaming,
+                            &format!("\nAfter the diagram.\n\n{intro}\n\n{intro}"),
+                        ),
+                        cx,
+                    )
+                });
+                for _ in 0..50 {
+                    tick(&transcript, window, cx);
+                }
+                let this = transcript.read(cx);
+                assert!(this.pinned);
+                assert!(this.distance_from_bottom() <= 1.0);
+                assert!(this.diagrams.borrow_mut().next_job().is_none());
+            });
+        }
+
+        #[test]
+        fn mermaid_completion_renders_the_tail_without_moving_the_runway_prompt() {
+            with_window(|transcript, window, cx| {
+                transcript.update(cx, |this, cx| {
+                    feed(this, vec![prompt("prompt")], cx);
+                    this.rail_enabled = false;
+                });
+                draw(window, cx);
+                transcript.update(cx, |this, cx| {
+                    this.on_own_send("chat".into(), "prompt".into(), cx)
+                });
+                draw(window, cx);
+                for _ in 0..80 {
+                    tick(&transcript, window, cx);
+                }
+                let reply = |status| {
+                    vec![
+                        prompt("prompt"),
+                        assistant(
+                            "reply",
+                            status,
+                            vec![text_part(
+                                "text",
+                                &format!("Here it is:\n\n{MERMAID_FENCE}"),
+                            )],
+                        ),
+                    ]
+                };
+                transcript.update(cx, |this, cx| {
+                    feed(this, reply(MessageStatus::Streaming), cx)
+                });
+                for _ in 0..50 {
+                    tick(&transcript, window, cx);
+                }
+                assert!(transcript.read(cx).diagram_worker.is_none());
+                transcript.update(cx, |this, cx| {
+                    feed(this, reply(MessageStatus::Complete), cx)
+                });
+                for _ in 0..50 {
+                    tick(&transcript, window, cx);
+                }
+                let prompt_top = |cx: &gpui::App| {
+                    let this = transcript.read(cx);
+                    assert!(this.own_turn.is_some(), "a short reply keeps its runway");
+                    this.list.bounds_for_item(0).unwrap().top()
+                };
+                let before = prompt_top(cx);
+                assert!(render_next_diagram(&transcript, cx));
+                // No controller tick between the swap and this paint.
+                draw(window, cx);
+                assert_eq!(prompt_top(cx), before, "the diagram swap moved the prompt");
+                let this = transcript.read(cx);
+                assert!(
+                    this.list.max_offset_for_scrollbar().y <= px(2.5),
+                    "the swap opened blank space below the runway"
+                );
+                for _ in 0..50 {
+                    tick(&transcript, window, cx);
+                }
+                assert_eq!(prompt_top(cx), before);
+
+                // The lightbox frames an enlarged raster by the diagram's
+                // natural size and releases it on close.
+                let media = transcript
+                    .read(cx)
+                    .diagrams
+                    .borrow()
+                    .ready_media()
+                    .expect("rendered diagram");
+                cx.update_window(window.into(), |_, window, cx| {
+                    transcript.update(cx, |this, cx| {
+                        this.open_diagram_preview(media.clone(), window, cx)
+                    });
+                })
+                .unwrap();
+                draw(window, cx);
+                transcript.update(cx, |this, cx| {
+                    assert!(this.attachment_preview.is_some());
+                    assert!(this.diagram_zoom.is_some());
+                    this.close_diagram_zoom(cx);
+                    assert!(this.attachment_preview.is_none());
+                    assert!(this.diagram_zoom.is_none());
+                });
+                draw(window, cx);
+            });
+        }
+
         #[test]
         fn send_glide_never_crosses_the_prompt_during_remeasurement() {
             with_window(|transcript, window, cx| {
diff --git a/docs/markdown-preview.md b/docs/markdown-preview.md
index b6662e958a..246b35d48d 100644
--- a/docs/markdown-preview.md
+++ b/docs/markdown-preview.md
@@ -10,10 +10,12 @@ Task lists use the existing GPUI base checkbox with Zeron theme colors and icons
 
 Hovering a Markdown block exposes the same add-comment button used in diffs. The shared inline draft and comment cards appear below the block across the full preview panel width, with their location, input, text and actions aligned to the centered reading column. Each card retains its original file and line reference. Comments use the existing file-review staging, removal and editor anchors; they join the composer without modifying the Markdown. A paragraph, list, table or fence is one comment target, cited at its first source line. Existing notes on inner lines appear below their containing block. Cancel or Escape dismisses the draft. Truncated and non-editable previews cannot start comments, and stale preview offsets are rejected.
 
-Workspace-relative images are loaded from the device owning the checkout. HTTP(S) images remain links. HTML and MDX are not executed. Images and diagrams open in the shared centered lightbox with trackpad pinch, Ctrl + wheel zoom and pan; see [image preview and zoom](image-preview.md). Mermaid in chat is not enabled by this change.
+Workspace-relative images are loaded from the device owning the checkout. HTTP(S) images remain links. HTML and MDX are not executed. Images and diagrams open in the shared centered lightbox with trackpad pinch, Ctrl + wheel zoom and pan; see [image preview and zoom](image-preview.md). Chat renders Mermaid with the same engine; see [Mermaid in chat](#mermaid-in-chat).
 
 Mermaid diagrams use the same fence frame, header metrics, border, background and code actions as ordinary fenced code blocks. Switching between diagram and source replaces the body inside that single frame.
 
+Diagrams are drawn in Zeron's own style rather than the engine's stock theme. The canvas is transparent, so the diagram sits directly on the fence body under any surface treatment. Nodes are cards with 8px corners and a hairline border: white in light mode, one ink step above the fence in dark mode. Groups are a faint wash. Edge and group labels use muted text, and connectors use faint text. Decisions, sequence notes and activations carry a soft tint of the selected accent, and Gantt bars derive their hues from it. Gantt gridlines use the theme border. Colors set explicitly with `style` or `classDef` are kept. The layout uses tighter node and rank spacing than the engine default, so diagrams scaled to the reading column keep larger labels. In the lightbox, the diagram is drawn on a rounded plate in the fence body color so it remains legible over the scrim.
+
 Source fences use the same interaction model as chat code blocks: long lines have an independent horizontal scroll plane and a hover scrollbar, Copy changes to a transient `Copied` confirmation, and the Fit content control wraps lines to the available width. The Fit content choice is the same device-level persisted setting used by chat, so changing it in either surface updates both; horizontal offsets remain local to each fence.
 
 ## Mermaid engine decision
@@ -32,12 +34,22 @@ Preview parsing is debounced by 120ms and limited to the first 2 MiB of Markdown
 
 Source revisions reject obsolete async results. Image watcher events invalidate both completed and pending loads; changing theme regenerates diagrams. Switching back to Code releases the preview's derived state while preserving the editor and preview scroll position. Closing a preview schedules image asset and atlas eviction. Image/diagram completion remeasures rows with an absolute scroll anchor.
 
-Image reads are limited to 8 MiB, with 384 KiB binary chunks and content-hash validation between chunks. Raster images are decoded with 4096px dimension and 64 MiB allocation limits, then flattened to a static PNG, including the first frame of animations. SVG sources are parsed and reserialized with embedded/external image resolution disabled; the prepared vector source is retained (up to 8 MiB) regardless of its natural dimensions. A bounded outer SVG viewport preserves the complete original coordinate system. Preview rasters adapt to the panel and display density (up to 4×), capped at 1,048,576 pixels and 4096 pixels per side. The lightbox uses its own viewport and up to 2,097,152 pixels within the remaining document memory budget, reusing the preview when there is no room for another raster. CPU pixels, GPU textures and retained SVG bytes are budgeted. Enlarged variants are evicted on close, replacement, source changes and preview disposal. Unsupported SVG content may be omitted.
+Image reads are limited to 8 MiB, with 384 KiB binary chunks and content-hash validation between chunks. Raster images are decoded with 4096px dimension and 64 MiB allocation limits, then flattened to a static PNG, including the first frame of animations. SVG sources are parsed and reserialized with embedded/external image resolution disabled; the prepared vector source is retained (up to 8 MiB) regardless of its natural dimensions. A bounded outer SVG viewport preserves the complete original coordinate system. Preview rasters adapt to the panel and display density (up to 4×), capped at 1,048,576 pixels and 4096 pixels per side. The lightbox uses its own viewport and up to 2,097,152 pixels within the remaining document memory budget, reusing the preview when there is no room for another raster. CPU pixels, GPU textures and retained SVG bytes are budgeted. An SVG or diagram is accounted at the raster it currently holds, not the largest raster any view could request. A re-raster at a higher width or density happens only when the larger variant fits the remaining budget; otherwise the current raster stays. Enlarged variants are evicted on close, replacement, source changes and preview disposal. Unsupported SVG content may be omitted.
 
 Mermaid source is limited to 16 KiB, 256 lines and 2048 lexical segments; generated SVG is limited to 2 MiB. The native engine has no cooperative cancellation or hard execution deadline. Its CPU work is serialized across previews and runs off the UI thread; obsolete results must be rejected by their owning view. These limits bound admitted work but do not constitute a strict wall-clock guarantee.
 
 Manual validation on macOS and a second physical remote device must be recorded separately from headless Linux tests. Automated tests cannot establish platform-specific focus, GPU rendering or real network behavior by themselves.
 
+## Mermaid in chat
+
+Assistant replies render ```` ```mermaid ```` fences as diagrams, sharing the file preview's engine, fence frame, source toggle, Copy action and lightbox. Inline images in chat keep their existing text rendering.
+
+Streaming never renders a fence that may still be growing. Only blocks that a later row of the same reply follows, or blocks of a completed reply, request a diagram. The streaming tail keeps its source; per-token commits start no render work. Until a diagram is ready, the fence shows its ordinary source, so completion changes the row height at most once. A failed render keeps the source and shows the engine's diagnostic in a warning marker in the fence header.
+
+Rows request their fences while they lay out, so only painted diagrams cost anything. One serialized loop per transcript renders them off the UI thread, choosing its next source between renders and dropping requests whose rows scrolled away. Retained diagrams share a 64 MiB budget and are evicted least recently painted first, with a 64-entry cap; an evicted diagram renders again when its row returns. Diagrams painted in the latest two passes are never evicted. Theme changes discard every diagram, and results computed under the previous theme are rejected. Rasters follow the conversation column width and display density, under the same budget check before a larger re-raster.
+
+A diagram swap remeasures only the rows painting it and uses the same layout signals as other row-height changes. The bottom pin glides to the new end, and the own-turn runway reservation absorbs the change in the same layout without moving the sent prompt. Source toggles keep the stable row identity across streaming completion. The lightbox enlarges the diagram within the memory the retained diagrams leave available and releases that raster when it closes.
+
 ## Implementation validation
 
 The implementation was checked on Linux with the following commands:
@@ -58,3 +70,11 @@ Formatting checks pass for all changed Rust files, and `git diff --check` passes
 ### Browser link follow-up
 
 The file preview's session Browser routing was checked on Linux with `cargo test -p zeron-ui -- --test-threads=1` (918 passed), `cargo build -p zeron`, Rustfmt for changed modules, and `git diff --check`. New tests cover the preview-to-Files event, source-session ownership, complete destinations and clipboard content, rejected URLs, mail handling, preview suspension, and the Shell subscriptions for both Files and standalone file tabs. The first parallel suite run failed the existing `active_reply_text_selection_survives_streaming_and_completion` test; it passed in isolation and in the complete sequential run. This follow-up did not repeat native visual verification on Linux or macOS.
+
+### Mermaid in chat follow-up
+
+Chat Mermaid rendering was checked on Linux with `cargo test -p zeron-ui --lib -- --test-threads=1` (1528 passed), `cargo check -p zeron`, Rustfmt for changed modules and `git diff --check`. Cache unit tests cover single queueing per source, row tracking, dropping requests that scrolled away, theme invalidation of retained and in-flight results, eviction ordering that spares recently painted diagrams, and source toggles following their rows. Transcript tests stream a fence token by token and verify that the tail starts no render. They also verify that the following block renders it once, that the row height changes and the toggle restores the source, and that completion keeps the diagram and toggle. Other transcript tests check that a pinned overflowing stream stays at the bottom through the swap and further streaming. They also check that rendering a completed tail neither moves the own-turn prompt nor opens blank space below the runway, and that the diagram lightbox opens and releases its raster. In one parallel suite run, the existing `markdown_drag_tracks_each_table_column_and_wrapped_cell` and `rendered_truncation_resizes_and_selects_the_original_url` tests failed. Both passed in isolation and in the complete sequential run. Native visual verification on Linux or macOS was not performed.
+
+### Diagram style follow-up
+
+The Zeron diagram style was checked with `cargo test -p zeron-ui --lib -- --test-threads=1` (1531 passed), Rustfmt for changed modules and Clippy, which reports no new warnings in changed code. New unit tests cover the transparent canvas, rounded node corners, accent-tinted default decisions alongside an explicitly styled one that keeps its colors, themed Gantt gridlines, and diagram type detection past front matter and comments. The six-fixture corpus was rendered with `ZERON_MERMAID_ARTIFACTS` in light, dark and Geist Mono variants. It was composited onto the fence body color at the chat column size and inspected visually. Native visual verification in the running application was not performed.

From dbb639be372157a66603e2f0462d3702d3d33503 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Mon, 5 Oct 2026 00:44:41 -0700
Subject: [PATCH 46/74] Group projects by git identity, plus Zeron Icons and
 rolling labels (#799)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Group projects by git identity and pick the project before the device

Each git project now carries a repository id stamped by its owning engine:
the normalized origin remote (host/owner/repo), else a device-scoped hash of
the common git dir so remote-less worktrees still match. Clones and
worktrees of one repository share it across devices.

- Sidebar project mode folds projects with the same id into one group,
  named and iconed by the oldest checkout; the project icon moves to the
  group header and its rows drop theirs.
- Every checkout of a repository shares one project icon and color, on
  desktop and mobile.
- The new-session composer picks the project first (one row per
  repository across devices), then the device among its checkouts;
  project-less sessions still pick any device.
- iOS: the project menu lists one entry per repository with its hosts, and
  the host chip picks the checkout. The demo workspace gains a clone on a
  second device.

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

* Adopt Zeron Icons in the shell

Swap the shell's glyphs for icons.zeron.sh: carets, back/forward arrows,
plus, folder, branch, pull request, expand/collapse and file tree, plus new
fork and worktree glyphs (fork buttons no longer borrow the branch icon;
worktree rows no longer borrow folder-with-files).

The sidebar and right-pane toggles draw the Sidebar glyph from quads so its
panel can morph open <-> closed (280ms, cubic-bezier(.22, 1, .36, 1)). The
morph rides a new per-key state tween in motion.rs on the hover-fade clock:
it snaps on mount and reverses continuously mid-flight.

The sidebar project selector drops its caret.

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

* Keep composer chips steady across project switches

Switching projects reset every picker slot, so the model chip blanked and
the branch/checkout chips read "Select ref" until the reloads landed.

- Model catalogs are per device: a same-device project switch keeps them,
  and a device switch revalidates with the loaded rows still on screen
  (stale slots reload once through the engine's cache).
- The checkout and branch chip labels hold the previous project's ref until
  the new refs land; the branch popover and the send plan never read it.

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

* Roll label changes like Scritto's text

New roll_text element (a port of scrit.to's <scritto-text> roll): when a
keyed label changes, shared leading/trailing runs hold (the tail slides to
its new x) while the changed middle rolls — old glyphs rise out and shrink
as new ones rise in, staggered left to right on cubic-bezier(.22,1,.36,1),
with the width gliding between the two values.

Steady state hands back to the plain truncating label, invisibly: the line
height, baseline, glyph y-offsets and ceil'd width match gpui's own text
element, glyph sizes quantize to 1/8 px, and the width/tail ride the shell's
200ms RESIZE clock so whatever follows the label (the model chip's effort
text) settles early and never moves while glyphs finish. No overshoot —
labels land dead still. Reduced motion renders plain text.

Applied to the composer's model/project/device trigger chips and their
suffixes, the branch/checkout footer chips, the compact picker's effort
title (it retitles live while the slider drags), and the working trailer's
flavour word and elapsed timer (digits roll in place, the unit holds).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Stabilize the compact sidebar row's trailing cluster

The trailing items packed right in presence-dependent order, so the remote
globe and time columns shifted between rows with and without a PR badge,
and the hover archive affordance appeared in previously-empty space.

Now the PR badge sits LEFT of one fixed slot (30px x 14px; wider only for a
long jump hint) that shows the relative time, swaps in place to the archive
glyph while the row is hovered, and shows the Cmd+N jump legend while the
modifier is held — the legend beats the hover archive. The remote globe is
gone from compact rows. Columns land at the same x on every row and nothing
resizes on hover.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Keep the model chip's effort text muted at every level

It brightened whenever the pick departed from the model's default; the
effort now always reads in the chip's muted second tone. The default level
is still marked inside the model menu.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Blur and tilt rolling glyphs like Scritto

Rolling glyphs now carry Scritto's 0.1em blur and 2deg tilt, both fading
as each glyph lands, and scale on the GPU from one full-size raster
(paint_glyph_transformed) instead of re-rasterizing at quantized sizes.
Glyphs at rest — the shared runs and the sliding tail — still paint
through the ordinary pipeline, so the hand-off to the plain label stays
pixel-identical.

LOCAL ONLY: Cargo.toml [patch]es zui to ../zui-edgefade (branch
glyph-transform-blur, 0966d06) for paint_glyph_transformed. Before
pushing, push that branch, repin the zui rev here, drop the [patch], and
bump the gpui-component pin alongside.

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

* Pin zui 0966d06 for transformed and blurred glyphs

zui main now carries paint_glyph_transformed (zeronsh/zui 0966d06), so the
local [patch] onto ../zui-edgefade from the previous commit goes away. The
gpui-component pin moves with it (fix/zui-1561532 4764fd0) so Cargo.lock
keeps a single gpui.

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

* Identify repositories by their trunk's root commit

The identity was the normalized origin remote, so one repository split
into several projects whenever checkouts spelled their remote differently:
a pre-rename name kept alive by GitHub's redirect (zeronsh/comet-native vs
zeronsh/zeron), an SSH host alias (github-winglee vs github.com), or a
transferred owner.

It is now commit:<sha> of HEAD's first-parent root — the commit the trunk
grew from. Clones, worktrees and forks share it regardless of remote, and
a merged-in unrelated history (a second parent) never displaces it. A
shallow clone (whose boundary commits only look parentless) or an unborn
HEAD falls back to the normalized remote, then to the device-scoped
common-git-dir hash as before. Readers treat the id as opaque, so nothing
else changes; the scheme is unreleased, so no engine has stamped old ids.

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

* Return the compact model list to provider tabs

Restores the list page from the picker's original design (d56d83ba): a
back button beside the providers as tabs — Starred first, then each
provider's run of the list — over the search row. A tab jumps the list to
its group, the group at the top of the scroll lights its tab, the strip
keeps the viewed tab in sight and fades at both edges over tabs scrolled
past them, and the list opens on the current model's group.

The tabs and back button are row-height squares with the rows' corners,
inset 4pt from the card like the list and panel. The separate provider
page and the panel's provider button are gone (Tab on the panel still
cycles providers); browsing every provider's models (#749) is unchanged.

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

* Address adversarial review: catalogs, subfolders, frame rate, "+" target

- Device switch: a catalog still holding the previous device's models no
  longer resolves a send (only the explicit or remembered model and
  effort go out), stays marked stale until the new device answers, and a
  failed reload replaces those rows instead of retaining them.
- Repository identity carries the folder's path inside the repository, so
  monorepo siblings and plain folders inside an enclosing repo stay
  separate projects; the same subfolder still matches across clones. A
  failed identity check keeps the space's last id instead of flipping
  forms, and the trunk-root walk is cached per HEAD commit.
- Rolling text renews the shared ~30Hz pulse lease instead of requesting
  display-rate frames (the working timer rolled for most of every turn).
- The working trailer's word and timer key their rolls by turn, so a new
  turn starts fresh; the roll memory is bounded.
- The project group's "+" opens on this device's checkout first instead
  of the oldest one anywhere.

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

* Address adversarial review round 2

- A harness list still from the previous device stays marked stale until
  the new device answers (one in-flight reload) and reads as not loaded,
  so neither the chip nor a send falls back to a harness only the old
  device offered. The chip's effort is unclamped while the model slot is
  stale, matching what a send carries.
- Reduced motion switching on mid-roll settles the label at once instead
  of leaving the roll frozen with no frames to finish it.
- The working trailer's "Sending" bridge keys its own roll, so it never
  rolls out of the previous turn's last flavour word.

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

* Address adversarial review round 3

- A stale harness list counts as catalog loading, so with no picked or
  remembered harness the model chip shows its loading state across a
  device switch instead of going blank.
- The working trailer's sending bridge keys its roll on its own send
  start, so it never rolls out of the previous turn's word or an earlier
  send's "Queued" line.

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

* Don't report "No agents available" from a stale harness list

The previous device's list can't say this one has no agents; during a
device switch the chip shows its loading state instead.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 ARCHITECTURE.md                               |   2 +-
 Cargo.lock                                    |  44 +-
 Cargo.toml                                    |   8 +-
 apps/ios/Zeron/App/AppModel.swift             |   2 +-
 .../ios/Zeron/Core/Generated/zeron_core.swift |  20 +
 .../Session/NewSessionViewController.swift    |  79 +-
 apps/ios/ZeronUITests/SessionFlowTests.swift  |  30 +
 crates/client/src/client.rs                   |   1 +
 crates/client/src/demo/fixtures.rs            |  27 +-
 crates/client/src/workspace/view.rs           |  22 +-
 crates/client/tests/demo.rs                   |   8 +
 crates/client/tests/live.rs                   |   1 +
 crates/doc/src/registry.rs                    |   4 +
 crates/doc/src/registry/tests.rs              |  17 +-
 crates/doc/src/workspace.rs                   |  25 +-
 crates/engine/src/repos.rs                    | 156 ++++
 crates/engine/src/spaces.rs                   |  36 +-
 crates/engine/src/workspace_host.rs           |   8 +-
 .../engine/tests/m5_repos_diffs_terminals.rs  | 149 +++
 crates/engine/tests/workspace_sync.rs         |   1 +
 crates/mcp/src/zeron.rs                       |   1 +
 crates/mobile/src/client_ffi/types.rs         |   6 +
 crates/proto/src/entities.rs                  |   8 +
 crates/proto/src/view.rs                      |  58 ++
 crates/ui/assets/icons/alt-arrow-down.svg     |   2 +-
 crates/ui/assets/icons/alt-arrow-left.svg     |   2 +-
 crates/ui/assets/icons/alt-arrow-right.svg    |   2 +-
 crates/ui/assets/icons/alt-arrow-up.svg       |   2 +-
 crates/ui/assets/icons/arrow-left.svg         |   2 +-
 crates/ui/assets/icons/arrow-right.svg        |   2 +-
 crates/ui/assets/icons/collapse-arrows.svg    |   2 +-
 crates/ui/assets/icons/expand-arrows.svg      |   2 +-
 crates/ui/assets/icons/file-tree.svg          |   8 +-
 crates/ui/assets/icons/folder.svg             |   2 +-
 crates/ui/assets/icons/fork.svg               |   1 +
 crates/ui/assets/icons/git-branch.svg         |   8 +-
 crates/ui/assets/icons/plus.svg               |   2 +-
 crates/ui/assets/icons/pull-request.svg       |   8 +-
 .../icons/sidebar-minimalistic-left.svg       |   1 -
 .../ui/assets/icons/sidebar-minimalistic.svg  |   1 -
 crates/ui/assets/icons/worktree.svg           |   1 +
 .../ui/examples/project-selector-fixture.rs   |   8 +-
 crates/ui/examples/sidebar-fixture.rs         |  16 +-
 crates/ui/src/change_requests.rs              |   1 +
 crates/ui/src/files/sections.rs               |   4 +-
 crates/ui/src/icons.rs                        |  78 +-
 crates/ui/src/lib.rs                          |   1 +
 crates/ui/src/motion.rs                       | 157 ++++
 crates/ui/src/pickers.rs                      | 881 ++++++++++++++----
 crates/ui/src/pickers/compact.rs              | 433 ++++-----
 crates/ui/src/roll_text.rs                    | 504 ++++++++++
 crates/ui/src/shell.rs                        | 172 +++-
 crates/ui/src/shell/command_palette.rs        |   1 +
 crates/ui/src/shell/project_icon.rs           |  80 +-
 crates/ui/src/shell/spaces.rs                 | 195 +++-
 crates/ui/src/shell/tabs.rs                   |  17 +-
 crates/ui/src/state.rs                        |  49 +-
 crates/ui/src/transcript.rs                   |  45 +-
 58 files changed, 2702 insertions(+), 701 deletions(-)
 create mode 100644 crates/ui/assets/icons/fork.svg
 delete mode 100644 crates/ui/assets/icons/sidebar-minimalistic-left.svg
 delete mode 100644 crates/ui/assets/icons/sidebar-minimalistic.svg
 create mode 100644 crates/ui/assets/icons/worktree.svg
 create mode 100644 crates/ui/src/roll_text.rs

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index e1fa1c6223..4bc2cc40db 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -104,7 +104,7 @@ Two persistent doc kinds. When sync is enabled, session docs ride the chat2 row
    run journal), tail/diff sidecars. Constants carried over (`STREAM_COMMIT_MS=120`,
    `DO_FLUSH_MS=5s`, compaction at 8MB, retain 30d, tail 64).
 
-2. **Workspace registry doc** (per profile) — the `registry1` snapshot stores spaces (id, deviceId, path, name?, gitDetected, checkoutId), the chats index (id, deviceId, title, archived, cwd, branch, checkoutId, spaceId, lastSeenAt, lastMessagePreview/At, config), devices, session-status rows, and checkout-diff summary pointers. A space is a device+folder pair in the active profile; the owning device's `SpacesSync` stamps git presence so branch pickers and the diff sidebar can gate without another RPC. Local scope keeps the registry entirely in its profile store. Synced and development scopes join `/registry/{orgId}/ws`, backed by the private per-user room `reg1/{orgId}/{userId}`; rows are never visible to every member of an organization.
+2. **Workspace registry doc** (per profile) — the `registry1` snapshot stores spaces (id, deviceId, path, name?, gitDetected, checkoutId, repositoryId), the chats index (id, deviceId, title, archived, cwd, branch, checkoutId, spaceId, lastSeenAt, lastMessagePreview/At, config), devices, session-status rows, and checkout-diff summary pointers. A space is a device+folder pair in the active profile; the owning device's `SpacesSync` stamps git presence so branch pickers and the diff sidebar can gate without another RPC, plus a repository identity (the trunk's root commit, so renames, transfers and remote spellings don't split a repository; a shallow or empty history falls back to the normalized origin remote, then a device-scoped common-git-dir hash) that groups clones and worktrees of one repository in the sidebar's project mode. Local scope keeps the registry entirely in its profile store. Synced and development scopes join `/registry/{orgId}/ws`, backed by the private per-user room `reg1/{orgId}/{userId}`; rows are never visible to every member of an organization.
 
    Writer discipline: each device writes its own device and session-status rows, rows for chats it hosts, and git stamps for spaces it owns. Creates, renames, archives, and seen marks are LWW sets accepted from any device. `deleteSpace` tombstones the space and every chat/session row in it in one commit. Presence uses ephemeral room frames rather than durable heartbeat writes.
 
diff --git a/Cargo.lock b/Cargo.lock
index d8d345cb28..47644e8e73 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -943,7 +943,7 @@ dependencies = [
  "bitflags 2.13.1",
  "cexpr",
  "clang-sys",
- "itertools 0.10.5",
+ "itertools 0.11.0",
  "log",
  "prettyplease",
  "proc-macro2",
@@ -1599,7 +1599,7 @@ dependencies = [
 [[package]]
 name = "collections"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "gpui_util",
  "indexmap",
@@ -2367,7 +2367,7 @@ dependencies = [
 [[package]]
 name = "derive_refineable"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3582,7 +3582,7 @@ dependencies = [
 [[package]]
 name = "gpui"
 version = "0.2.2"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "accesskit",
  "anyhow",
@@ -3668,7 +3668,7 @@ dependencies = [
 [[package]]
 name = "gpui-base"
 version = "0.5.2"
-source = "git+https://github.com/zeronsh/gpui-component?rev=2f73e5c2bc03d6768cb5fcc92442c4cf4b963b70#2f73e5c2bc03d6768cb5fcc92442c4cf4b963b70"
+source = "git+https://github.com/zeronsh/gpui-component?rev=4764fd002ab5894ec9413511d01d37481b2129ab#4764fd002ab5894ec9413511d01d37481b2129ab"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3698,7 +3698,7 @@ dependencies = [
 [[package]]
 name = "gpui_linux"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "accesskit",
  "accesskit_unix",
@@ -3750,7 +3750,7 @@ dependencies = [
 [[package]]
 name = "gpui_macos"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "accesskit",
  "accesskit_macos",
@@ -3799,7 +3799,7 @@ dependencies = [
 [[package]]
 name = "gpui_macros"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -3810,7 +3810,7 @@ dependencies = [
 [[package]]
 name = "gpui_platform"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "console_error_panic_hook",
  "gpui",
@@ -3823,7 +3823,7 @@ dependencies = [
 [[package]]
 name = "gpui_shared_string"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "schemars",
  "serde",
@@ -3833,7 +3833,7 @@ dependencies = [
 [[package]]
 name = "gpui_tokio"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
  "gpui",
@@ -3844,7 +3844,7 @@ dependencies = [
 [[package]]
 name = "gpui_util"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
  "log",
@@ -3854,7 +3854,7 @@ dependencies = [
 [[package]]
 name = "gpui_web"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -3878,7 +3878,7 @@ dependencies = [
 [[package]]
 name = "gpui_wgpu"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
  "bytemuck",
@@ -3907,7 +3907,7 @@ dependencies = [
 [[package]]
 name = "gpui_windows"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "accesskit",
  "accesskit_windows",
@@ -4251,7 +4251,7 @@ dependencies = [
 [[package]]
 name = "http_client"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
  "async-compression",
@@ -5462,7 +5462,7 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 [[package]]
 name = "media"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
  "bindgen",
@@ -6835,7 +6835,7 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "perf"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "collections",
  "serde",
@@ -7949,7 +7949,7 @@ dependencies = [
 [[package]]
 name = "refineable"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "derive_refineable",
 ]
@@ -8670,7 +8670,7 @@ dependencies = [
 [[package]]
 name = "scheduler"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "async-task",
  "backtrace",
@@ -9507,7 +9507,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "sum_tree"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "heapless 0.9.3",
  "log",
@@ -11018,7 +11018,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 [[package]]
 name = "util_macros"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=667d0aaf9531d2d1b2d0674a5e55f977df1b09f6#667d0aaf9531d2d1b2d0674a5e55f977df1b09f6"
+source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "perf",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 5d25994ffe..adfb758350 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -77,15 +77,15 @@ loro-protocol = "0.3"
 # Linux — the Metal path's snapshot/blur/composite, ported).
 # Paint-time rounded image masks (#9), bounded Windows backdrop blur and
 # translucent compositing, plus blur-aware scene batching (#10).
-gpui = { git = "https://github.com/zeronsh/zui", rev = "667d0aaf9531d2d1b2d0674a5e55f977df1b09f6" }
-gpui_platform = { git = "https://github.com/zeronsh/zui", rev = "667d0aaf9531d2d1b2d0674a5e55f977df1b09f6", features = [
+gpui = { git = "https://github.com/zeronsh/zui", rev = "0966d065b23e0b7c9b53c2e186705b8bce16fe2d" }
+gpui_platform = { git = "https://github.com/zeronsh/zui", rev = "0966d065b23e0b7c9b53c2e186705b8bce16fe2d", features = [
     "wayland",
     "x11",
     "font-kit",
     "runtime_shaders",
 ] }
-gpui_tokio = { git = "https://github.com/zeronsh/zui", rev = "667d0aaf9531d2d1b2d0674a5e55f977df1b09f6" }
-gpui-base = { git = "https://github.com/zeronsh/gpui-component", rev = "2f73e5c2bc03d6768cb5fcc92442c4cf4b963b70" }
+gpui_tokio = { git = "https://github.com/zeronsh/zui", rev = "0966d065b23e0b7c9b53c2e186705b8bce16fe2d" }
+gpui-base = { git = "https://github.com/zeronsh/gpui-component", rev = "4764fd002ab5894ec9413511d01d37481b2129ab" }
 
 # diffs
 similar = "2"
diff --git a/apps/ios/Zeron/App/AppModel.swift b/apps/ios/Zeron/App/AppModel.swift
index fb9d8515c2..2809bc8793 100644
--- a/apps/ios/Zeron/App/AppModel.swift
+++ b/apps/ios/Zeron/App/AppModel.swift
@@ -476,7 +476,7 @@ final class AppModel {
     }
 
     var projectOptions: [ProjectOption] {
-        rawProjects.map { ProjectOption(id: $0.id, name: $0.name, device: $0.deviceId, deviceName: $0.deviceName ?? deviceName($0.deviceId), online: $0.deviceOnline, git: $0.gitDetected, colorIndex: Int($0.colorIndex)) }
+        rawProjects.map { ProjectOption(id: $0.id, name: $0.name, path: $0.path, device: $0.deviceId, deviceName: $0.deviceName ?? deviceName($0.deviceId), online: $0.deviceOnline, git: $0.gitDetected, groupKey: $0.groupKey, groupName: $0.groupName, colorIndex: Int($0.colorIndex)) }
     }
 
     var hostOptions: [HostOption] {
diff --git a/apps/ios/Zeron/Core/Generated/zeron_core.swift b/apps/ios/Zeron/Core/Generated/zeron_core.swift
index 2a750518a6..a8d2fe3ff8 100644
--- a/apps/ios/Zeron/Core/Generated/zeron_core.swift
+++ b/apps/ios/Zeron/Core/Generated/zeron_core.swift
@@ -6237,6 +6237,14 @@ public struct ProjectView: Equatable, Hashable {
     public var deviceOnline: Bool
     public var gitDetected: Bool
     public var createdAtMs: Int64
+    /**
+     * Shared by every checkout of one repository, on any device.
+     */
+    public var groupKey: String
+    /**
+     * The repository group's name, shared like `color_index`.
+     */
+    public var groupName: String
     /**
      * Most urgent indicator among its active sessions.
      */
@@ -6250,6 +6258,12 @@ public struct ProjectView: Equatable, Hashable {
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(id: String, name: String, path: String, colorIndex: UInt32, deviceId: String, deviceName: String?, deviceOnline: Bool, gitDetected: Bool, createdAtMs: Int64, 
+        /**
+         * Shared by every checkout of one repository, on any device.
+         */groupKey: String, 
+        /**
+         * The repository group's name, shared like `color_index`.
+         */groupName: String, 
         /**
          * Most urgent indicator among its active sessions.
          */indicator: ChatIndicator, unseenCount: UInt32, 
@@ -6265,6 +6279,8 @@ public struct ProjectView: Equatable, Hashable {
         self.deviceOnline = deviceOnline
         self.gitDetected = gitDetected
         self.createdAtMs = createdAtMs
+        self.groupKey = groupKey
+        self.groupName = groupName
         self.indicator = indicator
         self.unseenCount = unseenCount
         self.sessions = sessions
@@ -6295,6 +6311,8 @@ public struct FfiConverterTypeProjectView: FfiConverterRustBuffer {
                 deviceOnline: FfiConverterBool.read(from: &buf), 
                 gitDetected: FfiConverterBool.read(from: &buf), 
                 createdAtMs: FfiConverterInt64.read(from: &buf), 
+                groupKey: FfiConverterString.read(from: &buf), 
+                groupName: FfiConverterString.read(from: &buf), 
                 indicator: FfiConverterTypeChatIndicator.read(from: &buf), 
                 unseenCount: FfiConverterUInt32.read(from: &buf), 
                 sessions: FfiConverterSequenceTypeSessionRow.read(from: &buf)
@@ -6311,6 +6329,8 @@ public struct FfiConverterTypeProjectView: FfiConverterRustBuffer {
         FfiConverterBool.write(value.deviceOnline, into: &buf)
         FfiConverterBool.write(value.gitDetected, into: &buf)
         FfiConverterInt64.write(value.createdAtMs, into: &buf)
+        FfiConverterString.write(value.groupKey, into: &buf)
+        FfiConverterString.write(value.groupName, into: &buf)
         FfiConverterTypeChatIndicator.write(value.indicator, into: &buf)
         FfiConverterUInt32.write(value.unseenCount, into: &buf)
         FfiConverterSequenceTypeSessionRow.write(value.sessions, into: &buf)
diff --git a/apps/ios/Zeron/Session/NewSessionViewController.swift b/apps/ios/Zeron/Session/NewSessionViewController.swift
index c306b4c1b3..809575e882 100644
--- a/apps/ios/Zeron/Session/NewSessionViewController.swift
+++ b/apps/ios/Zeron/Session/NewSessionViewController.swift
@@ -16,11 +16,16 @@ struct NewSessionDraft: Equatable, Codable {
 struct ProjectOption: Equatable {
     let id: String
     let name: String
+    let path: String
     let device: String
     /// Display name of `device` (never show the id).
     let deviceName: String
     let online: Bool
     let git: Bool
+    /// Shared by every checkout of one repository, on any device; with
+    /// `groupName` and `colorIndex` they read as one project.
+    let groupKey: String
+    let groupName: String
     let colorIndex: Int
 }
 
@@ -231,10 +236,20 @@ final class NewSessionViewController: UIViewController, UIGestureRecognizerDeleg
     private var project: ProjectOption? { app.projectOptions.first { $0.id == draft.projectId } }
     private var deviceId: String { project?.device ?? draft.hostId ?? "" }
 
+    /// Checkouts of the picked project, one per row of the host menu.
+    private var checkouts: [ProjectOption] {
+        guard let p = project else { return [] }
+        return app.projectOptions
+            .filter { $0.groupKey == p.groupKey }
+            .sorted { ($0.deviceName.lowercased(), $0.path) < ($1.deviceName.lowercased(), $1.path) }
+    }
+
     private func refreshChips() {
         var chips: [ComposerChip] = []
         if let p = project {
-            chips.append(ComposerChip(id: "project", title: p.name, symbol: nil, icon: ProjectTile.image(name: p.name, colorIndex: p.colorIndex)))
+            // The project, then the host it runs on.
+            chips.append(ComposerChip(id: "project", title: p.groupName, symbol: nil, icon: ProjectTile.image(name: p.groupName, colorIndex: p.colorIndex)))
+            chips.append(ComposerChip(id: "host", title: p.deviceName, symbol: "desktopcomputer"))
             if p.git {
                 chips.append(ComposerChip(id: "branch", title: draft.worktree ? "New worktree" : (draft.branch ?? "Current branch"), symbol: nil, icon: BranchIcon.sized()))
             }
@@ -262,20 +277,27 @@ final class NewSessionViewController: UIViewController, UIGestureRecognizerDeleg
         mark.image = BrandMarks.image(for: draft.harness, side: 34)
     }
 
+    /// One entry per project — checkouts of one repository, on any device,
+    /// are one entry listing their hosts; the host chip then picks which.
     private func projectMenu() -> UIMenu {
-        let byDevice = Dictionary(grouping: app.projectOptions, by: \.device)
-        var sections: [UIMenuElement] = byDevice.keys.sorted { (byDevice[$0]?.first?.deviceName ?? "") < (byDevice[$1]?.first?.deviceName ?? "") }.map { device in
-            let items = byDevice[device]!
-            let name = items.first?.deviceName ?? "Host"
-            return UIMenu(title: name + (items.first?.online == false ? " · offline" : ""), options: .displayInline, children: items.map { p in
-                UIAction(title: p.name, image: UIImage(systemName: p.git ? "folder.badge.gearshape" : "folder"), state: p.id == draft.projectId ? .on : .off) { [weak self] _ in
-                    self?.draft.projectId = p.id
-                    self?.draft.hostId = nil
-                    self?.draft.branch = nil
-                    self?.loadModels()
-                }
-            })
+        var groups: [[ProjectOption]] = []
+        for p in app.projectOptions {
+            if let i = groups.firstIndex(where: { $0[0].groupKey == p.groupKey }) {
+                groups[i].append(p)
+            } else {
+                groups.append([p])
+            }
         }
+        groups.sort { $0[0].groupName.localizedCaseInsensitiveCompare($1[0].groupName) == .orderedAscending }
+        let picked = project?.groupKey
+        var sections: [UIMenuElement] = [UIMenu(options: .displayInline, children: groups.map { members in
+            let first = members[0]
+            var hosts: [String] = []
+            for m in members where !hosts.contains(m.deviceName) { hosts.append(m.deviceName) }
+            return UIAction(title: first.groupName, subtitle: hosts.sorted { $0.localizedCaseInsensitiveCompare($1) == .orderedAscending }.joined(separator: ", "), image: ProjectTile.image(name: first.groupName, colorIndex: first.colorIndex, side: 18), state: first.groupKey == picked ? .on : .off) { [weak self] _ in
+                self?.pickProject(members)
+            }
+        })]
         sections.append(UIMenu(options: .displayInline, children: [
             UIAction(title: "No Project…", image: UIImage(systemName: "tray"), state: draft.projectId == nil ? .on : .off) { [weak self] _ in
                 guard let self else { return }
@@ -298,8 +320,37 @@ final class NewSessionViewController: UIViewController, UIGestureRecognizerDeleg
         return UIMenu(title: "Project", children: sections)
     }
 
+    /// Keep the host when it has a checkout of the project, else the first
+    /// reachable one.
+    private func pickProject(_ members: [ProjectOption]) {
+        let pick = members.first { $0.id == draft.projectId }
+            ?? members.first { $0.device == deviceId }
+            ?? members.first(where: \.online)
+            ?? members[0]
+        pickCheckout(pick)
+    }
+
+    private func pickCheckout(_ p: ProjectOption) {
+        if p.id != draft.projectId { draft.branch = nil }
+        draft.projectId = p.id
+        draft.hostId = nil
+        loadModels()
+    }
+
+    /// With a project: its checkouts, by host (the path tells apart several
+    /// on one host). Without: every host — project-less sessions run in its
+    /// home.
     private func hostMenu() -> UIMenu {
-        UIMenu(title: "Run on", children: app.hostOptions.map { h in
+        let checkouts = self.checkouts
+        if !checkouts.isEmpty {
+            return UIMenu(title: "Run on", children: checkouts.map { p in
+                let shared = checkouts.filter { $0.device == p.device }.count > 1
+                return UIAction(title: p.deviceName, subtitle: shared ? p.path : (p.online ? "Online" : "Offline"), image: UIImage(systemName: "desktopcomputer"), state: p.id == draft.projectId ? .on : .off) { [weak self] _ in
+                    self?.pickCheckout(p)
+                }
+            })
+        }
+        return UIMenu(title: "Run on", children: app.hostOptions.map { h in
             UIAction(title: h.name, subtitle: h.online ? "Online" : "Offline", image: UIImage(systemName: "desktopcomputer"), state: h.id == draft.hostId ? .on : .off) { [weak self] _ in
                 self?.draft.hostId = h.id
                 self?.loadModels()
diff --git a/apps/ios/ZeronUITests/SessionFlowTests.swift b/apps/ios/ZeronUITests/SessionFlowTests.swift
index fe5426ec10..b299630fe7 100644
--- a/apps/ios/ZeronUITests/SessionFlowTests.swift
+++ b/apps/ios/ZeronUITests/SessionFlowTests.swift
@@ -284,6 +284,36 @@ final class SessionFlowTests: XCTestCase {
         XCTAssertFalse(use.exists)
     }
 
+    /// Clones of one repository are one project; the host chip then picks
+    /// which checkout runs the session.
+    func testProjectPickerGroupsClonesAndHostPicksCheckout() {
+        let app = launch(["-route", "new"])
+        let project = app.buttons["composer-chip-project"]
+        XCTAssertTrue(project.waitForExistence(timeout: 10))
+        project.tap()
+        let zeron = app.buttons.matching(NSPredicate(format: "label BEGINSWITH 'zeron'"))
+        XCTAssertTrue(zeron.firstMatch.waitForExistence(timeout: 5))
+        XCTAssertEqual(zeron.count, 1, "one entry for both clones")
+        snapshot(app, "project-menu")
+        zeron.firstMatch.tap()
+        let host = app.buttons["composer-chip-host"]
+        XCTAssertTrue(host.waitForExistence(timeout: 5))
+        host.tap()
+        func item(_ name: String) -> XCUIElement {
+            app.buttons.matching(NSPredicate(format: "label BEGINSWITH %@", name)).firstMatch
+        }
+        XCTAssertTrue(item("hetzner-01").waitForExistence(timeout: 5))
+        XCTAssertTrue(item("MacBook Pro").exists)
+        XCTAssertFalse(item("Mac Studio").exists, "only hosts with a checkout")
+        snapshot(app, "host-menu")
+        item("hetzner-01").tap()
+        let moved = NSPredicate(format: "label CONTAINS 'hetzner-01'")
+        expectation(for: moved, evaluatedWith: host)
+        waitForExpectations(timeout: 5)
+        XCTAssertTrue(project.label.contains("zeron"), "the project stays picked")
+        snapshot(app, "picked-clone")
+    }
+
     func testToolGroupExpandsAndShowsDetail() {
         let app = launch(["-route", "chat:chat-veil"])
         let expand = app.buttons["Expand"].firstMatch
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 3cfdd9dfea..d43669c15a 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -953,6 +953,7 @@ impl Client {
             git_detected,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: Utc::now(),
         };
         let id = space.id.clone();
diff --git a/crates/client/src/demo/fixtures.rs b/crates/client/src/demo/fixtures.rs
index bb13e70152..218f89decb 100644
--- a/crates/client/src/demo/fixtures.rs
+++ b/crates/client/src/demo/fixtures.rs
@@ -178,8 +178,8 @@ pub(crate) fn chats() -> Vec<DemoChat> {
             last_ago_ms: 10 * MIN,
             ..chat(
                 "chat-cjk",
-                Some("space-zeron"),
-                MAC,
+                Some("space-zeron-vps"),
+                VPS,
                 "多言語テキストのレイアウト 🌏",
                 "日本語の長い段落です。",
             )
@@ -246,8 +246,13 @@ pub(crate) fn spaces(now: i64) -> Vec<Space> {
             git_detected: git,
             git_checked_at: git.then(|| ms(now)),
             checkout_id: git.then(|| format!("co-{id}")),
+            repository_id: None,
             created_at: ms(now - ago),
         };
+    let zeron = |mut space: Space| {
+        space.repository_id = Some("github.com/zeronsh/zeron".into());
+        space
+    };
     vec![
         space(
             "space-blog",
@@ -257,7 +262,23 @@ pub(crate) fn spaces(now: i64) -> Vec<Space> {
             false,
             20 * DAY,
         ),
-        space("space-zeron", MAC, "/Users/dev/zeron", None, true, 9 * DAY),
+        zeron(space(
+            "space-zeron",
+            MAC,
+            "/Users/dev/zeron",
+            None,
+            true,
+            9 * DAY,
+        )),
+        // A second clone of the same repository on the VPS.
+        zeron(space(
+            "space-zeron-vps",
+            VPS,
+            "/srv/src/zeron",
+            None,
+            true,
+            6 * DAY,
+        )),
         space("space-edge", VPS, "/srv/deploys/edge", None, true, 4 * DAY),
         space(
             "space-mobile",
diff --git a/crates/client/src/workspace/view.rs b/crates/client/src/workspace/view.rs
index e7c7117ca2..078ad4042b 100644
--- a/crates/client/src/workspace/view.rs
+++ b/crates/client/src/workspace/view.rs
@@ -15,7 +15,7 @@ use std::sync::Arc;
 
 use chrono::{DateTime, Utc};
 use zeron_doc::WorkspaceState;
-use zeron_proto::view::{attention_rank, display_status};
+use zeron_proto::view::{attention_rank, display_status, project_key, representative_space};
 use zeron_proto::{
     ChangeRequestState, ChangeRequestSummary, Chat, ChatIndicator, CheckoutChangeRequestStatus,
     Device, Session, SidebarPreferences, Space,
@@ -131,6 +131,13 @@ pub struct ProjectView {
     pub device_online: bool,
     pub git_detected: bool,
     pub created_at_ms: i64,
+    /// The repository project this checkout belongs to
+    /// ([`zeron_proto::view::project_key`]): clones and worktrees of one
+    /// repository, on any device, share it.
+    pub group_key: String,
+    /// The group's name — its representative checkout's — shared by every
+    /// member, like `color_index`.
+    pub group_name: String,
     /// Most urgent indicator among its active sessions (Idle when none).
     pub indicator: ChatIndicator,
     pub unseen_count: u32,
@@ -411,6 +418,7 @@ fn hash_row(row: &SessionRow) -> u64 {
 }
 
 struct RowContext<'a> {
+    all_spaces: &'a [Space],
     spaces: HashMap<&'a str, &'a Space>,
     devices: HashMap<&'a str, &'a Device>,
     sessions: HashMap<&'a str, &'a Session>,
@@ -445,7 +453,8 @@ fn build_row(chat: &Chat, rc: &RowContext<'_>, cx: &DeriveContext<'_>) -> Arc<Se
         .map(|space| ProjectRef {
             id: space.id.clone(),
             name: space.display_name().to_owned(),
-            color_index: project_color_index(&space.path),
+            // Clones of one repository share their representative's color.
+            color_index: project_color_index(&representative_space(rc.all_spaces, space).path),
         });
     let device = rc.devices.get(chat.device_id.as_str());
     let config = chat.config.as_ref();
@@ -536,6 +545,7 @@ pub(crate) fn derive(
         }
     }
     let rc = RowContext {
+        all_spaces: &state.spaces,
         spaces: state.spaces.iter().map(|s| (s.id.as_str(), s)).collect(),
         devices: state.devices.iter().map(|d| (d.id.as_str(), d)).collect(),
         sessions: state
@@ -617,11 +627,12 @@ pub(crate) fn derive(
                 .map(|r| r.indicator)
                 .min_by_key(|i| attention_rank(*i))
                 .unwrap_or(ChatIndicator::Idle);
+            let representative = representative_space(&state.spaces, space);
             ProjectView {
                 id: space.id.clone(),
                 name: space.display_name().to_owned(),
                 path: space.path.clone(),
-                color_index: project_color_index(&space.path),
+                color_index: project_color_index(&representative.path),
                 device_id: space.device_id.clone(),
                 device_name: rc
                     .devices
@@ -635,6 +646,8 @@ pub(crate) fn derive(
                 ),
                 git_detected: space.git_detected,
                 created_at_ms: space.created_at.timestamp_millis(),
+                group_key: project_key(space),
+                group_name: representative.display_name().to_owned(),
                 indicator,
                 unseen_count: sessions.iter().filter(|r| r.unseen).count() as u32,
                 sessions,
@@ -751,6 +764,9 @@ fn snapshot_hash(s: &WorkspaceSnapshot) -> u64 {
         project.id.hash(&mut h);
         project.name.hash(&mut h);
         project.path.hash(&mut h);
+        project.color_index.hash(&mut h);
+        project.group_key.hash(&mut h);
+        project.group_name.hash(&mut h);
         project.device_name.hash(&mut h);
         project.device_online.hash(&mut h);
         project.git_detected.hash(&mut h);
diff --git a/crates/client/tests/demo.rs b/crates/client/tests/demo.rs
index 82a6811ea2..56bbd87a0f 100644
--- a/crates/client/tests/demo.rs
+++ b/crates/client/tests/demo.rs
@@ -97,6 +97,14 @@ fn front_page_mirrors_the_desktop_sidebar() {
     let zeron = ws.project("space-zeron").unwrap();
     assert_eq!(zeron.indicator, ChatIndicator::AwaitingInput);
     assert!(zeron.unseen_count >= 2);
+    // Clones of one repository are one project, with one name and color.
+    let clone = ws.project("space-zeron-vps").unwrap();
+    assert_eq!(clone.group_key, zeron.group_key);
+    assert_eq!(clone.group_name, "zeron");
+    assert_eq!(clone.color_index, zeron.color_index);
+    let cjk = ws.session("chat-cjk").unwrap();
+    assert_eq!(cjk.project.as_ref().unwrap().color_index, zeron.color_index);
+    assert_ne!(ws.project("space-edge").unwrap().group_key, zeron.group_key);
     assert_eq!(ids(&ws.projectless), ["chat-home"]);
     assert!(ws.devices.iter().any(|d| d.is_self && d.id == "ios-test"));
     assert!(!ws.device("dev-studio").unwrap().online);
diff --git a/crates/client/tests/live.rs b/crates/client/tests/live.rs
index 27fff96daa..203ae87f6d 100644
--- a/crates/client/tests/live.rs
+++ b/crates/client/tests/live.rs
@@ -58,6 +58,7 @@ fn host_rows(now: chrono::DateTime<Utc>) -> (Device, Space, Chat) {
         git_detected: true,
         git_checked_at: None,
         checkout_id: None,
+        repository_id: None,
         created_at: now,
     };
     let chat = Chat {
diff --git a/crates/doc/src/registry.rs b/crates/doc/src/registry.rs
index 255427e0ac..28a078cee6 100644
--- a/crates/doc/src/registry.rs
+++ b/crates/doc/src/registry.rs
@@ -785,6 +785,7 @@ impl RegistryDoc {
             ("gitDetected", json!(space.git_detected)),
             ("gitCheckedAt", opt_ms(space.git_checked_at)),
             ("checkoutId", opt_str(space.checkout_id.as_deref())),
+            ("repositoryId", opt_str(space.repository_id.as_deref())),
             ("createdAt", json!(space.created_at.timestamp_millis())),
         ]);
         self.write(KIND_SPACES, &space.id.clone(), OpKind::Upsert, set);
@@ -830,6 +831,7 @@ impl RegistryDoc {
         space_id: &str,
         detected: bool,
         checkout_id: Option<&str>,
+        repository_id: Option<&str>,
         checked_at: DateTime<Utc>,
     ) -> Result<bool, DocError> {
         if !self.row_exists(KIND_SPACES, space_id) {
@@ -842,6 +844,7 @@ impl RegistryDoc {
             fields([
                 ("gitDetected", json!(detected)),
                 ("checkoutId", opt_str(checkout_id)),
+                ("repositoryId", opt_str(repository_id)),
                 ("gitCheckedAt", json!(checked_at.timestamp_millis())),
             ]),
         );
@@ -1291,6 +1294,7 @@ impl RegistryDoc {
                     ("gitDetected", json!(space.git_detected)),
                     ("gitCheckedAt", opt_ms(space.git_checked_at)),
                     ("checkoutId", opt_str(space.checkout_id.as_deref())),
+                    ("repositoryId", opt_str(space.repository_id.as_deref())),
                     ("createdAt", json!(space.created_at.timestamp_millis())),
                 ]),
             );
diff --git a/crates/doc/src/registry/tests.rs b/crates/doc/src/registry/tests.rs
index 2bef1ada73..6d7e1ef8fa 100644
--- a/crates/doc/src/registry/tests.rs
+++ b/crates/doc/src/registry/tests.rs
@@ -288,6 +288,7 @@ fn space(id: &str, device_id: &str, path: &str) -> Space {
         git_detected: false,
         git_checked_at: None,
         checkout_id: None,
+        repository_id: None,
         created_at: ts(1_500),
     }
 }
@@ -566,16 +567,26 @@ fn spaces_round_trip_and_mutate() {
     assert_eq!(ws.space("sp-1").unwrap().unwrap().display_name(), "project");
 
     assert!(
-        ws.set_space_git("sp-1", true, Some("checkout-abc"), ts(4_000))
-            .unwrap()
+        ws.set_space_git(
+            "sp-1",
+            true,
+            Some("checkout-abc"),
+            Some("github.com/owner/project"),
+            ts(4_000),
+        )
+        .unwrap()
     );
     let row = ws.space("sp-1").unwrap().unwrap();
     assert!(row.git_detected);
     assert_eq!(row.checkout_id.as_deref(), Some("checkout-abc"));
+    assert_eq!(
+        row.repository_id.as_deref(),
+        Some("github.com/owner/project")
+    );
     assert_eq!(row.git_checked_at, Some(ts(4_000)));
 
     assert!(!ws.rename_space("nope", Some("x")).unwrap());
-    assert!(!ws.set_space_git("nope", true, None, ts(1)).unwrap());
+    assert!(!ws.set_space_git("nope", true, None, None, ts(1)).unwrap());
 }
 
 #[test]
diff --git a/crates/doc/src/workspace.rs b/crates/doc/src/workspace.rs
index 59c89d2bd8..7a8732cc99 100644
--- a/crates/doc/src/workspace.rs
+++ b/crates/doc/src/workspace.rs
@@ -7,7 +7,7 @@
 //! to the *same* row settle field-by-field LWW (exactly right for renames/archives):
 //! - `devices`: LoroMap keyed by deviceId → row map {id, name, platform, lastSeenAt}
 //! - `spaces`: LoroMap keyed by spaceId → row map {id, deviceId, path, name?,
-//!   gitDetected, gitCheckedAt?, checkoutId?, createdAt}
+//!   gitDetected, gitCheckedAt?, checkoutId?, repositoryId?, createdAt}
 //! - `chats`: LoroMap keyed by chatId → row map {id, deviceId, title?, archived, cwd?,
 //!   branch?, checkoutId?, config?(json), lastMessagePreview?, lastMessageAt?, createdAt,
 //!   harnessSessionId?, harnessSessionCwd?, spaceId?, lastSeenAt?}
@@ -170,6 +170,7 @@ impl WorkspaceDoc {
         row.insert("gitDetected", space.git_detected)?;
         set_opt_ms(&row, "gitCheckedAt", space.git_checked_at)?;
         set_opt_str(&row, "checkoutId", space.checkout_id.as_deref())?;
+        set_opt_str(&row, "repositoryId", space.repository_id.as_deref())?;
         row.insert("createdAt", space.created_at.timestamp_millis())?;
         self.doc.commit();
         Ok(())
@@ -208,6 +209,7 @@ impl WorkspaceDoc {
         space_id: &str,
         detected: bool,
         checkout_id: Option<&str>,
+        repository_id: Option<&str>,
         checked_at: DateTime<Utc>,
     ) -> Result<bool, DocError> {
         let Some(row) = self.existing_row("spaces", space_id) else {
@@ -215,6 +217,7 @@ impl WorkspaceDoc {
         };
         row.insert("gitDetected", detected)?;
         set_opt_str(&row, "checkoutId", checkout_id)?;
+        set_opt_str(&row, "repositoryId", repository_id)?;
         row.insert("gitCheckedAt", checked_at.timestamp_millis())?;
         self.doc.commit();
         Ok(true)
@@ -655,6 +658,8 @@ pub(crate) struct RawSpace {
     #[serde(default)]
     checkout_id: Option<String>,
     #[serde(default)]
+    repository_id: Option<String>,
+    #[serde(default)]
     created_at: i64,
 }
 
@@ -668,6 +673,7 @@ impl From<RawSpace> for Space {
             git_detected: raw.git_detected,
             git_checked_at: raw.git_checked_at.map(dt),
             checkout_id: raw.checkout_id,
+            repository_id: raw.repository_id,
             created_at: dt(raw.created_at),
         }
     }
@@ -878,6 +884,7 @@ mod tests {
             git_detected: false,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: ts(1_500),
         }
     }
@@ -1096,17 +1103,27 @@ mod tests {
         assert_eq!(ws.space("sp-1").unwrap().unwrap().display_name(), "project");
 
         assert!(
-            ws.set_space_git("sp-1", true, Some("checkout-abc"), ts(4_000))
-                .unwrap()
+            ws.set_space_git(
+                "sp-1",
+                true,
+                Some("checkout-abc"),
+                Some("github.com/owner/project"),
+                ts(4_000),
+            )
+            .unwrap()
         );
         let row = ws.space("sp-1").unwrap().unwrap();
         assert!(row.git_detected);
         assert_eq!(row.checkout_id.as_deref(), Some("checkout-abc"));
+        assert_eq!(
+            row.repository_id.as_deref(),
+            Some("github.com/owner/project")
+        );
         assert_eq!(row.git_checked_at, Some(ts(4_000)));
 
         // Unknown rows report false, never invent rows.
         assert!(!ws.rename_space("nope", Some("x")).unwrap());
-        assert!(!ws.set_space_git("nope", true, None, ts(1)).unwrap());
+        assert!(!ws.set_space_git("nope", true, None, None, ts(1)).unwrap());
     }
 
     #[test]
diff --git a/crates/engine/src/repos.rs b/crates/engine/src/repos.rs
index 9bb2edf821..b4df7c7a79 100644
--- a/crates/engine/src/repos.rs
+++ b/crates/engine/src/repos.rs
@@ -138,6 +138,10 @@ struct ReposInner {
     github_avatars: std::sync::Mutex<HashMap<String, String>>,
     github_avatar_pages: std::sync::Mutex<HashSet<String>>,
     file_index: FileIndexCache,
+    /// HEAD commit → its trunk's root commit. History behind a commit never
+    /// changes, so the full first-parent walk runs once per HEAD, not on
+    /// every spaces repair pass.
+    trunk_roots: std::sync::Mutex<HashMap<String, String>>,
 }
 
 struct IndexedPath {
@@ -183,6 +187,7 @@ impl Repos {
                     .build()
                     .unwrap_or_else(|_| reqwest::Client::new()),
                 github_avatars: std::sync::Mutex::new(HashMap::new()),
+                trunk_roots: std::sync::Mutex::new(HashMap::new()),
                 github_avatar_pages: std::sync::Mutex::new(HashSet::new()),
                 file_index: std::sync::Mutex::new(HashMap::new()),
             }),
@@ -253,6 +258,40 @@ impl Repos {
         Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
     }
 
+    /// Like [`Self::git`], for commands that answer "no" with a silent exit
+    /// status 1 (`rev-parse --verify --quiet`): `Ok(None)` then, `Err` for
+    /// any other failure.
+    async fn git_probe(&self, args: &[&str], cwd: Option<&Path>) -> Result<Option<String>, EngineError> {
+        let mut cmd = tokio::process::Command::new("git");
+        #[cfg(windows)]
+        {
+            use std::os::windows::process::CommandExt;
+            cmd.as_std_mut().creation_flags(0x08000000);
+        }
+        cmd.args(args);
+        if let Some(cwd) = cwd {
+            cmd.current_dir(cwd);
+        }
+        cmd.stdin(std::process::Stdio::null());
+        let output = cmd
+            .output()
+            .await
+            .map_err(|e| EngineError::Other(format!("git spawn failed: {e}")))?;
+        if output.status.success() {
+            return Ok(Some(String::from_utf8_lossy(&output.stdout).trim().to_string()));
+        }
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        if output.status.code() == Some(1) && stderr.trim().is_empty() {
+            return Ok(None);
+        }
+        Err(EngineError::Other(format!(
+            "git {} failed ({}): {}",
+            args.first().unwrap_or(&"?"),
+            output.status,
+            stderr.trim()
+        )))
+    }
+
     /// Async existence probe with a timeout: a wedged network mount just reads
     /// as "gone" instead of hanging every caller.
     async fn path_exists(path: &Path) -> bool {
@@ -338,6 +377,123 @@ impl Repos {
         })
     }
 
+    /// Identity shared by every clone and worktree of one repository: the
+    /// root commit its trunk grew from, `commit:<sha>`. Unlike a remote URL it
+    /// survives repository renames and transfers, SSH host aliases and
+    /// transport spellings, and it needs no network. Forks share it with
+    /// their upstream (the same codebase).
+    ///
+    /// A history that cannot vouch for its root — a shallow clone, or no
+    /// commits yet — falls back to the normalized `origin` remote (else the
+    /// first remote) as `host/owner/repo`, then to
+    /// `local:sha256(deviceId ‖ NUL ‖ canonical common git dir)`, so the
+    /// repository's worktrees on this device still match each other.
+    ///
+    /// A folder below the repository's top level carries its in-repository
+    /// path (`<identity>:apps/web`): sibling folders of one monorepo, or
+    /// plain folders inside an enclosing repository, stay separate projects,
+    /// while the same subfolder in another clone or worktree still matches.
+    ///
+    /// Errors are real failures (git missing, a lock, I/O) — never a silent
+    /// fallback to a different identity form, which would regroup the
+    /// sidebar on a transient hiccup. Callers keep their last value.
+    pub async fn repository_identity(&self, path: &Path) -> Result<String, EngineError> {
+        let base = match self.trunk_root_commit(path).await? {
+            Some(root) => format!("commit:{root}"),
+            None => self.remote_or_local_identity(path).await?,
+        };
+        let prefix = self.git(&["rev-parse", "--show-prefix"], Some(path)).await?;
+        let prefix = prefix.trim_end_matches('/');
+        Ok(if prefix.is_empty() {
+            base
+        } else {
+            format!("{base}:{prefix}")
+        })
+    }
+
+    /// The normalized remote, else the device-scoped common-git-dir hash.
+    async fn remote_or_local_identity(&self, path: &Path) -> Result<String, EngineError> {
+        let remote = match self.git(&["remote", "get-url", "origin"], Some(path)).await {
+            Ok(url) => Some(url),
+            Err(_) => match self.git(&["remote"], Some(path)).await {
+                Ok(names) => match names.lines().next() {
+                    Some(name) => self
+                        .git(&["remote", "get-url", name.trim()], Some(path))
+                        .await
+                        .ok(),
+                    None => None,
+                },
+                Err(_) => None,
+            },
+        };
+        if let Some(remote) = remote
+            .as_deref()
+            .and_then(crate::source_control::parse_git_remote)
+        {
+            return Ok(
+                format!("{}/{}/{}", remote.host, remote.owner, remote.repository)
+                    .to_ascii_lowercase(),
+            );
+        }
+        let common_dir = self
+            .git(
+                &["rev-parse", "--path-format=absolute", "--git-common-dir"],
+                Some(path),
+            )
+            .await?;
+        let canonical =
+            std::fs::canonicalize(&common_dir).unwrap_or_else(|_| PathBuf::from(&common_dir));
+        let mut hasher = Sha256::new();
+        hasher.update(self.inner.device_id.as_bytes());
+        hasher.update([0u8]);
+        hasher.update(canonical.to_string_lossy().as_bytes());
+        Ok(format!("local:{}", hex(&hasher.finalize())))
+    }
+
+    /// The root of HEAD's first-parent chain — the trunk's first commit. A
+    /// merged-in unrelated history arrives as a second parent, so its roots
+    /// never displace this one. `Ok(None)` when the history can't vouch for
+    /// a root: a shallow clone (its boundary commits only look parentless,
+    /// and differ with the fetch depth) or an unborn HEAD.
+    async fn trunk_root_commit(&self, path: &Path) -> Result<Option<String>, EngineError> {
+        let shallow = self
+            .git(&["rev-parse", "--is-shallow-repository"], Some(path))
+            .await?;
+        if shallow == "true" {
+            return Ok(None);
+        }
+        let Some(head) = self
+            .git_probe(&["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], Some(path))
+            .await?
+        else {
+            return Ok(None); // unborn HEAD: no commits yet
+        };
+        if let Some(root) = self.inner.trunk_roots.lock().ok().and_then(|cache| cache.get(&head).cloned()) {
+            return Ok(Some(root));
+        }
+        let roots = self
+            .git(
+                &["rev-list", "--first-parent", "--max-parents=0", &head],
+                Some(path),
+            )
+            .await?;
+        let Some(root) = roots
+            .lines()
+            .map(str::trim)
+            .find(|sha| !sha.is_empty())
+            .map(str::to_owned)
+        else {
+            return Ok(None);
+        };
+        if let Ok(mut cache) = self.inner.trunk_roots.lock() {
+            if cache.len() >= 4096 {
+                cache.clear();
+            }
+            cache.insert(head, root.clone());
+        }
+        Ok(Some(root))
+    }
+
     async fn to_repo(&self, path: &Path) -> Result<Repo, EngineError> {
         let branch = self.current_branch(path).await.ok();
         Ok(Repo {
diff --git a/crates/engine/src/spaces.rs b/crates/engine/src/spaces.rs
index f640bd14b0..c41b654ff6 100644
--- a/crates/engine/src/spaces.rs
+++ b/crates/engine/src/spaces.rs
@@ -3,7 +3,7 @@
 //!
 //! A space is a synced (device, folder) pair; the folder need NOT be a git
 //! repo. This service watches the workspace `spaces` rows owned by THIS device
-//! and keeps their `gitDetected`/`checkoutId` stamps truthful:
+//! and keeps their `gitDetected`/`checkoutId`/`repositoryId` stamps truthful:
 //!
 //! - recheck on boot / when a space row is first observed;
 //! - a non-recursive `notify` watcher on the space folder — `.git` appearing or
@@ -211,16 +211,26 @@ async fn entry_task(
 /// Probe git presence and stamp the row — write only on change.
 async fn check_space(inner: &Arc<SpacesSyncInner>, space_id: &str, path: &Path) {
     let detected = inner.repos.is_repo(path).await;
-    let checkout_id = if detected {
-        match inner.repos.checkout_identity(path).await {
+    let (checkout_id, repository_id) = if detected {
+        let checkout_id = match inner.repos.checkout_identity(path).await {
             Ok(identity) => Some(identity.id),
             Err(err) => {
                 tracing::debug!(space = %space_id, error = %err, "spaces: checkout identity failed");
                 None
             }
-        }
+        };
+        // `None` = the check failed; the row keeps its last identity below
+        // rather than regrouping the sidebar on a transient git error.
+        let repository_id = match inner.repos.repository_identity(path).await {
+            Ok(identity) => Some(Some(identity)),
+            Err(err) => {
+                tracing::debug!(space = %space_id, error = %err, "spaces: repository identity failed");
+                None
+            }
+        };
+        (checkout_id, repository_id)
     } else {
-        None
+        (None, Some(None))
     };
     let current = match inner.workspace.read_spaces() {
         Ok(spaces) => spaces.into_iter().find(|s| s.id == space_id),
@@ -232,13 +242,19 @@ async fn check_space(inner: &Arc<SpacesSyncInner>, space_id: &str, path: &Path)
     let Some(current) = current else {
         return; // deleted while checking
     };
-    if current.git_detected == detected && current.checkout_id == checkout_id {
+    let repository_id = repository_id.unwrap_or_else(|| current.repository_id.clone());
+    if current.git_detected == detected
+        && current.checkout_id == checkout_id
+        && current.repository_id == repository_id
+    {
         return; // unchanged — no oplog growth
     }
-    match inner
-        .workspace
-        .set_space_git(space_id, detected, checkout_id.as_deref())
-    {
+    match inner.workspace.set_space_git(
+        space_id,
+        detected,
+        checkout_id.as_deref(),
+        repository_id.as_deref(),
+    ) {
         Ok(_) => {
             tracing::info!(space = %space_id, git = detected, "space git presence updated");
         }
diff --git a/crates/engine/src/workspace_host.rs b/crates/engine/src/workspace_host.rs
index df4329a3dd..b272750b75 100644
--- a/crates/engine/src/workspace_host.rs
+++ b/crates/engine/src/workspace_host.rs
@@ -807,6 +807,7 @@ impl WorkspaceHost {
             git_detected: false,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: Utc::now(),
         };
         self.mutate(|doc| doc.upsert_space(&space))?;
@@ -988,6 +989,7 @@ impl WorkspaceHost {
                 git_detected,
                 git_checked_at: None,
                 checkout_id: None,
+                repository_id: None,
                 created_at: Utc::now(),
             })
         })?;
@@ -1020,11 +1022,13 @@ impl WorkspaceHost {
         space_id: &str,
         detected: bool,
         checkout_id: Option<&str>,
+        repository_id: Option<&str>,
     ) -> Result<bool, EngineError> {
         match self.read(|doc| doc.space(space_id))? {
             Some(space) if space.device_id == self.inner.config.device_id => {
-                Ok(self
-                    .mutate(|doc| doc.set_space_git(space_id, detected, checkout_id, Utc::now()))?)
+                Ok(self.mutate(|doc| {
+                    doc.set_space_git(space_id, detected, checkout_id, repository_id, Utc::now())
+                })?)
             }
             Some(space) => {
                 tracing::warn!(
diff --git a/crates/engine/tests/m5_repos_diffs_terminals.rs b/crates/engine/tests/m5_repos_diffs_terminals.rs
index e9571c95c7..bf6f481f0b 100644
--- a/crates/engine/tests/m5_repos_diffs_terminals.rs
+++ b/crates/engine/tests/m5_repos_diffs_terminals.rs
@@ -238,6 +238,146 @@ async fn repos_round_trip_add_branches_worktrees() {
     );
 }
 
+#[tokio::test]
+async fn repository_identity_spans_worktrees_and_clones() {
+    let temp = tempfile::tempdir().expect("tempdir");
+    let repos = test_repos(&temp.path().join("data"));
+    let repo = temp.path().join("repo");
+    init_repo(&repo).await;
+    let linked = temp.path().join("linked");
+    git(
+        &repo,
+        &[
+            "worktree",
+            "add",
+            "-q",
+            "-b",
+            "side",
+            linked.to_str().unwrap(),
+        ],
+    )
+    .await;
+
+    // The trunk's root commit: shared by worktrees, and by clones whatever
+    // their remotes say — an old name kept alive by a rename redirect, an
+    // SSH host alias, another transport.
+    let root = git_stdout(&repo, &["rev-list", "--max-parents=0", "HEAD"]).await;
+    let identity = repos.repository_identity(&repo).await.expect("identity");
+    assert_eq!(identity, format!("commit:{root}"));
+    assert_eq!(repos.repository_identity(&linked).await.unwrap(), identity);
+    git(
+        &repo,
+        &["remote", "add", "origin", "git@github-alias:zeronsh/old-name.git"],
+    )
+    .await;
+    let clone = temp.path().join("clone");
+    git(
+        temp.path(),
+        &["clone", "-q", repo.to_str().unwrap(), clone.to_str().unwrap()],
+    )
+    .await;
+    git(
+        &clone,
+        &["remote", "set-url", "origin", "https://github.com/zeronsh/new-name"],
+    )
+    .await;
+    assert_eq!(repos.repository_identity(&repo).await.unwrap(), identity);
+    assert_eq!(repos.repository_identity(&clone).await.unwrap(), identity);
+
+    // Folders below the top level stay their own projects: monorepo
+    // siblings differ, the same subfolder matches across clones.
+    for dir in [&repo, &clone] {
+        std::fs::create_dir_all(dir.join("apps/web")).unwrap();
+        std::fs::create_dir_all(dir.join("apps/api")).unwrap();
+    }
+    let web = repos
+        .repository_identity(&repo.join("apps/web"))
+        .await
+        .unwrap();
+    assert_eq!(web, format!("{identity}:apps/web"));
+    assert_ne!(
+        repos
+            .repository_identity(&repo.join("apps/api"))
+            .await
+            .unwrap(),
+        web
+    );
+    assert_eq!(
+        repos
+            .repository_identity(&clone.join("apps/web"))
+            .await
+            .unwrap(),
+        web
+    );
+
+    // An unrelated repository has its own root.
+    let other = temp.path().join("other");
+    std::fs::create_dir_all(&other).unwrap();
+    git(&other, &["init", "-q", "-b", "main"]).await;
+    std::fs::write(other.join("b.txt"), "unrelated\n").unwrap();
+    git(&other, &["add", "."]).await;
+    git(&other, &["commit", "-q", "-m", "other initial"]).await;
+    assert_ne!(repos.repository_identity(&other).await.unwrap(), identity);
+
+    // Merging an unrelated history in adds a root on a second parent; the
+    // trunk's root still names the repository.
+    git(&repo, &["fetch", "-q", other.to_str().unwrap(), "main"]).await;
+    git(
+        &repo,
+        &[
+            "merge",
+            "-q",
+            "--allow-unrelated-histories",
+            "-m",
+            "merge other",
+            "FETCH_HEAD",
+        ],
+    )
+    .await;
+    assert_eq!(repos.repository_identity(&repo).await.unwrap(), identity);
+
+    // A shallow clone can't vouch for its root: the remote names it.
+    let shallow = temp.path().join("shallow");
+    git(
+        temp.path(),
+        &[
+            "clone",
+            "-q",
+            "--depth",
+            "1",
+            &format!("file://{}", repo.display()),
+            shallow.to_str().unwrap(),
+        ],
+    )
+    .await;
+    git(
+        &shallow,
+        &["remote", "set-url", "origin", "https://GitHub.com/ZeronSH/Zeron.git"],
+    )
+    .await;
+    assert_eq!(
+        repos.repository_identity(&shallow).await.unwrap(),
+        "github.com/zeronsh/zeron"
+    );
+
+    // No commits yet: the remote (origin, else the first), then a
+    // device-scoped local identity.
+    let empty = temp.path().join("empty");
+    std::fs::create_dir_all(&empty).unwrap();
+    git(&empty, &["init", "-q", "-b", "main"]).await;
+    let local = repos.repository_identity(&empty).await.unwrap();
+    assert!(local.starts_with("local:"), "{local}");
+    git(
+        &empty,
+        &["remote", "add", "upstream", "git@github.com:Anara/Comet.git"],
+    )
+    .await;
+    assert_eq!(
+        repos.repository_identity(&empty).await.unwrap(),
+        "github.com/anara/comet"
+    );
+}
+
 #[tokio::test]
 async fn git_history_is_topological_paged_and_carries_public_refs() {
     let tmp = tempfile::tempdir().expect("tempdir");
@@ -1328,6 +1468,7 @@ async fn spaces_sync_stamps_git_presence_and_reacts_to_git_init() {
     };
     assert!(!space.git_detected, "plain folder must read as non-git");
     assert!(space.checkout_id.is_none());
+    assert!(space.repository_id.is_none());
 
     // `git init` later flips the stamp (watcher and/or explicit recheck).
     git(&folder, &["init", "-b", "main"]).await;
@@ -1346,6 +1487,14 @@ async fn spaces_sync_stamps_git_presence_and_reacts_to_git_init() {
             .expect("watch alive");
     };
     assert!(space.checkout_id.is_some(), "git space gains a checkout id");
+    assert!(
+        space
+            .repository_id
+            .as_deref()
+            .is_some_and(|id| id.starts_with("local:")),
+        "remote-less git space gains a local repository id: {:?}",
+        space.repository_id
+    );
     core.shutdown().await;
 }
 
diff --git a/crates/engine/tests/workspace_sync.rs b/crates/engine/tests/workspace_sync.rs
index 56d3183b71..c992735801 100644
--- a/crates/engine/tests/workspace_sync.rs
+++ b/crates/engine/tests/workspace_sync.rs
@@ -693,6 +693,7 @@ async fn legacy_workspace_doc_migrates_instantly_on_first_boot() {
                 git_detected: true,
                 git_checked_at: Some(now),
                 checkout_id: Some("co-1".into()),
+                repository_id: None,
                 created_at: now,
             })
             .unwrap();
diff --git a/crates/mcp/src/zeron.rs b/crates/mcp/src/zeron.rs
index ac75e7ab5c..8661975f61 100644
--- a/crates/mcp/src/zeron.rs
+++ b/crates/mcp/src/zeron.rs
@@ -772,6 +772,7 @@ mod tests {
             git_detected: true,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: Utc::now(),
         }
     }
diff --git a/crates/mobile/src/client_ffi/types.rs b/crates/mobile/src/client_ffi/types.rs
index eb3d4d1752..c62862edae 100644
--- a/crates/mobile/src/client_ffi/types.rs
+++ b/crates/mobile/src/client_ffi/types.rs
@@ -604,6 +604,10 @@ pub struct ProjectView {
     pub device_online: bool,
     pub git_detected: bool,
     pub created_at_ms: i64,
+    /// Shared by every checkout of one repository, on any device.
+    pub group_key: String,
+    /// The repository group's name, shared like `color_index`.
+    pub group_name: String,
     /// Most urgent indicator among its active sessions.
     pub indicator: ChatIndicator,
     pub unseen_count: u32,
@@ -623,6 +627,8 @@ impl From<&zc::ProjectView> for ProjectView {
             device_online: p.device_online,
             git_detected: p.git_detected,
             created_at_ms: p.created_at_ms,
+            group_key: p.group_key.clone(),
+            group_name: p.group_name.clone(),
             indicator: p.indicator.into(),
             unseen_count: p.unseen_count,
             sessions: rows(&p.sessions),
diff --git a/crates/proto/src/entities.rs b/crates/proto/src/entities.rs
index 9946cb8501..1226139b07 100644
--- a/crates/proto/src/entities.rs
+++ b/crates/proto/src/entities.rs
@@ -128,6 +128,14 @@ pub struct Space {
     /// (sha256(deviceId ‖ NUL ‖ git_dir)) — diff grouping key for root sessions.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub checkout_id: Option<String>,
+    /// Owner-stamped when git: identity shared by every clone and worktree of
+    /// one repository — its trunk's root commit (`commit:<sha>`, which
+    /// survives renames, transfers and remote spellings), else for a shallow
+    /// or empty history the normalized origin remote (`host/owner/repo`),
+    /// else `local:` + a device-scoped hash of the common git dir. Opaque to
+    /// readers: projects with equal ids group together.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub repository_id: Option<String>,
     pub created_at: DateTime<Utc>,
 }
 
diff --git a/crates/proto/src/view.rs b/crates/proto/src/view.rs
index acb9bb45a2..32f7c6ace4 100644
--- a/crates/proto/src/view.rs
+++ b/crates/proto/src/view.rs
@@ -122,6 +122,30 @@ pub fn sort_spaces(spaces: &mut [Space]) {
     });
 }
 
+/// The project a space belongs to: spaces sharing a repository identity —
+/// clones and worktrees of one repository, on any device — are one project.
+/// A space without an identity is a project of its own. Pure.
+pub fn project_key(space: &Space) -> String {
+    match space.repository_id.as_deref() {
+        Some(repository_id) => format!("repo:{repository_id}"),
+        None => space.id.clone(),
+    }
+}
+
+/// The space that speaks for `space`'s whole project: the oldest member, id
+/// tiebreak. Its name and color stand for every member, and the choice is
+/// the same on every device, so a repository looks alike everywhere. Pure.
+pub fn representative_space<'a>(spaces: &'a [Space], space: &'a Space) -> &'a Space {
+    let Some(repository_id) = space.repository_id.as_deref() else {
+        return space;
+    };
+    spaces
+        .iter()
+        .filter(|s| s.repository_id.as_deref() == Some(repository_id))
+        .min_by_key(|s| (s.created_at, s.id.as_str()))
+        .unwrap_or(space)
+}
+
 /// Sidebar order: `last_message_at` desc, falling back to `created_at`; ties
 /// break by `created_at` desc then id so the sort is total and stable across
 /// devices. Pure.
@@ -176,6 +200,40 @@ pub fn gate_phase(
     }
 }
 
+#[cfg(test)]
+mod project_tests {
+    use super::*;
+
+    fn space(id: &str, device: &str, repository: Option<&str>, minutes: i64) -> Space {
+        Space {
+            id: id.into(),
+            device_id: device.into(),
+            path: format!("/{device}/{id}"),
+            name: None,
+            git_detected: repository.is_some(),
+            git_checked_at: None,
+            checkout_id: None,
+            repository_id: repository.map(str::to_string),
+            created_at: DateTime::<Utc>::UNIX_EPOCH + chrono::TimeDelta::minutes(minutes),
+        }
+    }
+
+    #[test]
+    fn spaces_sharing_a_repository_are_one_project_led_by_the_oldest() {
+        let spaces = vec![
+            space("laptop", "mac", Some("github.com/o/r"), 2),
+            space("server", "vps", Some("github.com/o/r"), 1),
+            space("notes", "mac", None, 0),
+        ];
+        assert_eq!(project_key(&spaces[0]), "repo:github.com/o/r");
+        assert_eq!(project_key(&spaces[0]), project_key(&spaces[1]));
+        assert_eq!(project_key(&spaces[2]), "notes");
+        assert_eq!(representative_space(&spaces, &spaces[0]).id, "server");
+        assert_eq!(representative_space(&spaces, &spaces[1]).id, "server");
+        assert_eq!(representative_space(&spaces, &spaces[2]).id, "notes");
+    }
+}
+
 #[cfg(test)]
 mod gate_tests {
     use super::*;
diff --git a/crates/ui/assets/icons/alt-arrow-down.svg b/crates/ui/assets/icons/alt-arrow-down.svg
index 53e3b066c5..00cb48a570 100644
--- a/crates/ui/assets/icons/alt-arrow-down.svg
+++ b/crates/ui/assets/icons/alt-arrow-down.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="m19 9l-7 6l-7-6"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 9.25 12 14.75 6.5 9.25"/></svg>
diff --git a/crates/ui/assets/icons/alt-arrow-left.svg b/crates/ui/assets/icons/alt-arrow-left.svg
index 4dd27113c9..6af13e8fe7 100644
--- a/crates/ui/assets/icons/alt-arrow-left.svg
+++ b/crates/ui/assets/icons/alt-arrow-left.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="m15 5l-6 7l6 7"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M14.75 17.5 9.25 12 14.75 6.5"/></svg>
diff --git a/crates/ui/assets/icons/alt-arrow-right.svg b/crates/ui/assets/icons/alt-arrow-right.svg
index 00eb28aa30..644eed71cc 100644
--- a/crates/ui/assets/icons/alt-arrow-right.svg
+++ b/crates/ui/assets/icons/alt-arrow-right.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="m9 5l6 7l-6 7"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M9.25 6.5 14.75 12 9.25 17.5"/></svg>
diff --git a/crates/ui/assets/icons/alt-arrow-up.svg b/crates/ui/assets/icons/alt-arrow-up.svg
index 0a88aa4e5e..88f3979358 100644
--- a/crates/ui/assets/icons/alt-arrow-up.svg
+++ b/crates/ui/assets/icons/alt-arrow-up.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="m5 15l7-6l7 6"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M6.5 14.75 12 9.25 17.5 14.75"/></svg>
diff --git a/crates/ui/assets/icons/arrow-left.svg b/crates/ui/assets/icons/arrow-left.svg
index 96bafa1d3d..e409f87e46 100644
--- a/crates/ui/assets/icons/arrow-left.svg
+++ b/crates/ui/assets/icons/arrow-left.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M20 12H4m0 0l6-6m-6 6l6 6"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M19 12H5m5.5-5.5L5 12l5.5 5.5"/></svg>
diff --git a/crates/ui/assets/icons/arrow-right.svg b/crates/ui/assets/icons/arrow-right.svg
index ef861410c3..f31f6bd6cb 100644
--- a/crates/ui/assets/icons/arrow-right.svg
+++ b/crates/ui/assets/icons/arrow-right.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M4 12h16m0 0l-6-6m6 6l-6 6"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12h14m-5.5-5.5L19 12l-5.5 5.5"/></svg>
diff --git a/crates/ui/assets/icons/collapse-arrows.svg b/crates/ui/assets/icons/collapse-arrows.svg
index b744c52801..c5340b8a1a 100644
--- a/crates/ui/assets/icons/collapse-arrows.svg
+++ b/crates/ui/assets/icons/collapse-arrows.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M13 5v6h6m.5-6.5L13 11M11 19v-6H5m-.5 6.5L11 13"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M4 10h6V4m0 6L4 4m16 10h-6v6m0-6 6 6"/></svg>
diff --git a/crates/ui/assets/icons/expand-arrows.svg b/crates/ui/assets/icons/expand-arrows.svg
index f2b57dfcf8..7ffed0e6ad 100644
--- a/crates/ui/assets/icons/expand-arrows.svg
+++ b/crates/ui/assets/icons/expand-arrows.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M14 4h6v6m-.5-5.5L13 11M10 20H4v-6m.5 5.5L11 13"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M9 4H4v5m0-5 6 6m5 10h5v-5m0 5-6-6"/></svg>
diff --git a/crates/ui/assets/icons/file-tree.svg b/crates/ui/assets/icons/file-tree.svg
index 6e8160c1f1..85d51efe7d 100644
--- a/crates/ui/assets/icons/file-tree.svg
+++ b/crates/ui/assets/icons/file-tree.svg
@@ -1,7 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24">
-  <g fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
-    <path d="M2 3v12a3 3 0 0 0 3 3h7M2 6h10"/>
-    <rect x="16" y="3" width="6" height="6" rx="1.5"/>
-    <rect x="16" y="15" width="6" height="6" rx="1.5"/>
-  </g>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M4 5.25v9.25a2 2 0 0 0 2 2h9.5M4 7.5h11.5"/><rect x="15.5" y="5.25" width="4.5" height="4.5" rx="1"/><rect x="15.5" y="14.25" width="4.5" height="4.5" rx="1"/></svg>
diff --git a/crates/ui/assets/icons/folder.svg b/crates/ui/assets/icons/folder.svg
index 77a59f4bf4..be589c8e42 100644
--- a/crates/ui/assets/icons/folder.svg
+++ b/crates/ui/assets/icons/folder.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="1.5"><path stroke-linecap="round" d="M18 10h-5"/><path d="M2 6.95c0-.883 0-1.324.07-1.692A4 4 0 0 1 5.257 2.07C5.626 2 6.068 2 6.95 2c.386 0 .58 0 .766.017a4 4 0 0 1 2.18.904c.144.119.28.255.554.529L11 4c.816.816 1.224 1.224 1.712 1.495a4 4 0 0 0 .848.352C14.098 6 14.675 6 15.828 6h.374c2.632 0 3.949 0 4.804.77q.119.105.224.224c.77.855.77 2.172.77 4.804V14c0 3.771 0 5.657-1.172 6.828S17.771 22 14 22h-4c-3.771 0-5.657 0-6.828-1.172S2 17.771 2 14z"/></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M3 7a3 3 0 0 1 3-3h2.6a2 2 0 0 1 1.6.8L12 7h6a3 3 0 0 1 3 3v7a3 3 0 0 1-3 3H6a3 3 0 0 1-3-3Z"/></svg>
diff --git a/crates/ui/assets/icons/fork.svg b/crates/ui/assets/icons/fork.svg
new file mode 100644
index 0000000000..379aa04327
--- /dev/null
+++ b/crates/ui/assets/icons/fork.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M12 15.5V12M6 8.5V10a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V8.5"/><circle cx="12" cy="17.75" r="2.25"/><circle cx="6" cy="6.25" r="2.25"/><circle cx="18" cy="6.25" r="2.25"/></svg>
diff --git a/crates/ui/assets/icons/git-branch.svg b/crates/ui/assets/icons/git-branch.svg
index c8820da1e0..a01c97e42b 100644
--- a/crates/ui/assets/icons/git-branch.svg
+++ b/crates/ui/assets/icons/git-branch.svg
@@ -1,7 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<circle cx="6.5" cy="5.5" r="2.25" stroke="currentColor" stroke-width="1.5"/>
-<circle cx="6.5" cy="18.5" r="2.25" stroke="currentColor" stroke-width="1.5"/>
-<circle cx="17.5" cy="7.5" r="2.25" stroke="currentColor" stroke-width="1.5"/>
-<path d="M6.5 7.75v8.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
-<path d="M17.5 9.75c0 2.9-2.6 4.35-6.2 4.72c-1.9.2-3.3.9-4 2.03" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M6 8.5v7M6 12h10a2 2 0 0 0 2-2V8.5"/><circle cx="6" cy="6.25" r="2.25"/><circle cx="6" cy="17.75" r="2.25"/><circle cx="18" cy="6.25" r="2.25"/></svg>
diff --git a/crates/ui/assets/icons/plus.svg b/crates/ui/assets/icons/plus.svg
index 7f9fff563a..fff3ff23f0 100644
--- a/crates/ui/assets/icons/plus.svg
+++ b/crates/ui/assets/icons/plus.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="none"><path d="M8 3.25v9.5M3.25 8h9.5" stroke="currentColor" stroke-width="1.25" stroke-linecap="round"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14M5 12h14"/></svg>
diff --git a/crates/ui/assets/icons/pull-request.svg b/crates/ui/assets/icons/pull-request.svg
index cd875ce477..9e221e3e08 100644
--- a/crates/ui/assets/icons/pull-request.svg
+++ b/crates/ui/assets/icons/pull-request.svg
@@ -1,7 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<circle cx="6" cy="5" r="2.25" stroke="currentColor" stroke-width="1.5"/>
-<circle cx="6" cy="19" r="2.25" stroke="currentColor" stroke-width="1.5"/>
-<circle cx="18" cy="19" r="2.25" stroke="currentColor" stroke-width="1.5"/>
-<path d="M6 7.25v9.5M15 5h.75A2.25 2.25 0 0 1 18 7.25v9.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
-<path d="m12.75 7.75 2.5-2.75-2.5-2.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M6 8.5v7M18 15.5V8.25a2 2 0 0 0-2-2h-3.5m2.25-2.25L12.5 6.25l2.25 2.25"/><circle cx="6" cy="6.25" r="2.25"/><circle cx="6" cy="17.75" r="2.25"/><circle cx="18" cy="17.75" r="2.25"/></svg>
diff --git a/crates/ui/assets/icons/sidebar-minimalistic-left.svg b/crates/ui/assets/icons/sidebar-minimalistic-left.svg
deleted file mode 100644
index 5a6a23703b..0000000000
--- a/crates/ui/assets/icons/sidebar-minimalistic-left.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="1.5"><path d="M2 11c0-3.771 0-5.657 1.172-6.828S6.229 3 10 3h4c3.771 0 5.657 0 6.828 1.172S22 7.229 22 11v2c0 3.771 0 5.657-1.172 6.828S17.771 21 14 21h-4c-3.771 0-5.657 0-6.828-1.172S2 16.771 2 13z"/><path stroke-linecap="round" d="M9 21V3"/></g></svg>
diff --git a/crates/ui/assets/icons/sidebar-minimalistic.svg b/crates/ui/assets/icons/sidebar-minimalistic.svg
deleted file mode 100644
index ed94e9e580..0000000000
--- a/crates/ui/assets/icons/sidebar-minimalistic.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="1.5"><path d="M2 11c0-3.771 0-5.657 1.172-6.828S6.229 3 10 3h4c3.771 0 5.657 0 6.828 1.172S22 7.229 22 11v2c0 3.771 0 5.657-1.172 6.828S17.771 21 14 21h-4c-3.771 0-5.657 0-6.828-1.172S2 16.771 2 13z"/><path stroke-linecap="round" d="M15 21V3"/></g></svg>
\ No newline at end of file
diff --git a/crates/ui/assets/icons/worktree.svg b/crates/ui/assets/icons/worktree.svg
new file mode 100644
index 0000000000..cea0138cc7
--- /dev/null
+++ b/crates/ui/assets/icons/worktree.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M6 8.5v7M8.25 6.25H16a2 2 0 0 1 2 2v7.25"/><circle cx="6" cy="6.25" r="2.25"/><circle cx="6" cy="17.75" r="2.25"/><circle cx="18" cy="17.75" r="2.25"/></svg>
diff --git a/crates/ui/examples/project-selector-fixture.rs b/crates/ui/examples/project-selector-fixture.rs
index 1fcbb2f166..d038555738 100644
--- a/crates/ui/examples/project-selector-fixture.rs
+++ b/crates/ui/examples/project-selector-fixture.rs
@@ -1,5 +1,6 @@
 //! Native project selector review fixture, with isolated synthetic data.
 //! Run under a desktop/Xvfb, then click the sidebar's "All projects" selector.
+//! ZERON_FIXTURE_PROJECT=<space id> starts the new-session canvas on that project.
 use gpui::{AppContext, Bounds, WindowBounds, WindowOptions, point, px, size};
 use zeron_ui::*;
 
@@ -38,11 +39,14 @@ fn main() {
             s.chats_synced = true;
             s.spaces_synced = true;
             s.spaces = serde_json::from_value(serde_json::json!([
-                {"id":"a","deviceId":"local","path":"/projects/anara","createdAt":"2026-09-15T00:00:00Z"},
-                {"id":"b","deviceId":"remote","path":"/projects/anara","createdAt":"2026-09-15T00:00:00Z"},
+                {"id":"a","deviceId":"local","path":"/projects/anara","repositoryId":"github.com/anara/anara","createdAt":"2026-09-15T00:00:00Z"},
+                {"id":"b","deviceId":"remote","path":"/projects/anara","repositoryId":"github.com/anara/anara","createdAt":"2026-09-15T00:00:00Z"},
                 {"id":"c","deviceId":"long","path":"/projects/design-system-with-a-long-project-name","createdAt":"2026-09-15T00:00:00Z"},
                 {"id":"d","deviceId":"unknown","path":"/projects/fieldnotes","createdAt":"2026-09-15T00:00:00Z"}
             ])).unwrap();
+            if let Ok(space) = std::env::var("ZERON_FIXTURE_PROJECT") {
+                s.selected_space = Some(space);
+            }
             s
         });
         let boot = EngineBootConfig { data_dir: data, ipc_port: 0, edge_url: String::new(),
diff --git a/crates/ui/examples/sidebar-fixture.rs b/crates/ui/examples/sidebar-fixture.rs
index bfd7342848..d59d03b7d0 100644
--- a/crates/ui/examples/sidebar-fixture.rs
+++ b/crates/ui/examples/sidebar-fixture.rs
@@ -1,4 +1,5 @@
-//! Isolated native sidebar review fixture. ZERON_SIDEBAR_COMPACT / ZERON_SIDEBAR_HIDE_LABEL select layout.
+//! Isolated native sidebar review fixture. ZERON_SIDEBAR_COMPACT / ZERON_SIDEBAR_HIDE_LABEL select layout;
+//! ZERON_SIDEBAR_BY_PROJECT groups by project, with a remote clone of the local repository.
 use gpui::{AppContext, Bounds, WindowBounds, WindowOptions, px, size};
 use zeron_ui::*;
 
@@ -14,7 +15,8 @@ fn main() -> anyhow::Result<()> {
         settings.sidebar_show_branch = true;
         settings.sidebar_compact = std::env::var_os("ZERON_SIDEBAR_COMPACT").is_some();
         settings.sidebar_show_project_label = std::env::var_os("ZERON_SIDEBAR_HIDE_LABEL").is_none();
-        settings.sidebar_organization = settings::SidebarOrganization::InOneList;
+        let by_project = std::env::var_os("ZERON_SIDEBAR_BY_PROJECT").is_some();
+        settings.sidebar_organization = if by_project { settings::SidebarOrganization::ByProject } else { settings::SidebarOrganization::InOneList };
         settings.sidebar_width = 310.0;
         settings.sidebar_pins_mut("local".into()).extend(["chat-0".into(), "chat-1".into()]);
         let project_path = data.join("fieldnotes");
@@ -75,6 +77,13 @@ fn main() -> anyhow::Result<()> {
                     change_request: Some(zeron_proto::ChangeRequestSummary { provider: "github".into(), number: 412 + ix as u64, title: chat.title.clone().unwrap(), url: "https://github.com/zeronsh/zeron/pull/412".into(), state: zeron_proto::ChangeRequestState::Open, base_ref: "main".into(), head_ref: source.branch.clone() }),
                 });
             }
+            if by_project {
+                s.spaces[0].repository_id = Some("github.com/zeronsh/fieldnotes".into());
+                s.spaces.push(serde_json::from_value(serde_json::json!({"id":"fieldnotes-remote","deviceId":"remote","path":"/projects/fieldnotes","repositoryId":"github.com/zeronsh/fieldnotes","createdAt":chrono::Utc::now()})).unwrap());
+                for ix in [3, 7] {
+                    s.chats[ix].space_id = Some("fieldnotes-remote".into());
+                }
+            }
             s.chats[4].last_message_at = Some(chrono::Utc::now());
             s.chats[8].archived = true;
             s
@@ -84,8 +93,11 @@ fn main() -> anyhow::Result<()> {
             window_bounds: Some(WindowBounds::Windowed(Bounds::new(gpui::point(px(12.),px(30.)), size(px(1100.),px(800.))))),
             titlebar: Some(gpui::TitlebarOptions { title: None, appears_transparent: true, traffic_light_position: Some(gpui::point(px(14.),px(14.))) }),
             app_owns_titlebar_drag: true,
+            // Same backdrop as the app window, or the frosted surface has nothing to blur.
+            window_background: theme::Theme::of(cx).window_background_appearance(),
             ..Default::default()
         }, |_, cx| cx.new(|cx| shell::Shell::new(state.clone(), boot, cx))).unwrap();
+        appearance::reapply_window_background(cx);
         state.update(cx, |_, cx| cx.notify());
         cx.activate(true);
     });
diff --git a/crates/ui/src/change_requests.rs b/crates/ui/src/change_requests.rs
index fb51b0e562..d660830994 100644
--- a/crates/ui/src/change_requests.rs
+++ b/crates/ui/src/change_requests.rs
@@ -393,6 +393,7 @@ mod tests {
             git_detected: true,
             git_checked_at: None,
             checkout_id: Some("checkout".into()),
+            repository_id: None,
             created_at: Utc.timestamp_opt(0, 0).unwrap(),
         }
     }
diff --git a/crates/ui/src/files/sections.rs b/crates/ui/src/files/sections.rs
index a167316044..abc9398f41 100644
--- a/crates/ui/src/files/sections.rs
+++ b/crates/ui/src/files/sections.rs
@@ -563,7 +563,7 @@ impl FilesSurface {
             .child(
                 header_action(
                     "files-sections-fork",
-                    icons::GIT_BRANCH,
+                    icons::FORK,
                     "Fork this chat",
                     theme,
                 )
@@ -838,7 +838,7 @@ impl FilesSurface {
                 .child(
                     pill_button(
                         "files-sections-empty-fork",
-                        icons::GIT_BRANCH,
+                        icons::FORK,
                         "Fork",
                         theme,
                     )
diff --git a/crates/ui/src/icons.rs b/crates/ui/src/icons.rs
index 20d990664a..832c7b27c6 100644
--- a/crates/ui/src/icons.rs
+++ b/crates/ui/src/icons.rs
@@ -16,7 +16,10 @@
 
 use std::borrow::Cow;
 
-use gpui::{AssetSource, Hsla, Result, SharedString, Styled as _, Svg, svg};
+use gpui::{
+    AssetSource, Div, Hsla, ParentElement as _, Result, SharedString, Styled as _, Svg, div, px,
+    svg,
+};
 
 macro_rules! icon_assets {
     ($(($const_name:ident, $path:literal)),+ $(,)?) => {
@@ -83,26 +86,28 @@ icon_assets![
     (FOLDER_WITH_FILES, "folder-with-files"),
     // Original tree glyph with compact nodes for the independent Files panel.
     (FILE_TREE, "file-tree"),
-    (FOLDER, "folder"),
     // Hand-drawn floppy disk in the Solar Linear style. Workspace editor save.
     (FLOPPY_DISK, "floppy-disk"),
-    // Hand-drawn git-branch glyph in the Solar Linear style (like the
-    // terminal/plus/return ports) — the set has no branch icon.
+    // Zeron Icons (icons.zeron.sh): 24px canvas, 1.75px round strokes. The
+    // git family shares rails at x=6/18 and 2.25-radius nodes; the carets
+    // and arrows are the site's one path pre-rotated per direction.
+    (FOLDER, "folder"),
+    (FORK, "fork"),
     (GIT_BRANCH, "git-branch"),
-    // Provider-neutral pull-request glyph, drawn in the same linear family.
     (PULL_REQUEST, "pull-request"),
+    (WORKTREE, "worktree"),
+    (PLUS, "plus"),
+    (ARROW_LEFT, "arrow-left"),
+    (ARROW_RIGHT, "arrow-right"),
+    (ALT_ARROW_DOWN, "alt-arrow-down"),
+    (ALT_ARROW_UP, "alt-arrow-up"),
+    (ALT_ARROW_LEFT, "alt-arrow-left"),
+    (ALT_ARROW_RIGHT, "alt-arrow-right"),
     // Compact history-ref glyphs, drawn in the same linear style.
     (CLOUD, "cloud"),
     (TAG, "tag"),
-    (SIDEBAR_MINIMALISTIC, "sidebar-minimalistic"),
-    // Mirrored variant (zeron window-controls.tsx `-scale-x-100`): the LEFT
-    // sidebar toggle shows the panel line on the left; gpui divs have no
-    // scale transform at the pinned rev, so the flip is baked into the asset.
-    (SIDEBAR_MINIMALISTIC_LEFT, "sidebar-minimalistic-left"),
     (KEY_MINIMALISTIC, "key-minimalistic"),
     (KEYBOARD, "keyboard"),
-    (ARROW_LEFT, "arrow-left"),
-    (ARROW_RIGHT, "arrow-right"),
     (ARROW_UP, "arrow-up"),
     // arrow-up mirrored (like the sidebar flip) — the Solar Linear set here
     // has no plain arrow-down.
@@ -113,11 +118,6 @@ icon_assets![
     // Hand-drawn return/enter arrow in the Solar Linear style (like the
     // terminal/plus/close ports) — the set has no return glyph.
     (RETURN, "return"),
-    (ALT_ARROW_DOWN, "alt-arrow-down"),
-    // alt-arrow-down mirrored (drawn as its twin: same stroke, caps, joints) —
-    // the embedded Solar Linear set ships no up chevron. The collapse half of
-    // the long-user-message expander.
-    (ALT_ARROW_UP, "alt-arrow-up"),
     // Hand-drawn expand/maximize arrows in the Solar Linear style (like the
     // terminal/plus/return ports) — the set has no expand glyph.
     (EXPAND_ARROWS, "expand-arrows"),
@@ -131,8 +131,6 @@ icon_assets![
     (SPLIT_COLUMNS, "split-columns"),
     // Long-line wrapping toggle shared by changes and agent Markdown fences.
     (WRAP_TEXT, "wrap-text"),
-    (ALT_ARROW_LEFT, "alt-arrow-left"),
-    (ALT_ARROW_RIGHT, "alt-arrow-right"),
     (SMARTPHONE, "smartphone"),
     (ARCHIVE_UP_MINIMALISTIC, "archive-up-minimalistic"),
     (REFRESH, "refresh"),
@@ -184,7 +182,6 @@ icon_assets![
     // Hand-drawn zeron glyphs (terminal-panel.tsx / composer-actions.tsx /
     // menu-check.tsx / logo.tsx).
     (TERMINAL, "terminal"),
-    (PLUS, "plus"),
     (CLOSE, "close"),
     // Hand-drawn Linux caption glyphs (minimize dash, maximize square,
     // restore stacked squares) in the same style as `close` — drawn for the
@@ -258,6 +255,47 @@ pub fn icon(path: &'static str) -> Svg {
     svg().path(path).flex_none()
 }
 
+/// The Zeron Icons sidebar glyph (icons.zeron.sh "Sidebar" / "Right
+/// sidebar"): a rounded frame holding a panel whose width morphs 5.5 → 1.75
+/// as the sidebar closes. gpui SVGs are static, so it is drawn from quads in
+/// the source's 24-unit space, scaled to `size`. `open` is the morph progress
+/// (1 = open; drive it with [`crate::motion::state_t`]); `right` mirrors it.
+pub fn sidebar_glyph(open: f32, right: bool, size: f32, color: Hsla) -> Div {
+    let s = size / 24.0;
+    // `<rect x=3 y=4 w=18 h=16 rx=4 stroke-width=1.75>`: the centered stroke
+    // grows the box by half the stroke on each side.
+    let stroke = 1.75;
+    let frame = div()
+        .absolute()
+        .left(px((3.0 - stroke / 2.0) * s))
+        .top(px((4.0 - stroke / 2.0) * s))
+        .w(px((18.0 + stroke) * s))
+        .h(px((16.0 + stroke) * s))
+        .rounded(px((4.0 + stroke / 2.0) * s))
+        .border(px(stroke * s))
+        .border_color(color);
+    // `<rect class=zi-panel x=6.5 y=7.5 w=5.5 h=9 rx=.875>`; closed: w=1.75.
+    let inset = px(6.5 * s);
+    let panel = div()
+        .absolute()
+        .top(px(7.5 * s))
+        .w(px(crate::motion::lerp(1.75, 5.5, open.clamp(0.0, 1.0)) * s))
+        .h(px(9.0 * s))
+        .rounded(px(0.875 * s))
+        .bg(color);
+    let panel = if right {
+        panel.right(inset)
+    } else {
+        panel.left(inset)
+    };
+    div()
+        .relative()
+        .flex_none()
+        .size(px(size))
+        .child(frame)
+        .child(panel)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index bd30fcdf29..1f12719451 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -53,6 +53,7 @@ pub mod popover;
 pub mod project_actions;
 pub mod queue;
 pub mod rail;
+mod roll_text;
 pub mod settings;
 pub mod shell;
 pub mod sound;
diff --git a/crates/ui/src/motion.rs b/crates/ui/src/motion.rs
index 4b91ab786a..31f8afa958 100644
--- a/crates/ui/src/motion.rs
+++ b/crates/ui/src/motion.rs
@@ -464,6 +464,9 @@ pub const EASE_TAILWIND: CubicBezier = CubicBezier::new(0.4, 0.0, 0.2, 1.0);
 /// CSS `transition-colors` default: 150ms over [`EASE_TAILWIND`] — the temporal
 /// blend every interactive hover wash rides in the original.
 pub const HOVER_FADE: MotionSpec = MotionSpec::new(150, EASE_TAILWIND);
+/// Zeron Icons (icons.zeron.sh) state morph: `--zi-duration: 280ms` over
+/// `cubic-bezier(.22, 1, .36, 1)` — the sidebar glyph's panel open ↔ closed.
+pub const GLYPH_STATE: MotionSpec = MotionSpec::new(280, EASE_OUT_QUINT);
 /// Zeron loader pulse period: 2.4s.
 pub const ZERON_PULSE: MotionSpec = MotionSpec::new(2400, EASE);
 /// Gradient matrix spinner wave period: 750ms.
@@ -889,6 +892,128 @@ pub fn hover_blend(key: &str, rest: Hsla, hover: Hsla) -> Hsla {
     mix(rest, hover, hover_t(key))
 }
 
+// ---------------------------------------------------------------------------
+// Two-state glyph morphs (CSS `transition` on a `data-state` flip)
+// ---------------------------------------------------------------------------
+//
+// Zeron Icons morph between two states (the sidebar glyph's panel narrows when
+// the sidebar closes). Same manual clock and liveness rules as the hover
+// fades, but keyed by the element's *state* rather than pointer events: the
+// first read of a key snaps to its state (mounting never replays a morph), a
+// flip re-anchors at the current value so a mid-flight toggle reverses
+// smoothly, and an entry unread for a full frame is pruned.
+
+#[derive(Debug, Clone, Copy)]
+struct StateEntry {
+    origin: f32,
+    target: f32,
+    started: Instant,
+    spec: MotionSpec,
+    seen: u64,
+}
+
+impl StateEntry {
+    fn duration(&self) -> Duration {
+        self.spec.total().mul_f32(speed_scale())
+    }
+
+    fn value(&self, now: Instant) -> f32 {
+        let duration = self.duration();
+        let elapsed = now.saturating_duration_since(self.started);
+        if duration.is_zero() || elapsed >= duration {
+            return self.target;
+        }
+        let raw = elapsed.as_secs_f32() / duration.as_secs_f32();
+        lerp(self.origin, self.target, self.spec.progress(raw))
+    }
+
+    fn settled(&self, now: Instant) -> bool {
+        self.origin == self.target || now.saturating_duration_since(self.started) >= self.duration()
+    }
+}
+
+/// Per-key state-morph store. Pure core (explicit `now`) — unit-testable.
+#[derive(Default)]
+pub struct StateMorphs {
+    entries: HashMap<String, StateEntry>,
+    frame: u64,
+}
+
+impl StateMorphs {
+    /// Progress (0 = off, 1 = on) of `key` toward `on` at `now`; stamps
+    /// liveness. Reduced motion snaps a flip straight to its endpoint.
+    pub fn value_at(
+        &mut self,
+        key: &str,
+        on: bool,
+        spec: MotionSpec,
+        reduced: bool,
+        now: Instant,
+    ) -> f32 {
+        let target = if on { 1.0 } else { 0.0 };
+        let frame = self.frame;
+        let Some(entry) = self.entries.get_mut(key) else {
+            self.entries.insert(
+                key.to_string(),
+                StateEntry {
+                    origin: target,
+                    target,
+                    started: now,
+                    spec,
+                    seen: frame,
+                },
+            );
+            return target;
+        };
+        if entry.target != target {
+            let current = entry.value(now);
+            *entry = StateEntry {
+                origin: if reduced { target } else { current },
+                target,
+                started: now,
+                spec,
+                seen: frame,
+            };
+        }
+        entry.seen = frame;
+        entry.value(now)
+    }
+
+    /// Once-per-frame bookkeeping: prune unmounted entries and report whether
+    /// any morph is still mid-flight (→ keep frames coming).
+    pub fn tick_at(&mut self, now: Instant) -> bool {
+        self.frame += 1;
+        let frame = self.frame;
+        let mut active = false;
+        self.entries.retain(|_, entry| {
+            if entry.seen + 1 < frame {
+                return false;
+            }
+            active |= !entry.settled(now);
+            true
+        });
+        active
+    }
+}
+
+thread_local! {
+    static STATE_MORPHS: RefCell<StateMorphs> = RefCell::new(StateMorphs::default());
+}
+
+/// Morph progress (0..1) of `key` toward `on` this frame.
+pub fn state_t(key: &str, on: bool, spec: MotionSpec, reduced: bool) -> f32 {
+    STATE_MORPHS.with(|morphs| {
+        morphs
+            .borrow_mut()
+            .value_at(key, on, spec, reduced, Instant::now())
+    })
+}
+
+/// Frame-drive hook, beside [`hover_fades_active`]: call ONCE per window frame.
+pub fn state_morphs_active() -> bool {
+    STATE_MORPHS.with(|morphs| morphs.borrow_mut().tick_at(Instant::now()))
+}
+
 // ---------------------------------------------------------------------------
 // Reduced motion
 // ---------------------------------------------------------------------------
@@ -1512,6 +1637,38 @@ mod tests {
         assert_eq!(fades.value_at("pill", ms(225)), 0.0, "lands at rest");
     }
 
+    #[test]
+    fn state_morph_snaps_on_mount_and_reverses_continuously() {
+        let mut morphs = StateMorphs::default();
+        let t0 = Instant::now();
+        let ms = |m: u64| t0 + Duration::from_millis(m);
+        let morph = |m: &mut StateMorphs, on, at| m.value_at("glyph", on, GLYPH_STATE, false, at);
+
+        // First sight lands on the state — no replay at mount.
+        assert_eq!(morph(&mut morphs, true, t0), 1.0);
+        assert!(!morphs.tick_at(t0));
+
+        // Flip: starts from 1, mid-flight strictly between, lands at 0.
+        assert_eq!(morph(&mut morphs, false, ms(10)), 1.0);
+        let mid = morph(&mut morphs, false, ms(80));
+        assert!(mid > 0.0 && mid < 1.0, "mid-flight: {mid}");
+        assert!(morphs.tick_at(ms(80)));
+
+        // Reverse mid-flight re-anchors — no jump — then lands at 1.
+        let at_flip = morph(&mut morphs, true, ms(80));
+        assert!((at_flip - mid).abs() < 1e-4, "continuity: {mid} vs {at_flip}");
+        assert_eq!(morph(&mut morphs, true, ms(400)), 1.0);
+        assert!(!morphs.tick_at(ms(400)));
+
+        // Reduced motion snaps a flip.
+        assert_eq!(morphs.value_at("glyph", false, GLYPH_STATE, true, ms(500)), 0.0);
+
+        // Unread for a full frame: pruned (a remount snaps again).
+        morphs.tick_at(ms(600));
+        morphs.tick_at(ms(700));
+        assert!(morphs.entries.is_empty());
+    }
+
     #[test]
     fn hover_fade_reduced_motion_snaps() {
         let mut fades = HoverFades::default();
diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 4f8826da06..989936c9ad 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -13,7 +13,8 @@
 
 mod compact;
 
-use std::collections::HashMap;
+use crate::roll_text::{roll_text, rolling};
+use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::time::Duration;
 
@@ -405,6 +406,25 @@ pub fn browser_rows(listing: &FolderListing) -> Vec<&zeron_proto::FolderEntry> {
 /// the first Down lands on row 0.
 const NO_ACTIVE_ROW: usize = usize::MAX;
 
+/// One project-picker row: every space of a project
+/// ([`zeron_proto::view::project_key`]), named for its representative.
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct ProjectRow {
+    key: String,
+    name: String,
+}
+
+/// One device-picker row: a device, and the picked project's checkout on it.
+#[derive(Clone, Debug, PartialEq)]
+struct DeviceRow {
+    device_id: String,
+    name: String,
+    /// The project's space on this device; `None` when no project is picked.
+    space: Option<Space>,
+    /// The checkout's path, when the device holds several of the project.
+    detail: Option<String>,
+}
+
 /// What names the selected model, shared by the composer chip and the
 /// compact panel so the two never disagree about it.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -595,9 +615,10 @@ pub struct Pickers {
     chip_resizing: bool,
     open_model_height: f32,
     compact_model_list: bool,
-    /// The compact picker's provider page, entered from the panel's
-    /// provider button; exclusive with [`Self::compact_model_list`].
-    compact_providers: bool,
+    /// The model list's provider tab strip: its sideways scroll, and the
+    /// tab last brought into view as the list scrolled.
+    compact_strip_scroll: gpui::ScrollHandle,
+    compact_strip_viewed: Option<usize>,
     effort_dragging: bool,
     compact_motion: compact::CompactMotion,
     compact_keyboard: bool,
@@ -624,9 +645,26 @@ pub struct Pickers {
     harnesses: Loadable<Vec<HarnessDescriptor>>,
     models: HashMap<HarnessId, Loadable<Vec<Model>>>,
     model_refresh_errors: HashMap<HarnessId, String>,
+    /// The loaded harness list belongs to the previous device: reload it
+    /// once, keeping its rows on screen meanwhile (see the state observer).
+    harnesses_stale: bool,
+    /// The stale harness list's reload is in flight (one request).
+    harnesses_revalidating: bool,
+    /// Loaded model slots still holding the previous device's catalog: shown
+    /// while the new device's reload runs, never used to resolve a send, and
+    /// cleared only when the new device's answer lands (a failure replaces
+    /// the rows rather than keeping the wrong device's).
+    stale_models: HashSet<HarnessId>,
+    /// Stale slots whose reload is in flight (one request per slot).
+    revalidating: HashSet<HarnessId>,
     refs: Loadable<Vec<RepoRef>>,
     /// Space id the `refs` slot belongs to (invalidated on space change).
     refs_space: Option<String>,
+    /// The previous project's resolved ref, shown ONLY by the checkout and
+    /// branch chip labels until this project's refs land — so a project
+    /// switch never blinks them through "Select ref". Never read by the
+    /// popover or the send plan.
+    held_ref: Option<RepoRef>,
     /// Highlighted row in the open list (keyboard nav).
     active: usize,
     /// Models-list scroll — keyboard nav keeps the highlighted row in view.
@@ -761,22 +799,36 @@ impl Pickers {
             // (and possibly the device) changed under them.
             let space = state.read(cx).selected_space.clone();
             let device = state.read(cx).effective_device_id();
-            if space != this.space_owner || device != this.device_owner {
+            let device_changed = device != this.device_owner;
+            if space != this.space_owner || device_changed {
                 this.space_owner = space;
                 this.device_owner = device;
-                this.target_generation = this.target_generation.wrapping_add(1);
                 this.setting_menu = None;
                 this.setting_bounds = None;
+                this.held_ref = this.selected_ref().cloned().or(this.held_ref.take());
                 this.refs_task = None;
-                this.load_task = None;
                 this.config.branch = None;
                 this.config.checkout = CheckoutKind::default();
                 this.refs = Loadable::Idle;
                 this.refs_space = None;
-                // Catalogs are per-DEVICE (fetched from the space's host):
-                // a space switch may land on another device, so refetch.
-                this.harnesses = Loadable::Idle;
-                this.models.clear();
+            }
+            // Catalogs are per-DEVICE (fetched from the space's host), so a
+            // project switch on the same device keeps them. A device switch
+            // revalidates against the new host with the loaded rows still on
+            // screen, so the model chip never blanks; in-flight loads for
+            // the old host are discarded by the generation bump and restart.
+            if device_changed {
+                this.target_generation = this.target_generation.wrapping_add(1);
+                this.load_task = None;
+                this.harnesses_revalidating = false;
+                if matches!(this.harnesses, Loadable::Ready(_)) {
+                    this.harnesses_stale = true;
+                } else {
+                    this.harnesses = Loadable::Idle;
+                }
+                this.models.retain(|_, slot| matches!(slot, Loadable::Ready(_)));
+                this.stale_models = this.models.keys().copied().collect();
+                this.revalidating.clear();
                 this.model_refresh_errors.clear();
                 this.catalog_rev += 1;
             }
@@ -831,7 +883,8 @@ impl Pickers {
             chip_resizing: false,
             open_model_height: model_menu_height(0),
             compact_model_list: false,
-            compact_providers: false,
+            compact_strip_scroll: gpui::ScrollHandle::new(),
+            compact_strip_viewed: None,
             effort_dragging: false,
             compact_motion: compact::CompactMotion::default(),
             compact_keyboard: false,
@@ -858,8 +911,13 @@ impl Pickers {
             harnesses: Loadable::Idle,
             models: HashMap::new(),
             model_refresh_errors: HashMap::new(),
+            harnesses_stale: false,
+            harnesses_revalidating: false,
+            stale_models: HashSet::new(),
+            revalidating: HashSet::new(),
             refs: Loadable::Idle,
             refs_space: None,
+            held_ref: None,
             active: 0,
             model_scroll: gpui::UniformListScrollHandle::new(),
             model_rows_cache: std::cell::RefCell::new(None),
@@ -972,8 +1030,12 @@ impl Pickers {
         // New-chat canvas: the remembered last-used harness (sticky defaults),
         // when the loaded catalog still offers it (the device may have
         // disabled it in Settings → Providers since).
+        // A list still from the previous device reads as not loaded: it may
+        // offer harnesses this device lacks, and what the chip shows must be
+        // what a send would carry.
+        let fresh = self.harnesses.ready().filter(|_| !self.harnesses_stale);
         if let Some(harness) = self.defaults.harness {
-            let offered = match self.harnesses.ready() {
+            let offered = match fresh {
                 Some(list) => offered_harnesses(list).iter().any(|d| d.id == harness),
                 None => true, // catalog not loaded yet — trust the memory
             };
@@ -985,9 +1047,7 @@ impl Pickers {
         // harness first, and resolving chips against it would boot the
         // new-chat canvas onto "Mock" instead of Claude Code + its default
         // model (it stays available under `ZERON_HARNESS=mock`).
-        self.harnesses
-            .ready()
-            .and_then(|list| offered_harnesses(list).first().map(|d| d.id))
+        fresh.and_then(|list| offered_harnesses(list).first().map(|d| d.id))
     }
 
     /// Effective model id: the draft pick, the selected chat's config, or (on
@@ -1012,8 +1072,10 @@ impl Pickers {
     /// Effective reasoning — always concrete once the model is known: the
     /// draft pick / chat config / remembered default, clamped to the selected
     /// model's ladder, falling back to the model's default level.
-    fn effective_reasoning(&self, cx: &App) -> Option<ReasoningLevel> {
-        let explicit = self.config.reasoning.or_else(|| {
+    /// The reasoning level picked, configured or remembered — before any
+    /// clamping to the selected model's ladder.
+    fn explicit_reasoning(&self, cx: &App) -> Option<ReasoningLevel> {
+        self.config.reasoning.or_else(|| {
             match self.state.read(cx).selected_chat_row() {
                 Some(chat) => chat.config.as_ref().and_then(|c| c.reasoning),
                 // New chat: the level last used with this model, else the
@@ -1023,8 +1085,17 @@ impl Pickers {
                     .and_then(|h| self.defaults.reasoning_for(h, self.effective_model_id(cx)))
                     .or(self.defaults.reasoning),
             }
-        });
-        if self.selected_model(cx).is_none() {
+        })
+    }
+
+    fn effective_reasoning(&self, cx: &App) -> Option<ReasoningLevel> {
+        let explicit = self.explicit_reasoning(cx);
+        // The old device's ladder must not clamp the chip's level either:
+        // a send in this window carries the unclamped value.
+        let stale = self
+            .effective_harness(cx)
+            .is_some_and(|h| self.stale_models.contains(&h));
+        if stale || self.selected_model(cx).is_none() {
             // Catalog not loaded yet: show the explicit value as-is (nothing
             // to clamp against); it resolves to a concrete level on load.
             return explicit;
@@ -1052,7 +1123,9 @@ impl Pickers {
         if let Some(label) = self.selected_model_label(cx) {
             return ModelName::Named(label.into());
         }
-        let catalog_loading = matches!(self.harnesses, Loadable::Idle | Loadable::Loading);
+        // A list still from the previous device is loading for this one.
+        let catalog_loading = self.harnesses_stale
+            || matches!(self.harnesses, Loadable::Idle | Loadable::Loading);
         let models_loading = self.effective_harness(cx).is_some_and(|harness| {
             !matches!(
                 self.models.get(&harness),
@@ -1123,8 +1196,10 @@ impl Pickers {
     /// enabled). False while the catalog is still loading or failed
     /// (nothing to conclude yet; offline sends must not be blocked on it).
     pub fn no_agents_available(&self) -> bool {
+        // The previous device's list can't speak for this one.
         self.harnesses
             .ready()
+            .filter(|_| !self.harnesses_stale)
             .is_some_and(|list| self.offered(list).is_empty())
     }
 
@@ -1144,8 +1219,20 @@ impl Pickers {
     /// `Mutate createChat`: concrete model + reasoning whenever the catalog is
     /// loaded (no "engine picks a default" passthrough).
     pub fn resolved(&self, cx: &App) -> ResolvedRunConfig {
+        let harness = self.effective_harness(cx);
+        // A catalog still from the previous device must not pick for this
+        // one (its default model, its effort ladder): send only what was
+        // chosen or remembered, as when no catalog has loaded.
+        if harness.is_some_and(|h| self.stale_models.contains(&h)) {
+            return ResolvedRunConfig {
+                harness,
+                model: self.effective_model_id(cx).map(str::to_string),
+                reasoning: self.explicit_reasoning(cx),
+                model_options: self.explicit_options(cx),
+            };
+        }
         ResolvedRunConfig {
-            harness: self.effective_harness(cx),
+            harness,
             model: self
                 .selected_model(cx)
                 .map(|m| m.id.clone())
@@ -1244,7 +1331,7 @@ impl Pickers {
         if kind == PickerKind::HarnessModel {
             self.open_model_height = model_menu_height(self.setting_groups(cx).len());
             self.compact_model_list = false;
-            self.compact_providers = false;
+            self.compact_strip_viewed = None;
             self.effort_dragging = false;
             self.compact_keyboard = false;
             self.compact_motion = compact::CompactMotion::default();
@@ -1299,7 +1386,7 @@ impl Pickers {
             },
             PickerKind::Branch => self.selected_ref_index(cx),
             PickerKind::HarnessModel => self.selected_model_index(cx),
-            PickerKind::Space => self.selected_space_index(cx),
+            PickerKind::Space => self.selected_project_index(cx),
             PickerKind::Device => self.selected_device_index(cx),
         };
         if kind == PickerKind::HarnessModel {
@@ -1379,7 +1466,9 @@ impl Pickers {
         let reload = match self.harnesses {
             Loadable::Idle => true,
             Loadable::Loading => false,
-            Loadable::Ready(_) | Loadable::Error(_) => force,
+            Loadable::Ready(_) | Loadable::Error(_) => {
+                force || (self.harnesses_stale && !self.harnesses_revalidating)
+            }
         };
         if !reload {
             return;
@@ -1387,6 +1476,9 @@ impl Pickers {
         let Some(engine) = self.engine(cx) else {
             return;
         };
+        if self.harnesses_stale {
+            self.harnesses_revalidating = true;
+        }
         let target = self.space_target(cx);
         let generation = self.target_generation;
         if !matches!(self.harnesses, Loadable::Ready(_)) {
@@ -1412,6 +1504,8 @@ impl Pickers {
                 if pickers.target_generation != generation {
                     return;
                 }
+                pickers.harnesses_stale = false;
+                pickers.harnesses_revalidating = false;
                 pickers.catalog_rev += 1;
                 pickers.harnesses = match result {
                     Ok(value) => match serde_json::from_value::<Vec<HarnessDescriptor>>(value) {
@@ -1456,7 +1550,11 @@ impl Pickers {
         let reload = match self.models.get(&harness) {
             None | Some(Loadable::Idle) => true,
             Some(Loadable::Loading) => false,
-            Some(Loadable::Ready(_)) | Some(Loadable::Error(_)) => force,
+            Some(Loadable::Ready(_)) | Some(Loadable::Error(_)) => {
+                force
+                    || (self.stale_models.contains(&harness)
+                        && !self.revalidating.contains(&harness))
+            }
         };
         if !reload {
             return;
@@ -1464,6 +1562,9 @@ impl Pickers {
         let Some(engine) = self.engine(cx) else {
             return;
         };
+        if self.stale_models.contains(&harness) {
+            self.revalidating.insert(harness);
+        }
         let target = self.space_target(cx);
         let generation = self.target_generation;
         if !matches!(self.models.get(&harness), Some(Loadable::Ready(_))) {
@@ -1523,13 +1624,29 @@ impl Pickers {
                     },
                     Err(err) => Loadable::Error(err.to_string()),
                 };
-                pickers.apply_model_catalog(harness, loaded, cx);
+                pickers.land_model_reload(harness, loaded, cx);
             })
             .ok();
         })
         .detach();
     }
 
+    /// A model load for the current device landed. A slot that still held
+    /// the previous device's rows is current again either way — on failure
+    /// the error replaces those rows instead of being retained under them.
+    fn land_model_reload(
+        &mut self,
+        harness: HarnessId,
+        loaded: Loadable<Vec<Model>>,
+        cx: &mut Context<Self>,
+    ) {
+        self.revalidating.remove(&harness);
+        if self.stale_models.remove(&harness) && matches!(loaded, Loadable::Error(_)) {
+            self.models.remove(&harness);
+        }
+        self.apply_model_catalog(harness, loaded, cx);
+    }
+
     fn apply_model_catalog(
         &mut self,
         harness: HarnessId,
@@ -1621,6 +1738,7 @@ impl Pickers {
                 .call(methods::LIST_REFS, serde_json::Value::Object(params))
                 .await;
             this.update(cx, |pickers, cx| {
+                pickers.held_ref = None;
                 pickers.refs = match result {
                     Ok(value) => match serde_json::from_value::<Vec<RepoRef>>(value) {
                         Ok(refs) => Loadable::Ready(refs),
@@ -2117,8 +2235,6 @@ impl Pickers {
     fn activate_model_row(&mut self, cx: &mut Context<Self>) {
         if self.setting_menu.is_some() {
             self.activate_setting_choice(cx);
-        } else if self.compact_model_picker(cx) && self.compact_providers {
-            self.activate_compact_provider(cx);
         } else if self.compact_model_picker(cx) && self.compact_model_list {
             self.activate_model_index(self.active, cx);
         } else if let Some(index) = self.active.checked_sub(self.model_rows_len(cx)) {
@@ -2228,6 +2344,20 @@ impl Pickers {
             .or_else(|| self.selected_ref().map(|r| r.name.clone()))
     }
 
+    /// The ref the checkout and branch chips name: the resolved one, else —
+    /// while a project switch's refs load — the previous project's.
+    fn display_ref(&self) -> Option<&RepoRef> {
+        match self.refs {
+            Loadable::Idle | Loadable::Loading => self.selected_ref().or(self.held_ref.as_ref()),
+            _ => self.selected_ref(),
+        }
+    }
+
+    fn display_ref_is_worktree(&self) -> bool {
+        self.display_ref()
+            .is_some_and(|row| row.worktree_path.is_some())
+    }
+
     /// The existing worktree the picked ref is materialized in, if any.
     fn selected_ref_worktree(&self) -> Option<String> {
         self.selected_ref().and_then(|r| r.worktree_path.clone())
@@ -2257,7 +2387,7 @@ impl Pickers {
         match self.config.checkout {
             CheckoutKind::NewWorktree => "New worktree",
             CheckoutKind::Local => {
-                if self.selected_ref_worktree().is_some() {
+                if self.display_ref_is_worktree() {
                     "Current worktree"
                 } else {
                     "Current checkout"
@@ -2269,65 +2399,100 @@ impl Pickers {
     /// Label of the ref trigger: `From <ref>` only when a NEW worktree will be
     /// created off it (t3code `getBranchTriggerLabel`); the bare name otherwise.
     fn ref_label(&self) -> SharedString {
-        match (self.config.checkout, self.effective_ref_name()) {
+        let name = self
+            .config
+            .branch
+            .clone()
+            .or_else(|| self.display_ref().map(|row| row.name.clone()));
+        match (self.config.checkout, name) {
             (_, None) => SharedString::from("Select ref"),
             (CheckoutKind::NewWorktree, Some(name)) => SharedString::from(format!("From {name}")),
             (CheckoutKind::Local, Some(name)) => SharedString::from(name),
         }
     }
 
-    // ---- the space picker (new-session canvas) ----
+    // ---- the project picker (new-session canvas) ----
 
-    /// The picker's project rows: scoped to the canvas's device — the device
-    /// switcher narrows the list, projects on other devices don't show
-    /// (pick the device first, then its project). Unscoped only while the
-    /// device is still unknown (pre-probe boot).
-    fn scoped_space_rows(&self, cx: &App) -> Vec<Space> {
+    /// The picker's project rows: one per project across every device —
+    /// clones and worktrees sharing a repository identity are one row, named
+    /// for their representative. The device chip then picks which checkout.
+    fn project_rows(&self, cx: &App) -> Vec<ProjectRow> {
         let state = self.state.read(cx);
-        let device = state.effective_device_id();
-        state
-            .spaces_sorted()
-            .into_iter()
-            .filter(|s| match device.as_deref() {
-                Some(d) => s.device_id == d,
-                None => true,
-            })
-            .cloned()
-            .collect()
+        let mut rows: Vec<ProjectRow> = Vec::new();
+        for space in &state.spaces {
+            let key = zeron_proto::view::project_key(space);
+            if rows.iter().any(|row| row.key == key) {
+                continue;
+            }
+            rows.push(ProjectRow {
+                key,
+                name: state.representative_space(space).display_name().to_string(),
+            });
+        }
+        rows.sort_by_key(|row| (row.name.to_lowercase(), row.key.clone()));
+        rows
     }
 
-    /// [`Self::scoped_space_rows`] matching the search query, ranked
+    /// [`Self::project_rows`] matching the search query, ranked
     /// (`popover::filter_indices`).
-    fn filtered_space_rows(&self, cx: &App) -> Vec<Space> {
+    fn filtered_project_rows(&self, cx: &App) -> Vec<ProjectRow> {
         let query = self.search.read(cx).text().to_string();
-        let spaces = self.scoped_space_rows(cx);
-        let names: Vec<String> = spaces
-            .iter()
-            .map(|s| s.display_name().to_string())
-            .collect();
+        let rows = self.project_rows(cx);
+        let names: Vec<String> = rows.iter().map(|row| row.name.clone()).collect();
         popover::filter_indices(&query, &names)
             .into_iter()
-            .map(|ix| spaces[ix].clone())
+            .map(|ix| rows[ix].clone())
             .collect()
     }
 
     /// Current project row on an unsearched open, or the final opt-out row.
     /// An implicit empty selection has no highlight until the user navigates.
-    fn selected_space_index(&self, cx: &App) -> usize {
+    fn selected_project_index(&self, cx: &App) -> usize {
         if self.state.read(cx).no_project {
-            return self.scoped_space_rows(cx).len();
+            return self.project_rows(cx).len();
         }
         let selected = self
             .state
             .read(cx)
             .selected_space_row()
-            .map(|s| s.id.clone());
+            .map(zeron_proto::view::project_key);
         selected
-            .as_deref()
-            .and_then(|id| self.scoped_space_rows(cx).iter().position(|s| s.id == id))
+            .and_then(|key| self.project_rows(cx).iter().position(|row| row.key == key))
             .unwrap_or(NO_ACTIVE_ROW)
     }
 
+    /// Pick a project, keeping the device when it has a checkout of it:
+    /// the current checkout, else one on the current device, else this
+    /// device's, else the first.
+    fn pick_project(&mut self, key: String, cx: &mut Context<Self>) {
+        let space_id = {
+            let state = self.state.read(cx);
+            let Some(member) = state
+                .spaces
+                .iter()
+                .find(|s| zeron_proto::view::project_key(s) == key)
+            else {
+                return;
+            };
+            let members = state.project_members(member);
+            let selected = state.selected_space_row().map(|s| s.id.clone());
+            let device = state.effective_device_id();
+            members
+                .iter()
+                .find(|s| selected.as_deref() == Some(s.id.as_str()))
+                .or_else(|| {
+                    members
+                        .iter()
+                        .find(|s| device.as_deref() == Some(s.device_id.as_str()))
+                })
+                .or(members.first())
+                .map(|s| s.id.clone())
+        };
+        if let Some(space_id) = space_id {
+            self.pick_space(space_id, cx);
+        }
+    }
+
     /// Re-home the canvas onto another project. The state observer does the
     /// heavy lifting: branch draft, ref cache, and the per-device
     /// harness/model catalogs all invalidate on the project change.
@@ -2377,11 +2542,39 @@ impl Pickers {
         }
     }
 
-    /// Devices in picker order: this device first, then by name.
-    fn device_rows(&self, cx: &App) -> Vec<zeron_proto::Device> {
+    /// The device picker's rows. With a project picked: its checkouts, one
+    /// row per device (this device first), with the path when a device holds
+    /// several. Without one: every device — project-less sessions run in its
+    /// home.
+    fn device_rows(&self, cx: &App) -> Vec<DeviceRow> {
         let state = self.state.read(cx);
         let local = state.local_device_id.clone();
-        let mut devices: Vec<zeron_proto::Device> = state.devices.clone();
+        let device_name = |id: &str| {
+            state
+                .device_name(id)
+                .unwrap_or("Unknown device")
+                .to_string()
+        };
+        if let Some(space) = state.selected_space_row() {
+            let members = state.project_members(space);
+            return members
+                .iter()
+                .map(|member| {
+                    let shared = members
+                        .iter()
+                        .filter(|other| other.device_id == member.device_id)
+                        .count()
+                        > 1;
+                    DeviceRow {
+                        device_id: member.device_id.clone(),
+                        name: device_name(&member.device_id),
+                        space: Some((*member).clone()),
+                        detail: shared.then(|| member.path.clone()),
+                    }
+                })
+                .collect();
+        }
+        let mut devices: Vec<&zeron_proto::Device> = state.devices.iter().collect();
         devices.sort_by_key(|d| {
             (
                 local.as_deref() != Some(d.id.as_str()),
@@ -2390,14 +2583,28 @@ impl Pickers {
             )
         });
         devices
+            .into_iter()
+            .map(|device| DeviceRow {
+                device_id: device.id.clone(),
+                name: device.name.clone(),
+                space: None,
+                detail: None,
+            })
+            .collect()
     }
 
     /// [`Self::device_rows`] filtered by the search box (same ranked
     /// substring match as the project rows).
-    fn filtered_device_rows(&self, cx: &App) -> Vec<zeron_proto::Device> {
+    fn filtered_device_rows(&self, cx: &App) -> Vec<DeviceRow> {
         let query = self.search.read(cx).text().to_string();
         let rows = self.device_rows(cx);
-        let names: Vec<String> = rows.iter().map(|d| d.name.clone()).collect();
+        let names: Vec<String> = rows
+            .iter()
+            .map(|row| match &row.detail {
+                Some(detail) => format!("{} {detail}", row.name),
+                None => row.name.clone(),
+            })
+            .collect();
         popover::filter_indices(&query, &names)
             .into_iter()
             .map(|ix| rows[ix].clone())
@@ -2405,26 +2612,51 @@ impl Pickers {
     }
 
     fn selected_device_index(&self, cx: &App) -> usize {
-        let effective = self.state.read(cx).effective_device_id();
+        let (selected, effective) = {
+            let state = self.state.read(cx);
+            (
+                state.selected_space_row().map(|s| s.id.clone()),
+                state.effective_device_id(),
+            )
+        };
         self.device_rows(cx)
             .iter()
-            .position(|d| Some(d.id.as_str()) == effective.as_deref())
+            .position(|row| match &row.space {
+                Some(space) => selected.as_deref() == Some(space.id.as_str()),
+                None => effective.as_deref() == Some(row.device_id.as_str()),
+            })
             .unwrap_or(0)
     }
 
-    /// The device popover: search + one row per device (name, muted "offline"
-    /// tag, check on the canvas's effective device).
+    /// A device row picks the project's checkout there, or — without a
+    /// project — the device itself.
+    fn pick_device_row(&mut self, row: DeviceRow, cx: &mut Context<Self>) {
+        match row.space {
+            Some(space) => self.pick_space(space.id, cx),
+            None => self.pick_device(row.device_id, cx),
+        }
+    }
+
+    /// The device popover: search + one row per device (name, muted path when
+    /// a device holds several checkouts of the project, offline glyph, check
+    /// on the canvas's target).
     fn render_device_popover(&mut self, cx: &mut Context<Self>) -> AnyElement {
         let theme = Theme::of(cx).for_popup();
         let now = chrono::Utc::now();
         let rows = self.filtered_device_rows(cx);
-        let (effective, local, online): (Option<String>, Option<String>, Vec<bool>) = {
+        let (selected_space, effective, local, online): (
+            Option<String>,
+            Option<String>,
+            Option<String>,
+            Vec<bool>,
+        ) = {
             let state = self.state.read(cx);
             (
+                state.selected_space_row().map(|s| s.id.clone()),
                 state.effective_device_id(),
                 state.local_device_id.clone(),
                 rows.iter()
-                    .map(|d| state.device_online(&d.id, now))
+                    .map(|row| state.device_online(&row.device_id, now))
                     .collect(),
             )
         };
@@ -2448,11 +2680,16 @@ impl Pickers {
                         .gap(px(2.0))
                         .max_h(px(self.list_budget(64.0)))
                         .children(rows.into_iter().zip(online).enumerate().map(
-                            |(ix, (device, online))| {
-                                let is_local = local.as_deref() == Some(device.id.as_str());
-                                let label: SharedString = device.name.clone().into();
-                                let is_selected = effective.as_deref() == Some(device.id.as_str());
-                                let pick_id = device.id.clone();
+                            |(ix, (row, online))| {
+                                let is_local = local.as_deref() == Some(row.device_id.as_str());
+                                let label: SharedString = row.name.clone().into();
+                                let is_selected = match &row.space {
+                                    Some(space) => {
+                                        selected_space.as_deref() == Some(space.id.as_str())
+                                    }
+                                    None => effective.as_deref() == Some(row.device_id.as_str()),
+                                };
+                                let detail = row.detail.clone().map(SharedString::from);
                                 popover::menu_row_nav(
                                     &theme,
                                     is_selected,
@@ -2461,9 +2698,28 @@ impl Pickers {
                                 )
                                 .id(("device-row", ix))
                                 .on_click(cx.listener(move |this, _, _, cx| {
-                                    this.pick_device(pick_id.clone(), cx);
+                                    this.pick_device_row(row.clone(), cx);
                                 }))
-                                .child(div().flex_1().min_w_0().truncate().child(label))
+                                .child(
+                                    div()
+                                        .flex_1()
+                                        .min_w_0()
+                                        .flex()
+                                        .flex_row()
+                                        .items_baseline()
+                                        .gap(px(6.0))
+                                        .child(div().flex_none().child(label))
+                                        .when_some(detail, |el, detail| {
+                                            el.child(
+                                                div()
+                                                    .min_w_0()
+                                                    .truncate()
+                                                    .text_size(crate::typography::ui_rems(10.0))
+                                                    .text_color(theme.text_muted)
+                                                    .child(detail),
+                                            )
+                                        }),
+                                )
                                 // The local device wears a muted right-aligned "You"
                                 // instead of a "(this device)" suffix in the name.
                                 .when(is_local, |el| {
@@ -2498,26 +2754,24 @@ impl Pickers {
             .into_any_element()
     }
 
-    /// The project popover: search + one row per project on the picked device
-    /// (check on the current pick), then "New project…" and the opt-out rows. Rows
-    /// are device-scoped, so no per-row `@ device` tag — the device chip next
-    /// door names the host.
+    /// The project popover: search + one row per project across devices
+    /// (check on the current pick), then "New project…" and the opt-out rows.
+    /// No per-row `@ device` tag — the device chip next door picks the host.
     fn render_space_popover(&mut self, cx: &mut Context<Self>) -> AnyElement {
         let theme = Theme::of(cx).for_popup();
-        let rows = self.filtered_space_rows(cx);
+        let rows = self.filtered_project_rows(cx);
         let selected = self
             .state
             .read(cx)
             .selected_space_row()
-            .map(|s| s.id.clone());
+            .map(zeron_proto::view::project_key);
         let active = self.active;
         let no_project_index = rows.len();
         let scrollbar = popover::rail(self, "space-scrollbar", &theme, cx);
         let body: AnyElement = if rows.is_empty() {
-            // Distinguish "the filter ate everything" from "this device has
-            // no projects yet" — the scoped list makes the latter common.
+            // Distinguish "the filter ate everything" from "no projects yet".
             let empty: &str = if self.search.read(cx).text().is_empty() {
-                "No projects on this device."
+                "No projects yet."
             } else {
                 "No projects match."
             };
@@ -2537,10 +2791,10 @@ impl Pickers {
                         .flex_col()
                         .gap(px(2.0))
                         .max_h(px(self.list_budget(152.0)))
-                        .children(rows.into_iter().enumerate().map(|(ix, space)| {
-                            let label: SharedString = space.display_name().to_string().into();
-                            let is_selected = selected.as_deref() == Some(space.id.as_str());
-                            let pick_id = space.id.clone();
+                        .children(rows.into_iter().enumerate().map(|(ix, row)| {
+                            let label: SharedString = row.name.into();
+                            let is_selected = selected.as_deref() == Some(row.key.as_str());
+                            let key = row.key;
                             popover::menu_row_nav(
                                 &theme,
                                 is_selected,
@@ -2549,7 +2803,7 @@ impl Pickers {
                             )
                             .id(("space-row", ix))
                             .on_click(cx.listener(move |this, _, _, cx| {
-                                this.pick_space(pick_id.clone(), cx);
+                                this.pick_project(key.clone(), cx);
                             }))
                             .child(div().flex_1().min_w_0().truncate().child(label))
                         })),
@@ -2628,17 +2882,17 @@ impl Pickers {
             self.pick_ref(row, cx);
         }
         if self.open_kind() == Some(PickerKind::Space) {
-            let rows = self.filtered_space_rows(cx);
-            if let Some(space) = rows.get(self.active) {
-                self.pick_space(space.id.clone(), cx);
+            let rows = self.filtered_project_rows(cx);
+            if let Some(row) = rows.get(self.active) {
+                self.pick_project(row.key.clone(), cx);
             } else if self.active == rows.len() {
                 self.pick_no_project(cx);
             }
         }
         if self.open_kind() == Some(PickerKind::Device)
-            && let Some(device) = self.filtered_device_rows(cx).into_iter().nth(self.active)
+            && let Some(row) = self.filtered_device_rows(cx).into_iter().nth(self.active)
         {
-            self.pick_device(device.id, cx);
+            self.pick_device_row(row, cx);
         }
         // Palette-search Enter submits the highlighted model or setting.
         if self.open_kind() == Some(PickerKind::HarnessModel) {
@@ -2699,10 +2953,6 @@ impl Pickers {
             return;
         }
         if self.open_kind() == Some(PickerKind::HarnessModel) && self.compact_model_picker(cx) {
-            if self.compact_providers {
-                self.compact_provider_key(event, cx);
-                return;
-            }
             if !self.compact_model_list {
                 self.compact_panel_key(event, cx);
                 return;
@@ -2759,7 +3009,7 @@ impl Pickers {
                                 self.setting_groups(cx).len()
                             }
                     }
-                    Some(PickerKind::Space) => self.filtered_space_rows(cx).len() + 1,
+                    Some(PickerKind::Space) => self.filtered_project_rows(cx).len() + 1,
                     Some(PickerKind::Device) => self.filtered_device_rows(cx).len(),
                     None => 0,
                 };
@@ -3027,13 +3277,21 @@ impl Pickers {
                 },
             )
             .when(label_loading, |el| {
+                // Nothing is named on screen: the label rolls in from empty.
+                rolling(format!("{id}-label"), SharedString::default(), true);
                 el.child(popover::skeleton_bar(56.0, cx.entity_id(), cx))
             })
             .when(!label_loading, |el| {
-                el.child(if resizing {
-                    resizing_chip_text(format!("{id}-label").into(), 1.0, None, label)
-                } else {
-                    div().min_w_0().truncate().child(label).into_any_element()
+                // A changing label rolls (Scritto-style); at rest it is the
+                // plain truncating label, or the clip-don't-ellipsize variant
+                // while the model chip's width glides.
+                let rolling = rolling(format!("{id}-label"), label.clone(), cx.reduce_motion());
+                el.child(match rolling {
+                    Some(rolling) => rolling,
+                    None if resizing => {
+                        resizing_chip_text(format!("{id}-label").into(), 1.0, None, label)
+                    }
+                    None => div().min_w_0().truncate().child(label).into_any_element(),
                 })
             })
             // The effort half of the combined model+effort chip (and the space
@@ -3043,7 +3301,16 @@ impl Pickers {
             // model name — the run's identity — truncates last.
             .when_some(suffix, |el, (suffix, tint)| {
                 let color = tint.unwrap_or(theme.text_muted.opacity(0.7));
-                el.child(if resizing {
+                let rolling = rolling(format!("{id}-suffix"), suffix.clone(), cx.reduce_motion());
+                el.child(if let Some(rolling) = rolling {
+                    div()
+                        .flex()
+                        .flex_shrink(1000.0)
+                        .min_w_0()
+                        .text_color(color)
+                        .child(rolling)
+                        .into_any_element()
+                } else if resizing {
                     resizing_chip_text(format!("{id}-suffix").into(), 1000.0, Some(color), suffix)
                 } else {
                     div()
@@ -3111,7 +3378,7 @@ impl Pickers {
                     .flex_none()
                     .text_color(theme.text_muted.opacity(0.7)),
             )
-            .child(div().min_w_0().truncate().child(label))
+            .child(roll_text(format!("{id}-label"), label, cx.reduce_motion()))
             .child(
                 crate::icons::icon(crate::icons::ALT_ARROW_DOWN)
                     .size(px(12.0))
@@ -3165,8 +3432,9 @@ impl Pickers {
             )
     }
 
-    /// New-session destination controls. Machine and project form the
-    /// original chip-only cluster floating above the composer's trailing edge.
+    /// New-session destination controls: the project, then the device it
+    /// runs on, as a chip-only cluster floating above the composer's trailing
+    /// edge.
     pub fn render_new_thread_target_selectors(&mut self, cx: &mut Context<Self>) -> AnyElement {
         let theme = Theme::of(cx).clone();
         let closing = (self.open.closing_since(), self.menu_geometry().below);
@@ -3225,17 +3493,17 @@ impl Pickers {
             .items_center()
             .gap(px(4.0))
             .child(attach_overlay_end(
-                device_chip,
+                project_chip,
                 &mut overlay,
-                PickerKind::Device,
-                "device-popover",
+                PickerKind::Space,
+                "project-popover",
                 closing,
             ))
             .child(attach_overlay_end(
-                project_chip,
+                device_chip,
                 &mut overlay,
-                PickerKind::Space,
-                "project-popover",
+                PickerKind::Device,
+                "device-popover",
                 closing,
             ))
             .into_any_element()
@@ -3269,9 +3537,9 @@ impl Pickers {
             }
             _ => None,
         };
-        let kind_icon = match (self.config.checkout, self.selected_ref_worktree().is_some()) {
+        let kind_icon = match (self.config.checkout, self.display_ref_is_worktree()) {
             (CheckoutKind::Local, false) => crate::icons::FOLDER,
-            _ => crate::icons::FOLDER_WITH_FILES,
+            _ => crate::icons::WORKTREE,
         };
         let checkout_chip = self.footer_chip(
             PickerKind::Checkout,
@@ -3351,7 +3619,7 @@ impl Pickers {
             };
             let is_worktree = chat.cwd.as_deref().is_some_and(|cwd| cwd != space.path);
             let (icon_path, label) = if is_worktree {
-                (crate::icons::FOLDER_WITH_FILES, "Worktree")
+                (crate::icons::WORKTREE, "Worktree")
             } else {
                 (crate::icons::FOLDER, "Local checkout")
             };
@@ -3434,9 +3702,9 @@ impl Pickers {
             &theme,
             cx,
         );
-        let kind_icon = match (self.config.checkout, self.selected_ref_worktree().is_some()) {
+        let kind_icon = match (self.config.checkout, self.display_ref_is_worktree()) {
             (CheckoutKind::Local, false) => crate::icons::FOLDER,
-            _ => crate::icons::FOLDER_WITH_FILES,
+            _ => crate::icons::WORKTREE,
         };
         let kind_chip = self.footer_chip(
             PickerKind::Checkout,
@@ -3795,7 +4063,7 @@ impl Pickers {
             "Current checkout"
         };
         let local_icon = if has_worktree {
-            crate::icons::FOLDER_WITH_FILES
+            crate::icons::WORKTREE
         } else {
             crate::icons::FOLDER
         };
@@ -3804,7 +4072,7 @@ impl Pickers {
             (
                 CheckoutKind::NewWorktree,
                 "New worktree",
-                crate::icons::FOLDER_WITH_FILES,
+                crate::icons::WORKTREE,
             ),
         ];
         let active = self.active;
@@ -4022,7 +4290,7 @@ impl Pickers {
         }
 
         if compact {
-            tabs = self.compact_list_header(cx);
+            tabs = self.compact_model_back_header(cx);
         }
 
         // ── search row: icon + borderless input over a full-bleed hairline.
@@ -4188,8 +4456,7 @@ impl Pickers {
             .flex()
             .flex_col()
             .child(tabs)
-            // The compact header carries the filter beside its back button.
-            .when(!compact, |el| el.child(search_row))
+            .child(search_row)
             .children(refresh_error)
             .child(list_host)
             .children(tray)
@@ -5862,7 +6129,9 @@ impl Render for Pickers {
                 ModelName::Loading | ModelName::None { .. } => SharedString::default(),
             }
         };
-        let catalog_loading = matches!(self.harnesses, Loadable::Idle | Loadable::Loading);
+        // A list still from the previous device is loading for this one.
+        let catalog_loading = self.harnesses_stale
+            || matches!(self.harnesses, Loadable::Idle | Loadable::Loading);
         // Harness unknown while the catalog resolves: the pixel-glyph loader
         // instead of guessing a brand mark.
         let chip_icon_loading = self.title.is_none()
@@ -5886,10 +6155,9 @@ impl Render for Pickers {
             ),
         };
         // The chip names the model and its effort only; the other options
-        // (context, fast mode, ...) live in the popover. The effort brightens
-        // when it departs from the model's default.
+        // (context, fast mode, ...) live in the popover. The effort always
+        // reads in the muted second tone, default or not (user request).
         let effort = self.effective_reasoning(cx);
-        let effort_customized = effort != default_reasoning(&self.trait_ladder(cx));
         // Render the open popover's body first (mutable borrow), then the
         // chips. Branch/Checkout render in the composer FOOTER row (see
         // `render_footer`), not here.
@@ -5918,12 +6186,7 @@ impl Render for Pickers {
         // None for the title picker (titles always run at minimal reasoning).
         let chip_suffix = effort
             .filter(|_| self.title.is_none())
-            .map(|level| {
-                (
-                    SharedString::from(reasoning_label(level)),
-                    effort_customized.then(|| theme.text.opacity(0.85)),
-                )
-            })
+            .map(|level| (SharedString::from(reasoning_label(level)), None))
             .or_else(|| {
                 self.title
                     .is_none()
@@ -6886,6 +7149,7 @@ mod tests {
                 git_detected: true,
                 git_checked_at: None,
                 checkout_id: None,
+                repository_id: None,
                 created_at: chrono::Utc::now(),
             }]);
             state
@@ -6905,14 +7169,302 @@ mod tests {
             assert!(pickers.defaults.no_project);
             assert!(pickers.state.read(cx).auto_selected);
             assert!(pickers.defaults.project.is_none());
-            assert_eq!(pickers.selected_space_index(cx), 1);
+            assert_eq!(pickers.selected_project_index(cx), 1);
         });
         state.update(cx, |state, cx| state.select_device("remote".into(), cx));
         cx.run_until_parked();
         pickers.update(cx, |pickers, cx| {
             assert_eq!(pickers.space_target(cx).as_deref(), Some("remote"));
-            assert_eq!(pickers.selected_space_index(cx), 0); // empty device
-            assert!(pickers.target_generation >= 2);
+            // Projects list across devices; the opt-out row stays picked.
+            assert_eq!(pickers.selected_project_index(cx), 1);
+            // Only the device switch re-targets the per-device catalogs; the
+            // same-device projectless pick kept them.
+            assert_eq!(pickers.target_generation, 1);
+        });
+    }
+
+    fn git_space(id: &str, device: &str) -> Space {
+        Space {
+            id: id.into(),
+            device_id: device.into(),
+            path: format!("/{device}/{id}"),
+            name: None,
+            git_detected: true,
+            git_checked_at: None,
+            checkout_id: None,
+            repository_id: None,
+            created_at: chrono::Utc::now(),
+        }
+    }
+
+    fn repo_ref(name: &str, current: bool, worktree: Option<&str>) -> RepoRef {
+        RepoRef {
+            name: name.into(),
+            current,
+            worktree_path: worktree.map(str::to_string),
+        }
+    }
+
+    #[gpui::test]
+    fn project_switch_on_one_device_keeps_the_model_catalog(cx: &mut gpui::TestAppContext) {
+        let state = cx.new(|_| {
+            let mut state = AppState::new();
+            state.local_device_id = Some("local".into());
+            state.apply_spaces(vec![git_space("a", "local"), git_space("b", "local")]);
+            state.selected_space = Some("a".into());
+            state
+        });
+        let pickers = cx.new(|cx| Pickers::new(state.clone(), cx));
+        pickers.update(cx, |pickers, cx| {
+            pickers.defaults = ComposerDefaults::default();
+            pickers.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Codex, "Codex")]);
+            pickers.apply_model_catalog(
+                HarnessId::Codex,
+                Loadable::Ready(vec![bare_model("gpt", "GPT")]),
+                cx,
+            );
+            assert_eq!(pickers.model_name(cx), ModelName::Named("GPT".into()));
+        });
+        state.update(cx, |state, cx| state.select_space(Some("b".into()), cx));
+        cx.run_until_parked();
+        pickers.update(cx, |pickers, cx| {
+            // Same host: the catalog stands, the chip never blanks.
+            assert_eq!(pickers.model_name(cx), ModelName::Named("GPT".into()));
+            assert!(matches!(pickers.harnesses, Loadable::Ready(_)));
+            assert!(!pickers.harnesses_stale && pickers.stale_models.is_empty());
+        });
+    }
+
+    #[gpui::test]
+    fn device_switch_revalidates_the_catalog_without_blanking(cx: &mut gpui::TestAppContext) {
+        let state = cx.new(|_| {
+            let mut state = AppState::new();
+            state.local_device_id = Some("local".into());
+            state.apply_spaces(vec![git_space("a", "local"), git_space("b", "remote")]);
+            state.selected_space = Some("a".into());
+            state
+        });
+        let pickers = cx.new(|cx| Pickers::new(state.clone(), cx));
+        pickers.update(cx, |pickers, cx| {
+            pickers.defaults = ComposerDefaults::default();
+            // A picked harness keeps the chip naming its model throughout.
+            pickers.config.harness = Some(HarnessId::Codex);
+            pickers.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Codex, "Codex")]);
+            pickers.apply_model_catalog(
+                HarnessId::Codex,
+                Loadable::Ready(vec![bare_model("gpt", "GPT")]),
+                cx,
+            );
+            pickers.models.insert(HarnessId::ClaudeCode, Loadable::Loading);
+        });
+        state.update(cx, |state, cx| state.select_space(Some("b".into()), cx));
+        cx.run_until_parked();
+        pickers.update(cx, |pickers, cx| {
+            // Old rows stay on screen, marked for one reload from the new host;
+            // a load in flight for the old host restarts instead.
+            assert_eq!(pickers.model_name(cx), ModelName::Named("GPT".into()));
+            assert!(pickers.harnesses_stale);
+            assert_eq!(pickers.stale_models, HashSet::from([HarnessId::Codex]));
+            assert!(!pickers.models.contains_key(&HarnessId::ClaudeCode));
+            // The old device's catalog never picks for the new one: with no
+            // explicit or remembered model, a send leaves the choice to the
+            // new device instead of carrying the old catalog's default.
+            assert_eq!(pickers.resolved(cx).model, None);
+            // A failed reload replaces the old device's rows — it is not
+            // retained like a same-device refresh failure.
+            pickers.land_model_reload(
+                HarnessId::Codex,
+                Loadable::Error("device offline".into()),
+                cx,
+            );
+            assert!(pickers.stale_models.is_empty());
+            assert!(matches!(
+                pickers.models.get(&HarnessId::Codex),
+                Some(Loadable::Error(_))
+            ));
+            assert_ne!(pickers.model_name(cx), ModelName::Named("GPT".into()));
+            // With nothing picked or remembered, the old device's harness list
+            // doesn't choose either — for the chip or a send.
+            pickers.config.harness = None;
+            assert!(pickers.harnesses_stale);
+            assert_eq!(pickers.effective_harness(cx), None);
+            assert_eq!(pickers.resolved(cx).harness, None);
+            // ...and the chip reads as loading, never blank.
+            assert_eq!(pickers.model_name(cx), ModelName::Loading);
+        });
+    }
+
+    #[gpui::test]
+    fn same_device_refresh_failure_keeps_the_loaded_rows(cx: &mut gpui::TestAppContext) {
+        let state = cx.new(|_| {
+            let mut state = AppState::new();
+            state.local_device_id = Some("local".into());
+            state.apply_spaces(vec![git_space("a", "local")]);
+            state.selected_space = Some("a".into());
+            state
+        });
+        let pickers = cx.new(|cx| Pickers::new(state, cx));
+        pickers.update(cx, |pickers, cx| {
+            pickers.defaults = ComposerDefaults::default();
+            pickers.harnesses = Loadable::Ready(vec![descriptor(HarnessId::Codex, "Codex")]);
+            pickers.apply_model_catalog(
+                HarnessId::Codex,
+                Loadable::Ready(vec![bare_model("gpt", "GPT")]),
+                cx,
+            );
+            pickers.land_model_reload(HarnessId::Codex, Loadable::Error("flaky".into()), cx);
+            assert_eq!(pickers.model_name(cx), ModelName::Named("GPT".into()));
+            assert!(matches!(
+                pickers.models.get(&HarnessId::Codex),
+                Some(Loadable::Ready(_))
+            ));
+        });
+    }
+
+    #[gpui::test]
+    fn project_switch_holds_the_ref_labels_until_refs_land(cx: &mut gpui::TestAppContext) {
+        let state = cx.new(|_| {
+            let mut state = AppState::new();
+            state.local_device_id = Some("local".into());
+            state.apply_spaces(vec![git_space("a", "local"), git_space("b", "local")]);
+            state.selected_space = Some("a".into());
+            state
+        });
+        let pickers = cx.new(|cx| Pickers::new(state.clone(), cx));
+        pickers.update(cx, |pickers, _| {
+            pickers.refs = Loadable::Ready(vec![
+                repo_ref("main", false, None),
+                repo_ref("feature", true, Some("/wt/feature")),
+            ]);
+            pickers.refs_space = Some("a".into());
+            assert_eq!(pickers.ref_label(), SharedString::from("feature"));
+            assert_eq!(pickers.checkout_label(), "Current worktree");
+        });
+        state.update(cx, |state, cx| state.select_space(Some("b".into()), cx));
+        cx.run_until_parked();
+        pickers.update(cx, |pickers, cx| {
+            // The chips keep naming the last ref while b's refs load...
+            assert!(matches!(pickers.refs, Loadable::Idle));
+            assert_eq!(pickers.ref_label(), SharedString::from("feature"));
+            assert_eq!(pickers.checkout_label(), "Current worktree");
+            // ...but nothing that acts on refs sees a's rows.
+            assert!(pickers.filtered_ref_rows(cx).is_empty());
+            assert_eq!(
+                pickers.checkout_plan(),
+                CheckoutPlan::CurrentCheckout { branch: None }
+            );
+            pickers.refs = Loadable::Ready(vec![repo_ref("trunk", true, None)]);
+            pickers.held_ref = None; // as the refs load does on landing
+            assert_eq!(pickers.ref_label(), SharedString::from("trunk"));
+            assert_eq!(pickers.checkout_label(), "Current checkout");
+        });
+    }
+
+    #[gpui::test]
+    fn project_picker_lists_repositories_then_their_devices(cx: &mut gpui::TestAppContext) {
+        let space = |id: &str, device: &str, name: &str, repository: Option<&str>, minutes| Space {
+            id: id.into(),
+            device_id: device.into(),
+            path: format!("/{device}/{id}"),
+            name: Some(name.into()),
+            git_detected: repository.is_some(),
+            git_checked_at: None,
+            checkout_id: None,
+            repository_id: repository.map(str::to_string),
+            created_at: chrono::DateTime::<chrono::Utc>::UNIX_EPOCH
+                + chrono::TimeDelta::minutes(minutes),
+        };
+        let state = cx.new(|_| {
+            let mut state = AppState::new();
+            state.local_device_id = Some("mac".into());
+            state.devices = ["mac", "vps"]
+                .into_iter()
+                .map(|id| {
+                    serde_json::from_value(serde_json::json!({
+                        "id": id, "name": id.to_uppercase(), "platform": "macos", "lastSeenAt": null
+                    }))
+                    .unwrap()
+                })
+                .collect();
+            state.apply_spaces(vec![
+                space("notes", "mac", "notes", None, 0),
+                space("server", "vps", "comet", Some("github.com/o/comet"), 1),
+                space(
+                    "laptop",
+                    "mac",
+                    "comet-laptop",
+                    Some("github.com/o/comet"),
+                    2,
+                ),
+                space(
+                    "server-wt",
+                    "vps",
+                    "comet-wt",
+                    Some("github.com/o/comet"),
+                    3,
+                ),
+            ]);
+            state.selected_space = Some("notes".into());
+            state
+        });
+        let pickers = cx.new(|cx| Pickers::new(state.clone(), cx));
+        pickers.update(cx, |pickers, cx| {
+            // One row per repository, named for its oldest checkout.
+            let rows: Vec<(String, String)> = pickers
+                .project_rows(cx)
+                .into_iter()
+                .map(|row| (row.name, row.key))
+                .collect();
+            assert_eq!(
+                rows,
+                [
+                    ("comet".into(), "repo:github.com/o/comet".into()),
+                    ("notes".into(), "notes".into())
+                ]
+            );
+            // Picking it keeps the canvas on this device's checkout.
+            pickers.pick_project("repo:github.com/o/comet".into(), cx);
+            assert_eq!(
+                pickers.state.read(cx).selected_space.as_deref(),
+                Some("laptop")
+            );
+            assert_eq!(pickers.selected_project_index(cx), 0);
+            // The device picker offers only the project's checkouts; a device
+            // holding two is told apart by path.
+            let devices: Vec<(String, Option<String>)> = pickers
+                .device_rows(cx)
+                .into_iter()
+                .map(|row| (row.device_id, row.detail))
+                .collect();
+            assert_eq!(
+                devices,
+                [
+                    ("mac".into(), None),
+                    ("vps".into(), Some("/vps/server".into())),
+                    ("vps".into(), Some("/vps/server-wt".into())),
+                ]
+            );
+            let server = pickers.device_rows(cx).remove(1);
+            pickers.pick_device_row(server, cx);
+            assert_eq!(
+                pickers.state.read(cx).selected_space.as_deref(),
+                Some("server")
+            );
+            assert_eq!(pickers.selected_device_index(cx), 1);
+            // Without a project, every device is offered.
+            pickers.pick_no_project(cx);
+            let devices: Vec<(String, bool)> = pickers
+                .device_rows(cx)
+                .into_iter()
+                .map(|row| (row.device_id, row.space.is_some()))
+                .collect();
+            assert_eq!(devices, [("mac".into(), false), ("vps".into(), false)]);
+        });
+        // A device switch keeps the project when the device has a checkout.
+        state.update(cx, |state, cx| {
+            state.select_space(Some("laptop".into()), cx);
+            state.select_device("vps".into(), cx);
+            assert_eq!(state.selected_space.as_deref(), Some("server"));
         });
     }
 
@@ -7974,7 +8526,7 @@ mod tests {
         cx.simulate_keystrokes(handle.into(), "tab");
         handle
             .read_with(cx, |picker, cx| {
-                assert!(!picker.compact_model_list && !picker.compact_providers);
+                assert!(!picker.compact_model_list);
                 assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
             })
             .unwrap();
@@ -8302,23 +8854,24 @@ mod tests {
                 picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
                 assert_eq!(picker.resolved(cx).model.as_deref(), Some("opus"));
                 assert_eq!(picker.effective_reasoning(cx), Some(ReasoningLevel::High));
-                // Starring adds a Starred entry ahead of the providers; it
-                // opens the starred models from every provider.
-                assert!(matches!(
-                    picker.compact_provider_rows(cx).first(),
-                    Some(compact::ProviderRow::Harness(_))
-                ));
+                // The list's tabs are its provider groups, in list order;
+                // starring adds a Starred tab ahead of them, holding the
+                // starred models from every provider.
+                picker.show_compact_models(cx);
+                assert_eq!(
+                    picker.compact_groups(cx),
+                    vec![(Some(HarnessId::Codex), 0), (Some(HarnessId::ClaudeCode), 2)]
+                );
                 picker.toggle_model_favorite(HarnessId::Codex, "gpt-a", cx);
-                picker.show_compact_providers(cx);
-                assert!(matches!(
-                    picker.compact_provider_rows(cx).first(),
-                    Some(compact::ProviderRow::Starred)
-                ));
-                picker.active = 0;
-                picker.activate_compact_provider(cx);
-                assert!(picker.compact_model_list && !picker.compact_providers);
+                assert_eq!(
+                    picker.compact_groups(cx),
+                    vec![
+                        (None, 0),
+                        (Some(HarnessId::Codex), 1),
+                        (Some(HarnessId::ClaudeCode), 2),
+                    ]
+                );
                 let rows = picker.model_rows(cx);
-                assert_eq!(rows.len(), 1);
                 assert_eq!(
                     (rows[0].harness, rows[0].model.id.as_str()),
                     (HarnessId::Codex, "gpt-a")
@@ -8381,14 +8934,10 @@ mod tests {
                 picker.activate_model_index(1, cx);
                 assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
                 picker.pick_harness(HarnessId::Codex, cx);
-                // The provider page lists every provider, highlighting the
-                // current one, and a pick lands back on the panel.
-                picker.show_compact_providers(cx);
-                assert!(picker.compact_providers && !picker.compact_model_list);
-                assert_eq!(picker.compact_provider_rows(cx).len(), 2);
-                assert_eq!(picker.active, 0);
+                // Switching provider (Tab on the panel) lands back on the
+                // panel at that provider's model.
                 picker.pick_compact_provider(HarnessId::ClaudeCode, cx);
-                assert!(!picker.compact_providers && !picker.compact_model_list);
+                assert!(!picker.compact_model_list);
                 assert_eq!(picker.resolved(cx).harness, Some(HarnessId::ClaudeCode));
                 assert_eq!(picker.resolved(cx).model.as_deref(), Some("claude-model"));
                 picker.pick_harness(HarnessId::Codex, cx);
@@ -8405,10 +8954,12 @@ mod tests {
                 picker.search.update(cx, |input, cx| input.set_text("Claude", cx));
                 assert_eq!(picker.model_rows_len(cx), 0);
                 picker.search.update(cx, |input, cx| input.set_text("", cx));
-                // A chat's provider is fixed: the provider page stays shut.
+                // A chat's provider is fixed: one tab, its own.
+                assert_eq!(
+                    picker.compact_groups(cx),
+                    vec![(Some(HarnessId::Codex), 0)]
+                );
                 picker.compact_model_list = false;
-                picker.show_compact_providers(cx);
-                assert!(!picker.compact_providers);
                 picker.focus_on_mount = true;
             })
             .unwrap();
diff --git a/crates/ui/src/pickers/compact.rs b/crates/ui/src/pickers/compact.rs
index fca3dbeb27..8441319abe 100644
--- a/crates/ui/src/pickers/compact.rs
+++ b/crates/ui/src/pickers/compact.rs
@@ -54,8 +54,10 @@ const EFFORT_BLOCK: f32 = SLIDER_TOP + SLIDER_HEIGHT + SLIDER_BOTTOM;
 const OPTIONS_GAP: f32 = 4.0;
 /// The card's 1pt border, top and bottom, sits inside its height.
 const CARD_BORDERS: f32 = 2.0;
-/// The list pages' one header row: back button and filter side by side.
-pub(super) const LIST_HEADER: f32 = 40.0;
+/// The model list's chrome above the rows: the back button with the
+/// provider tab strip (one row plus the card inset above and below, 40),
+/// then the search row (40).
+pub(super) const LIST_HEADER: f32 = 80.0;
 /// Option rows (26pt plus a 2pt gap) all show up to this many, then scroll.
 const OPTIONS_MAX_ROWS: usize = 6;
 /// The rows' 4pt top inset, then the rows; the panel's inset closes below.
@@ -81,18 +83,10 @@ enum EffortStops {
     },
 }
 
-/// One entry on the provider page: the starred models, or a provider.
-#[derive(Clone)]
-pub(super) enum ProviderRow {
-    Starred,
-    Harness(HarnessDescriptor),
-}
-
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub(super) enum CompactPage {
     Panel,
     Models,
-    Providers,
 }
 
 #[derive(Default)]
@@ -333,11 +327,6 @@ impl Pickers {
         self.show_compact_list(rail, "Search models…", cx);
     }
 
-    /// The starred models across providers, opened from the provider page.
-    fn show_compact_starred(&mut self, cx: &mut Context<Self>) {
-        self.show_compact_list(ModelRail::Favorites, "Search starred…", cx);
-    }
-
     fn show_compact_list(
         &mut self,
         rail: ModelRail,
@@ -345,15 +334,28 @@ impl Pickers {
         cx: &mut Context<Self>,
     ) {
         self.setting_menu = None;
-        self.compact_providers = false;
         self.compact_model_list = true;
         self.model_rail = rail;
         self.reset_compact_search(placeholder, cx);
-        // Open on the current model, at the top when it is near the start.
+        // Open on the current model: its provider's group at the top when
+        // the model sits near the start of it, else centred on the model.
         let selected = self.selected_model_index(cx);
         self.active = selected;
-        if selected < COMPACT_LIST_ROWS as usize - 2 {
-            self.model_scroll_base().set_offset(gpui::Point::default());
+        let start = self
+            .compact_groups(cx)
+            .into_iter()
+            .rev()
+            .find(|(_, start)| *start <= selected)
+            .map_or(0, |(_, start)| start);
+        if selected - start < COMPACT_LIST_ROWS as usize - 2 {
+            // One row of the previous group stays above, under the edge
+            // fade, so the group's first row is never washed out and the
+            // list shows there is more above.
+            self.model_scroll.scroll_to_item_strict_with_offset(
+                start,
+                gpui::ScrollStrategy::Top,
+                usize::from(start > 0),
+            );
         } else {
             self.model_scroll
                 .scroll_to_item_strict(selected, gpui::ScrollStrategy::Center);
@@ -362,29 +364,9 @@ impl Pickers {
         cx.notify();
     }
 
-    pub(super) fn show_compact_providers(&mut self, cx: &mut Context<Self>) {
-        if self.harness_locked(cx) {
-            return;
-        }
-        self.setting_menu = None;
-        self.compact_model_list = false;
-        self.compact_providers = true;
-        self.reset_compact_search("Search providers…", cx);
-        let effective = self.effective_harness(cx);
-        self.active = self
-            .compact_provider_rows(cx)
-            .iter()
-            .position(|row| matches!(row, ProviderRow::Harness(d) if Some(d.id) == effective))
-            .unwrap_or(0);
-        popover::reset_menu_scroll(&self.menu_scroll, &mut self.menu_bar);
-        self.focus_on_mount = true;
-        cx.notify();
-    }
-
-    /// Back from either list page to the panel.
+    /// Back from the model list to the panel.
     pub(super) fn show_compact_panel(&mut self, cx: &mut Context<Self>) {
         self.compact_model_list = false;
-        self.compact_providers = false;
         self.focus_on_mount = true;
         cx.notify();
     }
@@ -401,24 +383,6 @@ impl Pickers {
         });
     }
 
-    /// Starred models first (once any are starred), then the providers on
-    /// offer, narrowed by the filter.
-    pub(super) fn compact_provider_rows(&self, cx: &App) -> Vec<ProviderRow> {
-        let query = self.search.read(cx).text().trim().to_lowercase();
-        let matches = |name: &str| query.is_empty() || name.to_lowercase().contains(&query);
-        let starred = (!self.defaults.favorites.is_empty() && matches("Starred"))
-            .then_some(ProviderRow::Starred);
-        starred
-            .into_iter()
-            .chain(
-                self.rail_descriptors(cx)
-                    .into_iter()
-                    .filter(|d| matches(&d.name))
-                    .map(ProviderRow::Harness),
-            )
-            .collect()
-    }
-
     /// Picking a provider runs its last-used model at that model's last
     /// settings (the remembered defaults take over once the harness moves).
     pub(super) fn pick_compact_provider(&mut self, harness: HarnessId, cx: &mut Context<Self>) {
@@ -427,25 +391,144 @@ impl Pickers {
         self.show_compact_panel(cx);
     }
 
-    /// Both list pages share one header row: back to the panel, then the
-    /// page's filter beside it.
-    pub(super) fn compact_list_header(&mut self, cx: &mut Context<Self>) -> gpui::Div {
+    /// Where each provider's group starts in the unsearched list: starred
+    /// models first, then one run per provider.
+    pub(super) fn compact_groups(&self, cx: &App) -> Vec<(Option<HarnessId>, usize)> {
+        let rows = self.model_rows(cx);
+        let mut groups: Vec<(Option<HarnessId>, usize)> = Vec::new();
+        for (ix, row) in rows.iter().enumerate() {
+            let group =
+                (!self.defaults.is_favorite(row.harness, &row.model.id)).then_some(row.harness);
+            if groups.last().is_none_or(|(last, _)| *last != group) {
+                groups.push((group, ix));
+            }
+        }
+        groups
+    }
+
+    /// The model list's top row: back to the panel, then the providers as
+    /// tabs. Each tab jumps the list to its group, and the group at the top
+    /// of the scroll lights its tab. The strip fades at both edges over the
+    /// tabs scrolled past them.
+    pub(super) fn compact_model_back_header(&mut self, cx: &mut Context<Self>) -> gpui::Div {
         let theme = Theme::of(cx).for_popup();
+        let searching = !self.search.read(cx).text().trim().is_empty();
+        let groups = if searching {
+            Vec::new()
+        } else {
+            self.compact_groups(cx)
+        };
+        // Rows share one pitch, so the scroll offset names the top row.
+        let top = (f32::from(-self.model_scroll_base().offset().y)
+            / (COMPACT_ROW_HEIGHT + popover::MENU_GAP))
+            .round()
+            .max(0.0) as usize;
+        let current = groups
+            .iter()
+            .rev()
+            .find(|(_, start)| *start <= top)
+            .map(|(group, _)| *group);
+        // Many providers overflow the strip: keep the viewed tab in sight
+        // as the list scrolls, without fighting a manual sideways scroll.
+        let viewed_ix = groups.iter().position(|(group, _)| current == Some(*group));
+        if viewed_ix != self.compact_strip_viewed {
+            self.compact_strip_viewed = viewed_ix;
+            if let Some(ix) = viewed_ix {
+                self.compact_strip_scroll.scroll_to_item(ix);
+            }
+        }
+        let strip = (!groups.is_empty()).then(|| {
+            let tabs = div()
+                .id("compact-group-strip")
+                .flex_1()
+                .min_w_0()
+                .h_full()
+                .flex()
+                .items_center()
+                .gap(px(popover::MENU_GAP))
+                .overflow_x_scroll()
+                .track_scroll(&self.compact_strip_scroll)
+                .children(groups.into_iter().map(|(group, start)| {
+                    let viewed = current == Some(group);
+                    let (icon, tint, name): (&'static str, Option<gpui::Hsla>, SharedString) =
+                        match group {
+                            None => (crate::icons::STAR_BOLD, None, "Starred".into()),
+                            Some(harness) => {
+                                let (icon, tint) = harness_brand_icon(harness);
+                                let name = self
+                                    .rail_descriptors(cx)
+                                    .into_iter()
+                                    .find(|d| d.id == harness)
+                                    .map(|d| d.name)
+                                    .unwrap_or_default();
+                                (icon, tint, name.into())
+                            }
+                        };
+                    let hint = name.clone();
+                    div()
+                        .id(SharedString::from(format!("compact-group-{start}")))
+                        .role(gpui::Role::Button)
+                        .aria_label(SharedString::from(format!("Jump to {name}")))
+                        .tooltip(move |_, cx| cx.new(|_| PickerHint(hint.clone())).into())
+                        // A row-height square with the rows' corners, so the
+                        // strip sits on the card's grid like the list below.
+                        .flex_none()
+                        .size(px(COMPACT_ROW_HEIGHT))
+                        .rounded(px(popover::MENU_ITEM_RADIUS))
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .cursor_pointer()
+                        .when(viewed, |el| el.bg(crate::theme::ink(0.08)))
+                        .when(!viewed, |el| {
+                            el.opacity(0.7)
+                                .hover(|s| s.bg(crate::theme::ink(0.05)).opacity(1.0))
+                        })
+                        .on_click(cx.listener(move |this, _, _, cx| {
+                            this.compact_keyboard = false;
+                            this.active = start;
+                            this.model_scroll
+                                .scroll_to_item_strict(start, gpui::ScrollStrategy::Top);
+                            cx.notify();
+                        }))
+                        .child(crate::icons::icon(icon).size(px(14.0)).text_color(
+                            tint.unwrap_or(if viewed { theme.text } else { theme.text_muted }),
+                        ))
+                }));
+            // Each side fades over the tabs hidden past it, up to one tab
+            // pitch, reaching zero exactly at the clip edge.
+            crate::edge_fade::edge_faded(
+                COMPACT_ROW_HEIGHT + popover::MENU_GAP,
+                false,
+                false,
+                tabs,
+            )
+                .fade_left(true)
+                .fade_right(true)
+                .fade_scroll_x(&self.compact_strip_scroll)
+        });
+        // The card's inset on every side of one row-height strip: the same
+        // 4pt edge and 32pt pitch as the list rows and the panel's buttons.
         div()
-            .h(px(40.0))
+            .h(px(COMPACT_ROW_HEIGHT + 2.0 * popover::CARD_INSET))
             .flex_none()
             .px(px(popover::CARD_INSET))
-            .border_b_1()
-            .border_color(crate::theme::hairline(0.08))
             .flex()
             .items_center()
-            .gap(px(4.0))
+            .gap(px(popover::MENU_GAP))
             .child(
-                popover::menu_row(&theme, false, "compact-list-back")
-                    .id("compact-list-back")
+                div()
+                    .id("compact-model-back")
                     .role(gpui::Role::Button)
                     .aria_label("Back")
                     .flex_none()
+                    .size(px(COMPACT_ROW_HEIGHT))
+                    .rounded(px(popover::MENU_ITEM_RADIUS))
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .cursor_pointer()
+                    .hover(|s| s.bg(crate::theme::ink(0.05)))
                     .on_click(cx.listener(|this, _, _, cx| this.show_compact_panel(cx)))
                     .child(
                         crate::icons::icon(crate::icons::ALT_ARROW_LEFT)
@@ -453,152 +536,7 @@ impl Pickers {
                             .text_color(theme.text_muted),
                     ),
             )
-            .child(
-                div()
-                    .flex_1()
-                    .min_w_0()
-                    .text_size(crate::typography::ui_rems(13.0))
-                    .child(self.search.clone()),
-            )
-    }
-
-    pub(super) fn render_compact_provider_page(&mut self, cx: &mut Context<Self>) -> AnyElement {
-        let theme = Theme::of(cx).for_popup();
-        let rows = self.compact_provider_rows(cx);
-        let effective = self.effective_harness(cx);
-        let list_height = compact_list_height(rows.len())
-            .min((self.menu_geometry().height - LIST_HEADER - CARD_BORDERS).max(0.0));
-        let items: Vec<AnyElement> = if rows.is_empty() {
-            vec![empty_list_note(&theme, "No providers found")]
-        } else {
-            rows.into_iter()
-                .enumerate()
-                .map(|(ix, row)| {
-                    let (icon, tint, name, selected): (_, _, SharedString, bool) = match &row {
-                        ProviderRow::Starred => {
-                            (crate::icons::STAR_BOLD, None, "Starred".into(), false)
-                        }
-                        ProviderRow::Harness(descriptor) => {
-                            let (icon, tint) = harness_brand_icon(descriptor.id);
-                            (
-                                icon,
-                                tint,
-                                descriptor.name.clone().into(),
-                                effective == Some(descriptor.id),
-                            )
-                        }
-                    };
-                    let item = div()
-                        .id(("compact-provider", ix))
-                        .role(gpui::Role::ListBoxOption)
-                        .aria_label(name.clone())
-                        .aria_selected(selected)
-                        .h(px(COMPACT_ROW_HEIGHT))
-                        .pl(px(8.0))
-                        .pr(px(8.0))
-                        .rounded(px(popover::MENU_ITEM_RADIUS))
-                        .flex()
-                        .items_center()
-                        .gap(px(8.0))
-                        .cursor_pointer()
-                        .text_color(theme.text)
-                        .border_1()
-                        .border_color(gpui::transparent_black())
-                        .when(selected, |el| crate::glass::light(el, &theme, 1.0))
-                        .when(!selected && self.active == ix, |el| {
-                            el.bg(crate::theme::ink(0.05))
-                        })
-                        .when(self.compact_keyboard && self.active == ix, |el| {
-                            el.aria_active_descendant()
-                        })
-                        .on_hover(cx.listener(move |this, hovered: &bool, _, cx| {
-                            if *hovered && (this.active != ix || this.compact_keyboard) {
-                                this.compact_keyboard = false;
-                                this.active = ix;
-                                cx.notify();
-                            }
-                        }))
-                        .on_click(cx.listener(move |this, _, _, cx| {
-                            this.activate_provider_row(row.clone(), cx)
-                        }))
-                        .child(
-                            crate::icons::icon(icon)
-                                .size(px(14.0))
-                                .flex_none()
-                                .text_color(tint.unwrap_or(theme.text_muted)),
-                        )
-                        .child(
-                            div()
-                                .flex_1()
-                                .min_w_0()
-                                .truncate()
-                                .text_size(crate::typography::ui_rems(12.0))
-                                .font_weight(gpui::FontWeight::MEDIUM)
-                                .child(name),
-                        );
-                    div()
-                        .pb(px(popover::MENU_GAP))
-                        .child(item)
-                        .into_any_element()
-                })
-                .collect()
-        };
-        let scrollbar = popover::rail(self, "compact-providers-scrollbar", &theme, cx);
-        let list = div()
-            .id("compact-providers-host")
-            .relative()
-            .flex_none()
-            .h(px(list_height))
-            .py(px(popover::CARD_INSET))
-            .bg(crate::theme::ink(0.02))
-            .on_hover(cx.listener(Self::on_menu_list_hover))
-            .child(popover::faded_menu_list(
-                &self.menu_scroll,
-                popover::menu_scroll_list("compact-providers", &self.menu_scroll)
-                    .size_full()
-                    .child(div().flex().flex_col().children(items)),
-            ))
-            .children(scrollbar);
-        div()
-            .flex()
-            .flex_col()
-            .child(self.compact_list_header(cx))
-            .child(list)
-            .into_any_element()
-    }
-
-    pub(super) fn compact_provider_key(&mut self, event: &KeyDownEvent, cx: &mut Context<Self>) {
-        let count = self.compact_provider_rows(cx).len();
-        match event.keystroke.key.as_str() {
-            "escape" => self.show_compact_panel(cx),
-            "up" | "down" => {
-                let current = (self.active < count).then_some(self.active);
-                self.active = popover::menu_step(
-                    current,
-                    count,
-                    if event.keystroke.key == "up" { -1 } else { 1 },
-                )
-                .unwrap_or(0);
-                self.compact_keyboard = true;
-                cx.notify();
-            }
-            "enter" => self.activate_compact_provider(cx),
-            _ => return,
-        }
-        cx.stop_propagation();
-    }
-
-    pub(super) fn activate_compact_provider(&mut self, cx: &mut Context<Self>) {
-        if let Some(row) = self.compact_provider_rows(cx).get(self.active).cloned() {
-            self.activate_provider_row(row, cx);
-        }
-    }
-
-    fn activate_provider_row(&mut self, row: ProviderRow, cx: &mut Context<Self>) {
-        match row {
-            ProviderRow::Starred => self.show_compact_starred(cx),
-            ProviderRow::Harness(descriptor) => self.pick_compact_provider(descriptor.id, cx),
-        }
+            .children(strip)
     }
 
     pub(super) fn compact_fast_choice(&self, cx: &App) -> Option<(String, String, bool, bool)> {
@@ -774,9 +712,7 @@ impl Pickers {
             } else {
                 OPTIONS_GAP + options_height(options)
             };
-        let page = if self.compact_providers {
-            CompactPage::Providers
-        } else if self.compact_model_list {
+        let page = if self.compact_model_list {
             CompactPage::Models
         } else {
             CompactPage::Panel
@@ -785,11 +721,6 @@ impl Pickers {
             CompactPage::Models => {
                 LIST_HEADER + compact_list_height(self.model_rows_len(cx)) + CARD_BORDERS
             }
-            CompactPage::Providers => {
-                LIST_HEADER
-                    + compact_list_height(self.compact_provider_rows(cx).len())
-                    + CARD_BORDERS
-            }
             CompactPage::Panel => panel_height,
         });
         let (height, moving) = ScalarTransition::sample(
@@ -804,7 +735,6 @@ impl Pickers {
         }
         let content = match page {
             CompactPage::Models => self.render_harness_model_popover(cx),
-            CompactPage::Providers => self.render_compact_provider_page(cx),
             CompactPage::Panel => self.render_compact_model_panel(window, cx),
         };
         let now = std::time::Instant::now();
@@ -987,13 +917,19 @@ impl Pickers {
                 this.show_compact_models(cx);
             }))
             .when(!levels.is_empty(), |el| {
+                // The slider retitles the panel as it drags; the level name
+                // rolls between values like the composer chips.
                 el.child(
                     div()
                         .text_size(crate::typography::ui_rems(14.0))
                         .line_height(px(17.0))
                         .font_weight(gpui::FontWeight::SEMIBOLD)
                         .text_color(theme.text)
-                        .child(effort.clone()),
+                        .child(crate::roll_text::roll_text(
+                            format!("compact-effort-title-{}", cx.entity_id()),
+                            effort.clone(),
+                            reduced,
+                        )),
                 )
             })
             .child(
@@ -1113,67 +1049,16 @@ impl Pickers {
                     }),
             );
         }
-        // The provider is a square button as tall as the title, leading it.
-        // A chat whose harness is fixed shows the mark without the button.
         let header_height = if levels.is_empty() {
             HEADER_HEIGHT_SINGLE
         } else {
             HEADER_HEIGHT
         };
-        let locked = self.harness_locked(cx);
-        let provider_button = self.effective_harness(cx).map(|harness| {
-            let (icon, tint) = harness_brand_icon(harness);
-            let name: SharedString = self
-                .rail_descriptors(cx)
-                .into_iter()
-                .find(|d| d.id == harness)
-                .map(|d| d.name)
-                .unwrap_or_default()
-                .into();
-            let provider_key: SharedString = format!("compact-provider-{}", cx.entity_id()).into();
-            let provider_hover = if locked {
-                0.0
-            } else {
-                motion::hover_t(&provider_key)
-            };
-            let hint: SharedString = if locked {
-                name.clone()
-            } else {
-                format!("{name} · Change provider").into()
-            };
-            div()
-                .id("compact-select-provider")
-                .w(px(FAST_BUTTON_WIDTH))
-                .h_full()
-                .flex_none()
-                .rounded(px(popover::MENU_ITEM_RADIUS))
-                .flex()
-                .items_center()
-                .justify_center()
-                .bg(crate::theme::ink(0.05 * provider_hover))
-                .tooltip(move |_, cx| cx.new(|_| PickerHint(hint.clone())).into())
-                .when(!locked, |el| {
-                    el.role(gpui::Role::Button)
-                        .aria_label(SharedString::from(format!("{name} · Change provider")))
-                        .cursor_pointer()
-                        .on_hover(motion::hover_listener(provider_key))
-                        .on_click(cx.listener(|this, _, _, cx| {
-                            this.compact_keyboard = false;
-                            this.show_compact_providers(cx);
-                        }))
-                })
-                .child(
-                    crate::icons::icon(icon)
-                        .size(px(16.0))
-                        .text_color(tint.unwrap_or(theme.text_muted)),
-                )
-        });
         let header = div()
             .h(px(header_height))
             .flex_none()
             .flex()
             .gap(px(popover::CARD_INSET))
-            .children(provider_button)
             .child(title)
             .children(fast_button);
         let mut panel = div()
diff --git a/crates/ui/src/roll_text.rs b/crates/ui/src/roll_text.rs
new file mode 100644
index 0000000000..7eeac4edc3
--- /dev/null
+++ b/crates/ui/src/roll_text.rs
@@ -0,0 +1,504 @@
+//! Rolling label transitions — a port of Scritto's `<scritto-text>` roll
+//! (scrit.to/playground) for chip labels.
+//!
+//! When a keyed label changes, the characters it shares with the old value at
+//! either end stay put (the trailing run slides to its new place), while the
+//! changed middle rolls: old glyphs rise out and shrink away as new ones rise
+//! in from below — each softened by Scritto's 0.1em blur and 2° tilt while
+//! in motion — staggered left to right, and the label's width glides between
+//! the two. The glyphs ease out without Scritto's spring overshoot so the
+//! label lands dead still (user request).
+//!
+//! Steady state renders the ordinary truncating label, so layout, ellipsis and
+//! hit-testing are unchanged whenever nothing is moving; the custom element
+//! only exists for the ~0.7s a roll takes. Glyphs are painted from the shaped
+//! lines themselves, so kerning matches the plain label and the hand-off at
+//! the end is invisible.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+use gpui::{
+    App, Bounds, ContentMask, Element, ElementId, GlobalElementId, InspectorElementId,
+    IntoElement, LayoutId, ParentElement as _, Pixels, Radians, ScaledPixels, ShapedLine,
+    SharedString, Style, Styled as _, TextRun, TransformationMatrix, Window, div, point, px,
+};
+
+use crate::motion::{CubicBezier, EASE_OUT_QUINT, RESIZE, lerp, speed_scale};
+
+/// Scritto's default roll duration.
+const DURATION: Duration = Duration::from_millis(550);
+/// Per-glyph travel (em), resting scale, tilt (degrees), blur (em) and the
+/// stagger spread (fraction of the duration) — Scritto's
+/// `{y: .35, scale: .6, rotate: 2, blur: .1, stagger: .3}`.
+const TRAVEL_EM: f32 = 0.35;
+const REST_SCALE: f32 = 0.6;
+const TILT_DEG: f32 = 2.0;
+const BLUR_EM: f32 = 0.1;
+const STAGGER: f32 = 0.3;
+/// The glyph roll: Scritto's `cubic-bezier(.22,1,.36,1)`, a long settle with
+/// no overshoot.
+const GLIDE: CubicBezier = EASE_OUT_QUINT;
+
+/// Width and the shared trailing run settle on the shell's 200ms resize — the
+/// same clock the model chip's own width glide runs on — so whatever follows
+/// the label (the chip's effort text) reaches its final place together with
+/// the chip, early, and never moves again while the glyphs finish rolling.
+fn layout_progress(elapsed: f32) -> f32 {
+    RESIZE.progress(elapsed / RESIZE.total().as_secs_f32())
+}
+
+
+#[derive(Clone)]
+struct Roll {
+    from: SharedString,
+    to: SharedString,
+    started: Instant,
+}
+
+/// Bound on remembered labels (see [`rolling`]).
+const MAX_KEYS: usize = 256;
+
+thread_local! {
+    /// Last label per key, plus the roll in flight (if any).
+    static ROLLS: RefCell<HashMap<SharedString, (SharedString, Option<Roll>)>> =
+        RefCell::new(HashMap::new());
+}
+
+/// The whole roll in unscaled seconds: the stagger pushes the last glyph's
+/// start out by up to STAGGER of the duration.
+fn span() -> f32 {
+    DURATION.as_secs_f32() * (1.0 + STAGGER)
+}
+
+fn total() -> Duration {
+    Duration::from_secs_f32(span() * speed_scale())
+}
+
+/// The label for `key`: plain at rest, rolling for a moment after `text`
+/// changes. The first sight of a key never rolls.
+pub fn roll_text(key: impl Into<SharedString>, text: SharedString, reduced: bool) -> gpui::AnyElement {
+    rolling(key, text.clone(), reduced)
+        .unwrap_or_else(|| div().min_w_0().truncate().child(text).into_any_element())
+}
+
+/// The rolling element while `key`'s label is mid-roll, else `None` — for
+/// callers with their own at-rest presentation. Records `text` either way.
+pub fn rolling(
+    key: impl Into<SharedString>,
+    text: SharedString,
+    reduced: bool,
+) -> Option<gpui::AnyElement> {
+    let key = key.into();
+    let now = Instant::now();
+    let roll = ROLLS.with(|rolls| {
+        let mut rolls = rolls.borrow_mut();
+        // Keys can be per-turn (the working trailer), so bound the map: past
+        // the cap, forget settled labels — they show plain next time.
+        if rolls.len() >= MAX_KEYS && !rolls.contains_key(&key) {
+            rolls.retain(|_, (_, roll)| roll.is_some());
+        }
+        let entry = rolls.entry(key).or_insert_with(|| (text.clone(), None));
+        if entry.0 != text {
+            let from = std::mem::replace(&mut entry.0, text.clone());
+            entry.1 = (!reduced).then(|| Roll {
+                from,
+                to: text.clone(),
+                started: now,
+            });
+        }
+        // Finished — or reduced motion switched on mid-roll, where no frames
+        // would come to finish it: settle on the plain label now.
+        if reduced
+            || entry
+                .1
+                .as_ref()
+                .is_some_and(|roll| now.saturating_duration_since(roll.started) >= total())
+        {
+            entry.1 = None;
+        }
+        entry.1.clone()
+    });
+    roll.map(|roll| RollText { roll }.into_any_element())
+}
+
+/// Byte lengths of the shared leading and trailing character runs, never
+/// overlapping in either string.
+fn shared_ends(from: &str, to: &str) -> (usize, usize) {
+    let prefix: usize = from
+        .chars()
+        .zip(to.chars())
+        .take_while(|(a, b)| a == b)
+        .map(|(c, _)| c.len_utf8())
+        .sum();
+    let room = (from.len() - prefix).min(to.len() - prefix);
+    let suffix: usize = from[prefix..]
+        .chars()
+        .rev()
+        .zip(to[prefix..].chars().rev())
+        .take_while(|(a, b)| a == b)
+        .map(|(c, _)| c.len_utf8())
+        .scan(0, |sum, len| {
+            *sum += len;
+            Some(*sum)
+        })
+        .take_while(|sum| *sum <= room)
+        .last()
+        .unwrap_or(0);
+    (prefix, suffix)
+}
+
+struct RollText {
+    roll: Roll,
+}
+
+/// One shaped glyph: its x and advance in the line, and its byte index.
+struct Glyph {
+    font: gpui::FontId,
+    id: gpui::GlyphId,
+    index: usize,
+    x: f32,
+    /// The shaper's vertical offset, which gpui adds below the baseline.
+    y: f32,
+    advance: f32,
+    emoji: bool,
+}
+
+struct Shaped {
+    from: ShapedLine,
+    to: ShapedLine,
+    font_size: Pixels,
+    line_height: Pixels,
+}
+
+impl IntoElement for RollText {
+    type Element = Self;
+
+    fn into_element(self) -> Self::Element {
+        self
+    }
+}
+
+impl RollText {
+    fn elapsed(&self) -> f32 {
+        Instant::now()
+            .saturating_duration_since(self.roll.started)
+            .as_secs_f32()
+            / speed_scale()
+    }
+}
+
+impl Element for RollText {
+    type RequestLayoutState = Shaped;
+    type PrepaintState = ();
+
+    fn id(&self) -> Option<ElementId> {
+        None
+    }
+
+    fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
+        None
+    }
+
+    fn request_layout(
+        &mut self,
+        _id: Option<&GlobalElementId>,
+        _inspector_id: Option<&InspectorElementId>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> (LayoutId, Shaped) {
+        let text_style = window.text_style();
+        let font_size = text_style.font_size.to_pixels(window.rem_size());
+        // Exactly gpui's text element: line height snapped to the device
+        // pixel grid (not rounded to a logical pixel), so the line box and
+        // baseline match the plain label it hands off to.
+        let line_height = window.pixel_snap(
+            text_style
+                .line_height
+                .to_pixels(font_size.into(), window.rem_size()),
+        );
+        let shape = |text: &SharedString| {
+            let run = TextRun {
+                len: text.len(),
+                font: text_style.font(),
+                color: text_style.color,
+                background_color: None,
+                underline: None,
+                strikethrough: None,
+            };
+            window
+                .text_system()
+                .shape_line(text.clone(), font_size, &[run], None)
+        };
+        let from = shape(&self.roll.from);
+        let to = shape(&self.roll.to);
+        let progress = layout_progress(self.elapsed());
+        // Rounded up like gpui's text element sizes the plain label, so the
+        // settled width equals the label that replaces this element.
+        let width = lerp(f32::from(from.width), f32::from(to.width), progress).ceil();
+        let mut style = Style::default();
+        style.size.width = gpui::Length::Definite(px(width).into());
+        style.size.height = gpui::Length::Definite(line_height.into());
+        style.min_size.width = px(0.0).into();
+        style.flex_shrink = 1.0;
+        let layout_id = window.request_layout(style, [], cx);
+        (
+            layout_id,
+            Shaped {
+                from,
+                to,
+                font_size,
+                line_height,
+            },
+        )
+    }
+
+    fn prepaint(
+        &mut self,
+        _id: Option<&GlobalElementId>,
+        _inspector_id: Option<&InspectorElementId>,
+        _bounds: Bounds<Pixels>,
+        _request_layout: &mut Shaped,
+        _window: &mut Window,
+        _cx: &mut App,
+    ) {
+    }
+
+    fn paint(
+        &mut self,
+        _id: Option<&GlobalElementId>,
+        _inspector_id: Option<&InspectorElementId>,
+        bounds: Bounds<Pixels>,
+        shaped: &mut Shaped,
+        _prepaint: &mut (),
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        let elapsed = self.elapsed();
+        let duration = DURATION.as_secs_f32();
+        let color = window.text_style().color;
+        let font_size = shaped.font_size;
+        let travel = f32::from(font_size) * TRAVEL_EM;
+        let (prefix, suffix) = shared_ends(&self.roll.from, &self.roll.to);
+        let from_len = self.roll.from.len();
+        let to_len = self.roll.to.len();
+        // The trailing run slides from its old x to its new one with the width.
+        let slide = layout_progress(elapsed);
+        let suffix_dx = f32::from(
+            shaped.from.x_for_index(from_len - suffix) - shaped.to.x_for_index(to_len - suffix),
+        ) * (1.0 - slide);
+
+        // Glyphs of one line with their x extents and role.
+        let glyphs = |line: &ShapedLine| {
+            let mut out = Vec::new();
+            for run in line.runs.iter() {
+                for glyph in &run.glyphs {
+                    out.push((
+                        run.font_id,
+                        glyph.id,
+                        glyph.index,
+                        f32::from(glyph.position.x),
+                        f32::from(glyph.position.y),
+                        glyph.is_emoji,
+                    ));
+                }
+            }
+            let width = f32::from(line.width);
+            let ends: Vec<f32> = out
+                .iter()
+                .skip(1)
+                .map(|g| g.3)
+                .chain(std::iter::once(width))
+                .collect();
+            out.into_iter()
+                .zip(ends)
+                .map(|((font, id, index, x, y, emoji), end)| Glyph {
+                    font,
+                    id,
+                    index,
+                    x,
+                    y,
+                    advance: (end - x).max(0.0),
+                    emoji,
+                })
+                .collect::<Vec<_>>()
+        };
+        let from_glyphs = glyphs(&shaped.from);
+        let to_glyphs = glyphs(&shaped.to);
+        let changed = |index: usize, len: usize| index >= prefix && index < len - suffix;
+        // Stagger sweeps left to right across each side's changed glyphs.
+        let sweep = |list: &[Glyph], len: usize| {
+            let xs: Vec<f32> = list
+                .iter()
+                .filter(|g| changed(g.index, len))
+                .map(|g| g.x)
+                .collect();
+            let count = xs.len();
+            let min = xs.iter().copied().fold(f32::INFINITY, f32::min);
+            let max = xs.iter().copied().fold(f32::NEG_INFINITY, f32::max);
+            let spread = duration * STAGGER * count.saturating_sub(1) as f32 / count.max(1) as f32;
+            move |x: f32| {
+                if max > min {
+                    spread * ((x - min) / (max - min)).clamp(0.0, 1.0)
+                } else {
+                    0.0
+                }
+            }
+        };
+        let from_delay = sweep(&from_glyphs, from_len);
+        let to_delay = sweep(&to_glyphs, to_len);
+
+        let padding_top = (shaped.line_height - shaped.to.ascent - shaped.to.descent) / 2.0;
+        let baseline = bounds.origin.y + padding_top + shaped.to.ascent;
+        let center_y = f32::from(bounds.origin.y + shaped.line_height / 2.0);
+        let scale_factor = window.scale_factor();
+        // Vertical room for glyphs rolling past the line box, and a small
+        // horizontal allowance for the blur halo; the width otherwise clips.
+        let room = px(travel * 2.0);
+        let halo = px((f32::from(font_size) * BLUR_EM * 3.0).ceil());
+        let mask = Bounds {
+            origin: point(bounds.origin.x - halo, bounds.origin.y - room),
+            size: gpui::size(bounds.size.width + halo * 2.0, bounds.size.height + room * 2.0),
+        };
+        // `motion` = 1 − progress: Scritto's resting-state distance. Tilt and
+        // blur fade with it; scale and translate are the caller's.
+        let paint = |window: &mut Window,
+                     glyph: &Glyph,
+                     dx: f32,
+                     dy: f32,
+                     scale: f32,
+                     motion: f32,
+                     alpha: f32| {
+            if alpha <= 0.0 {
+                return;
+            }
+            let left = f32::from(bounds.origin.x) + glyph.x;
+            let center_x = left + glyph.advance / 2.0;
+            let rest_origin = point(px(left), px(f32::from(baseline) + glyph.y));
+            if glyph.emoji {
+                // Emoji can be neither tinted nor transformed; they swap at
+                // the midpoint and ride the translation alone.
+                if alpha < 0.5 {
+                    return;
+                }
+                let origin = point(px(left + dx), px(f32::from(baseline) + glyph.y + dy));
+                let _ = window.paint_emoji(origin, glyph.font, glyph.id, font_size);
+                return;
+            }
+            if motion <= 0.0 && dx == 0.0 && dy == 0.0 {
+                // At rest (the shared runs): the ordinary pipeline, so these
+                // glyphs antialias exactly like the label they hand off to.
+                let _ = window.paint_glyph(
+                    rest_origin,
+                    glyph.font,
+                    glyph.id,
+                    font_size,
+                    color.opacity(alpha.min(1.0)),
+                );
+                return;
+            }
+            if scale >= 1.0 && motion <= 0.0 {
+                // The sliding tail: a pure translation, same pipeline.
+                let origin = point(px(left + dx), px(f32::from(baseline) + glyph.y + dy));
+                let _ = window.paint_glyph(
+                    origin,
+                    glyph.font,
+                    glyph.id,
+                    font_size,
+                    color.opacity(alpha.min(1.0)),
+                );
+                return;
+            }
+            // Mid-roll: one full-size raster, scaled and tilted about the
+            // glyph's center at composite time, softened by Scritto's blur.
+            let dev = |value: f32| ScaledPixels(value * scale_factor);
+            let transformation = TransformationMatrix::unit()
+                .translate(point(dev(center_x + dx), dev(center_y + dy)))
+                .rotate(Radians((TILT_DEG * motion).to_radians()))
+                .scale(gpui::size(scale, scale))
+                .translate(point(dev(-center_x), dev(-center_y)));
+            let _ = window.paint_glyph_transformed(
+                rest_origin,
+                glyph.font,
+                glyph.id,
+                font_size,
+                color.opacity(alpha.min(1.0)),
+                transformation,
+                px(f32::from(font_size) * BLUR_EM * motion),
+            );
+        };
+        window.with_content_mask(Some(ContentMask { bounds: mask }), |window| {
+            for glyph in &from_glyphs {
+                if !changed(glyph.index, from_len) {
+                    continue; // the new line paints the shared runs
+                }
+                let progress = GLIDE.eval(((elapsed - from_delay(glyph.x)) / duration).clamp(0.0, 1.0));
+                paint(
+                    window,
+                    glyph,
+                    0.0,
+                    -travel * progress,
+                    lerp(1.0, REST_SCALE, progress),
+                    progress,
+                    1.0 - progress,
+                );
+            }
+            for glyph in &to_glyphs {
+                if glyph.index < prefix {
+                    paint(window, glyph, 0.0, 0.0, 1.0, 0.0, 1.0);
+                } else if glyph.index >= to_len - suffix {
+                    paint(window, glyph, suffix_dx, 0.0, 1.0, 0.0, 1.0);
+                } else {
+                    let progress =
+                        GLIDE.eval(((elapsed - to_delay(glyph.x)) / duration).clamp(0.0, 1.0));
+                    paint(
+                        window,
+                        glyph,
+                        0.0,
+                        travel * (1.0 - progress),
+                        lerp(REST_SCALE, 1.0, progress),
+                        1.0 - progress,
+                        progress,
+                    );
+                }
+            }
+        });
+        // Keep rolling on the shared ~30Hz pulse clock rather than at the
+        // display's refresh rate: the working timer rolls every second, and
+        // full-rate frames for most of every agent turn were exactly the
+        // battery drain the pulse clock exists to prevent. The lease lapses
+        // on its own once the roll stops painting.
+        if Instant::now().saturating_duration_since(self.roll.started) < total() {
+            crate::motion::pulse_lease(window.current_view(), cx);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shared_ends_keep_common_runs() {
+        assert_eq!(shared_ends("Opus 5.5", "Opus 5.1"), (7, 0));
+        assert_eq!(shared_ends("feature/a", "fix/a"), (1, 2));
+        assert_eq!(shared_ends("main", "main-2"), (4, 0));
+        // Never overlapping: "aa" → "aaa" shares the two leading chars only.
+        assert_eq!(shared_ends("aa", "aaa"), (2, 0));
+        assert_eq!(shared_ends("ab", "b"), (0, 1));
+    }
+
+    #[test]
+    fn glyphs_settle_without_overshoot() {
+        assert_eq!(GLIDE.eval(0.0), 0.0);
+        assert_eq!(GLIDE.eval(1.0), 1.0);
+        let mut last = 0.0;
+        for i in 0..=200 {
+            let value = GLIDE.eval(i as f32 / 200.0);
+            assert!(value <= 1.0, "overshoot at {i}: {value}");
+            assert!(value >= last, "not monotonic at {i}");
+            last = value;
+        }
+    }
+}
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index e990e96c92..fd1431a3b1 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -6475,9 +6475,19 @@ impl Shell {
                     .h_full()
                     .w(px(caption_buttons_width(self.linux_left_caption_count())))
             }))
-            .child(window_control_button(
+            .child(window_control_button_with(
                 "toggle-sidebar",
-                icons::SIDEBAR_MINIMALISTIC_LEFT,
+                icons::sidebar_glyph(
+                    motion::state_t(
+                        "toggle-sidebar",
+                        !self.settings.sidebar_collapsed,
+                        motion::GLYPH_STATE,
+                        self.reduced_motion,
+                    ),
+                    false,
+                    16.0,
+                    theme.text_muted,
+                ),
                 ShortcutId::ToggleSidebar.label(),
                 &theme,
                 cx.listener(|this, _, _, cx| this.toggle_sidebar(cx)),
@@ -7177,6 +7187,9 @@ impl Shell {
         // nine chips appear together instead of leaving a hole on whichever
         // row is busy or under the pointer.
         jump_label: Option<SharedString>,
+        // Whether the row wears its project icon. Rows inside a project
+        // group leave it to the group header.
+        project_icon: bool,
         search_query: Option<&str>,
         theme: &Theme,
         cx: &mut Context<Self>,
@@ -7205,7 +7218,7 @@ impl Shell {
             .is_some_and(|chat| {
                 self.state.read(cx).local_device_id.as_deref() != Some(chat.device_id.as_str())
             });
-        let project_icon = (search_query.is_none() && self.settings.sidebar_show_project_icon)
+        let project_icon = (project_icon && search_query.is_none())
             .then(|| self.render_project_icon(&id, SIDEBAR_ACTIVE_HARNESS_ICON_SIZE, selected, cx));
         let corner_hovered = !preview && self.chat_status_hover.as_deref() == Some(row_id.as_str());
         let archived_muted = archived && search_query.is_none() && !selected && !corner_hovered;
@@ -7719,22 +7732,33 @@ impl Shell {
                                 .text_color(subline),
                         )
                     })
-                    .when(
-                        if compact {
-                            remote || corner_hovered
-                        } else {
-                            !show_label
-                        },
-                        |el| {
-                            el.child(
-                                div()
-                                    .flex_none()
-                                    .text_color(subline)
-                                    .children(corner.take()),
-                            )
-                        },
-                    )
+                    .when(!compact && !show_label, |el| {
+                        el.child(
+                            div()
+                                .flex_none()
+                                .text_color(subline)
+                                .children(corner.take()),
+                        )
+                    })
+                    // Compact trailing cluster, right-packed: the PR badge sits
+                    // LEFT of one fixed slot that shows the relative time, swaps
+                    // to the archive affordance while the row is hovered, and
+                    // shows the Cmd+N jump legend while the modifier is held.
+                    // The legend wins over the hover archive (user request).
+                    // There is no remote globe — the slot's fixed width keeps
+                    // the column aligned across rows regardless of a PR badge.
                     .when(compact, |el| {
+                        // Cmd-held legend beats the hover archive; preview rows
+                        // (the palette) never archive.
+                        let show_legend = compact_jump_label.is_some();
+                        let show_archive = corner_hovered && !show_legend && !preview;
+                        // The slot is 30px (holds "17m"); a text-length jump
+                        // hint widens it to a floor so "Ctrl+1" vs "Ctrl+2"
+                        // never nudges the column.
+                        let text_hint = compact_jump_label
+                            .as_ref()
+                            .is_some_and(|label| label.chars().count() > 3);
+                        let archive_id = id.clone();
                         el.children(change_request.clone().map(|summary| {
                             if preview {
                                 crate::change_requests::pull_request_badge_preview(
@@ -7752,22 +7776,9 @@ impl Shell {
                                 )
                             }
                         }))
-                    })
-                    .when(compact, |el| {
-                        // The time slot is 30px, which holds "17m" but not
-                        // "Ctrl+2": unwrapped, the hint broke after the `+`
-                        // and stacked two lines. A text-length hint keeps one
-                        // line in a wider slot — a floor, not content sized,
-                        // so "Ctrl+1" (a narrower glyph) doesn't nudge its
-                        // row's badge off the others'. The floor scales with
-                        // the UI font like the text does, and a longer
-                        // rebound combo grows the slot instead of spilling
-                        // over the title.
-                        let text_hint = compact_jump_label
-                            .as_ref()
-                            .is_some_and(|label| label.chars().count() > 3);
-                        el.child(
+                        .child(
                             div()
+                                .id(SharedString::from(format!("{row_id}-corner")))
                                 .debug_selector({
                                     let id = id.clone();
                                     move || format!("chat-time-{id}")
@@ -7776,12 +7787,59 @@ impl Shell {
                                     el.min_w(crate::typography::ui_rems(COMPACT_JUMP_HINT_WIDTH))
                                 })
                                 .when(!text_hint, |el| el.w(px(30.0)))
+                                // Fixed height so swapping the time text for the
+                                // archive glyph never resizes the slot.
+                                .h(px(14.0))
                                 .flex_none()
-                                .whitespace_nowrap()
-                                .text_right()
-                                .text_size(crate::typography::ui_rems(11.0))
-                                .text_color(subline)
-                                .child(compact_jump_label.unwrap_or(time_ago)),
+                                .flex()
+                                .items_center()
+                                .justify_end()
+                                .aria_label(if show_archive {
+                                    if archived { "Unarchive" } else { "Archive" }
+                                } else {
+                                    "Session time"
+                                })
+                                .when(show_archive, |el| {
+                                    el.cursor_pointer()
+                                        .on_mouse_down(MouseButton::Left, |_, _, cx| {
+                                            cx.stop_propagation()
+                                        })
+                                        .on_click(cx.listener(move |this, _, _, cx| {
+                                            cx.stop_propagation();
+                                            this.chat_hover_resync = true;
+                                            this.set_chat_archived(
+                                                archive_id.clone(),
+                                                !archived,
+                                                cx,
+                                            );
+                                        }))
+                                        .tooltip(crate::settings::widgets::text_tooltip_above(
+                                            if archived {
+                                                "Unarchive session"
+                                            } else {
+                                                ShortcutId::ArchiveSession.label()
+                                            },
+                                        ))
+                                })
+                                .child(if show_archive {
+                                    icon(if archived {
+                                        icons::ARCHIVE_UP_MINIMALISTIC
+                                    } else {
+                                        icons::ARCHIVE_MINIMALISTIC
+                                    })
+                                    .size(px(SIDEBAR_ACTIVE_HARNESS_ICON_SIZE))
+                                    .flex_none()
+                                    .text_color(theme.text_muted)
+                                    .into_any_element()
+                                } else {
+                                    div()
+                                        .whitespace_nowrap()
+                                        .text_right()
+                                        .text_size(crate::typography::ui_rems(11.0))
+                                        .text_color(subline)
+                                        .child(compact_jump_label.unwrap_or(time_ago))
+                                        .into_any_element()
+                                }),
                         )
                     }),
             )
@@ -12142,7 +12200,19 @@ fn window_control_button(
     theme: &Theme,
     on_click: impl Fn(&gpui::ClickEvent, &mut Window, &mut App) + 'static,
 ) -> impl IntoElement {
-    let muted = theme.text_muted;
+    let glyph = icon(icon_path).size(px(16.0)).text_color(theme.text_muted);
+    window_control_button_with(id, glyph, label, theme, on_click)
+}
+
+/// [`window_control_button`] around a caller-drawn glyph (the morphing
+/// sidebar glyph).
+fn window_control_button_with(
+    id: &'static str,
+    glyph: impl IntoElement,
+    label: &'static str,
+    theme: &Theme,
+    on_click: impl Fn(&gpui::ClickEvent, &mut Window, &mut App) + 'static,
+) -> impl IntoElement {
     let fade_key = format!("window-control-{id}");
     div()
         .id(id)
@@ -12179,7 +12249,7 @@ fn window_control_button(
             on_click(event, window, cx)
         })
         .tooltip(crate::settings::widgets::text_tooltip(label))
-        .child(icon(icon_path).size(px(16.0)).text_color(muted))
+        .child(glyph)
 }
 
 const WINDOWS_CAPTION_BUTTON_WIDTH: f32 = 36.0;
@@ -12328,7 +12398,18 @@ fn header_icon_button(
     theme: &Theme,
     on_click: impl Fn(&gpui::ClickEvent, &mut Window, &mut App) + 'static,
 ) -> gpui::Stateful<gpui::Div> {
-    let muted = theme.text_muted;
+    let glyph = icon(icon_path).size(px(16.0)).text_color(theme.text_muted);
+    header_icon_button_with(id, glyph, label, on_click)
+}
+
+/// [`header_icon_button`] around a caller-drawn glyph (the morphing sidebar
+/// glyph).
+fn header_icon_button_with(
+    id: &'static str,
+    glyph: impl IntoElement,
+    label: &'static str,
+    on_click: impl Fn(&gpui::ClickEvent, &mut Window, &mut App) + 'static,
+) -> gpui::Stateful<gpui::Div> {
     let fade_key = format!("header-icon-{id}");
     div()
         .id(id)
@@ -12356,7 +12437,7 @@ fn header_icon_button(
             on_click(event, window, cx)
         })
         .tooltip(crate::settings::widgets::text_tooltip(label))
-        .child(icon(icon_path).size(px(16.0)).text_color(muted))
+        .child(glyph)
 }
 
 impl Render for Shell {
@@ -13054,7 +13135,8 @@ impl Render for Shell {
         // scheduling `with_animation` would have requested). Hover color fades
         // ride the same clock; their once-per-frame tick lives here (this is
         // the window's root render — it runs exactly once per frame).
-        if self.motion_active.get() | motion::hover_fades_active() {
+        if self.motion_active.get() | motion::hover_fades_active() | motion::state_morphs_active()
+        {
             window.request_animation_frame();
         }
 
@@ -15323,6 +15405,7 @@ mod exit_regressions {
                         git_detected: false,
                         git_checked_at: None,
                         checkout_id: None,
+                        repository_id: None,
                         created_at: Utc::now(),
                     }]);
                     // Boot opened an existing project session after loading defaults.
@@ -15391,6 +15474,7 @@ mod exit_regressions {
             git_detected: false,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: Utc::now(),
         };
         window
@@ -15471,6 +15555,7 @@ mod exit_regressions {
             git_detected: false,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: Utc::now(),
         };
         window
@@ -15740,6 +15825,7 @@ mod exit_regressions {
                         git_detected: false,
                         git_checked_at: None,
                         checkout_id: None,
+                        repository_id: None,
                         created_at: Utc::now(),
                     }]);
                 });
diff --git a/crates/ui/src/shell/command_palette.rs b/crates/ui/src/shell/command_palette.rs
index d59d702240..25b79e41a2 100644
--- a/crates/ui/src/shell/command_palette.rs
+++ b/crates/ui/src/shell/command_palette.rs
@@ -337,6 +337,7 @@ impl Shell {
                     false,
                     None,
                     None,
+                    false,
                     Some(&query),
                     &theme,
                     cx,
diff --git a/crates/ui/src/shell/project_icon.rs b/crates/ui/src/shell/project_icon.rs
index 2d2347b9ca..f9e2471dc0 100644
--- a/crates/ui/src/shell/project_icon.rs
+++ b/crates/ui/src/shell/project_icon.rs
@@ -288,8 +288,9 @@ impl Shell {
     ) -> AnyElement {
         let state = self.state.read(cx);
         let chat = state.chats.iter().find(|chat| chat.id == chat_id);
-        let space = chat.and_then(|chat| state.space_for_chat(chat));
-        let name = space
+        // The tooltip names this row's own project; the artwork is shared.
+        let name = chat
+            .and_then(|chat| state.space_for_chat(chat))
             .map(|space| space.display_name().to_string())
             .unwrap_or_else(|| "Home".into());
         // Same fallback as the row's "@ device" fragment.
@@ -297,10 +298,55 @@ impl Shell {
             .and_then(|chat| state.device_name(&chat.device_id))
             .unwrap_or("Unknown device")
             .to_string();
-        let seed = space
+        let art = self.project_icon_art(chat_id, selected, cx);
+        project_icon_frame(chat_id, &name, &device, size, art)
+    }
+
+    /// A project group header's icon: the same artwork its rows would wear,
+    /// without the tooltip — the label beside it already names the project.
+    pub(super) fn render_project_group_icon(
+        &self,
+        chat_id: &str,
+        size: f32,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        div()
+            .size(px(size))
+            .flex_none()
+            .child(self.project_icon_art(chat_id, false, cx))
+            .into_any_element()
+    }
+
+    /// Artwork for a chat's project, shared by every space of the project:
+    /// the representative's name and color, read from this device's checkout
+    /// when there is one (no round trip), else from the representative.
+    fn project_icon_art(
+        &self,
+        chat_id: &str,
+        selected: bool,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let state = self.state.read(cx);
+        let space = state
+            .chats
+            .iter()
+            .find(|chat| chat.id == chat_id)
+            .and_then(|chat| state.space_for_chat(chat));
+        let representative = space.map(|space| state.representative_space(space));
+        let name = representative
+            .map(|space| space.display_name().to_string())
+            .unwrap_or_else(|| "Home".into());
+        let seed = representative
             .map(|space| space.path.clone())
             .unwrap_or_else(|| "home".into());
-        let context = space.map(|space| FilesRequestContext {
+        let artwork = space.map(|space| {
+            state
+                .project_members(space)
+                .into_iter()
+                .find(|member| state.local_device_id.as_deref() == Some(&member.device_id))
+                .unwrap_or_else(|| state.representative_space(space))
+        });
+        let context = artwork.map(|space| FilesRequestContext {
             target: zeron_proto::WorkspaceTarget {
                 chat_id: None,
                 space_id: Some(space.id.clone()),
@@ -312,13 +358,7 @@ impl Shell {
             checkout_id: space.checkout_id.clone(),
         });
         let Some(context) = context else {
-            return project_icon_frame(
-                chat_id,
-                &name,
-                &device,
-                size,
-                monogram(&name, &seed, selected, Theme::of(cx)),
-            );
+            return monogram(&name, &seed, selected, Theme::of(cx));
         };
         let key = format!(
             "{:?}:{:?}:{}:{:?}:{}",
@@ -331,13 +371,7 @@ impl Shell {
         let engine = state.engine().cloned();
         // Don't cache a remote miss before a connection exists.
         if context.target_device_id.is_some() && engine.is_none() {
-            return project_icon_frame(
-                chat_id,
-                &name,
-                &device,
-                size,
-                monogram(&name, &seed, selected, Theme::of(cx)),
-            );
+            return monogram(&name, &seed, selected, Theme::of(cx));
         }
         let mut cache = self.project_icons.borrow_mut();
         cache.retain(|_, entity| entity.read(cx).refreshed.elapsed() < Duration::from_secs(300));
@@ -355,15 +389,9 @@ impl Shell {
             .clone();
         drop(cache);
         if entity.read(cx).media.is_none() {
-            return project_icon_frame(
-                chat_id,
-                &name,
-                &device,
-                size,
-                monogram(&name, &seed, selected, Theme::of(cx)),
-            );
+            return monogram(&name, &seed, selected, Theme::of(cx));
         }
-        project_icon_frame(chat_id, &name, &device, size, entity)
+        entity.into_any_element()
     }
 }
 
diff --git a/crates/ui/src/shell/spaces.rs b/crates/ui/src/shell/spaces.rs
index 710b3815ea..3b437e1870 100644
--- a/crates/ui/src/shell/spaces.rs
+++ b/crates/ui/src/shell/spaces.rs
@@ -918,6 +918,81 @@ mod pinned_session_tests {
         cx.run_until_parked();
     }
 
+    #[gpui::test]
+    fn sidebar_projects_sharing_a_repository_group_only_by_project(cx: &mut gpui::TestAppContext) {
+        use super::*;
+        let dir = tempfile::tempdir().unwrap();
+        let window = pin_test_shell(cx, dir.path());
+        window
+            .update(cx, |shell, _, cx| {
+                shell.settings.sidebar_organization = SidebarOrganization::ByProject;
+                shell.state.update(cx, |state, _| {
+                    state.workspace_scope = Some(WorkspaceScope::Local);
+                    state.local_device_id = Some("local".into());
+                    // The same repository on this device and on another,
+                    // plus an unrelated local project.
+                    state.spaces = [
+                        ("remote-clone", "remote", Some("github.com/o/r"), 0),
+                        ("local-clone", "local", Some("github.com/o/r"), 1),
+                        ("other", "local", None, 2),
+                    ]
+                    .into_iter()
+                    .map(|(id, device, repository, minutes)| {
+                        serde_json::from_value(serde_json::json!({
+                            "id": id, "deviceId": device, "path": format!("/{device}/{id}"),
+                            "name": id, "repositoryId": repository,
+                            "createdAt": Utc::now() - chrono::Duration::minutes(10 - minutes),
+                        }))
+                        .unwrap()
+                    })
+                    .collect();
+                    state.chats = [
+                        ("remote-new", "remote-clone", "remote"),
+                        ("other-mid", "other", "local"),
+                        ("local-old", "local-clone", "local"),
+                    ]
+                    .into_iter()
+                    .enumerate()
+                    .map(|(ix, (id, space, device))| {
+                        let mut chat = pin_test_chat(id);
+                        chat.space_id = Some(space.into());
+                        chat.device_id = device.into();
+                        chat.created_at = Utc::now() - chrono::Duration::minutes(ix as i64);
+                        chat
+                    })
+                    .collect();
+                });
+                assert_eq!(
+                    shell.sidebar_visible_order(cx),
+                    ids(&["remote-new", "local-old", "other-mid"])
+                );
+                // The oldest clone names the group on every device; this
+                // device's checkout leads the project's members.
+                let state = shell.state.read(cx);
+                let local_chat = state.chats.iter().find(|c| c.id == "local-old").unwrap();
+                assert_eq!(
+                    sidebar_project_group(state, local_chat),
+                    ("repo:github.com/o/r".into(), "remote-clone".into())
+                );
+                let local_space = state.space_row("local-clone").unwrap();
+                assert_eq!(state.representative_space(local_space).id, "remote-clone");
+                let members: Vec<&str> = state
+                    .project_members(local_space)
+                    .into_iter()
+                    .map(|space| space.id.as_str())
+                    .collect();
+                assert_eq!(members, ["local-clone", "remote-clone"]);
+
+                shell.settings.sidebar_organization = SidebarOrganization::ByDevice;
+                assert_eq!(
+                    shell.sidebar_visible_order(cx),
+                    ids(&["other-mid", "local-old", "remote-new"])
+                );
+            })
+            .unwrap();
+        cx.run_until_parked();
+    }
+
     #[gpui::test]
     fn sidebar_remote_pins_ignore_old_local_preferences(cx: &mut gpui::TestAppContext) {
         let dir = tempfile::tempdir().unwrap();
@@ -1239,7 +1314,10 @@ mod pinned_session_tests {
             let row = cx.debug_bounds("chat-older").unwrap();
             let title = cx.debug_bounds("chat-title-older").unwrap();
             cx.simulate_mouse_move(row.center(), None, gpui::Modifiers::default());
-            assert!(cx.debug_bounds("chat-title-older").unwrap().size.width < title.size.width);
+            // The globe/archive slot is always reserved, so hovering swaps its
+            // glyph in place: the title keeps its width and the status and time
+            // columns never move.
+            assert_eq!(cx.debug_bounds("chat-title-older").unwrap().size.width, title.size.width);
             assert_eq!(cx.debug_bounds("chat-status-older").unwrap(), status);
             assert_eq!(cx.debug_bounds("chat-time-older").unwrap(), time);
         }
@@ -1695,11 +1773,11 @@ mod pinned_session_tests {
 
         let row = cx.debug_bounds("chat-a").unwrap();
         cx.simulate_mouse_move(row.center(), None, gpui::Modifiers::default());
-        let pointer = cx.debug_bounds("chat-a-corner").unwrap().center();
+        let pointer = cx.debug_bounds("chat-time-a").unwrap().center();
         cx.simulate_mouse_move(pointer, None, gpui::Modifiers::default());
         for (archived, next) in [
-            ("a", Some(("b", "chat-b-corner"))),
-            ("b", Some(("c", "chat-c-corner"))),
+            ("a", Some(("b", "chat-time-b"))),
+            ("b", Some(("c", "chat-time-c"))),
             ("c", None),
         ] {
             cx.simulate_click(pointer, gpui::Modifiers::default());
@@ -2101,13 +2179,31 @@ fn promote_local_device_group<T>(
     }
 }
 
+/// Project-mode group of a chat as (key, label). Projects sharing a
+/// repository identity fold into one group named for their representative
+/// space; project-less sessions group per device and read as `~`.
+fn sidebar_project_group(state: &AppState, chat: &zeron_proto::Chat) -> (String, String) {
+    match state.space_for_chat(chat) {
+        Some(space) => (
+            zeron_proto::view::project_key(space),
+            state.representative_space(space).display_name().to_string(),
+        ),
+        None => match chat.space_id.clone() {
+            Some(space_id) => (space_id, "?".to_string()),
+            None => (format!("home:{}", chat.device_id), "~".to_string()),
+        },
+    }
+}
+
 /// Shared quiet rule for sidebar groups and palette sections.
 pub(super) fn sidebar_separator(theme: &Theme) -> gpui::Div {
     div().h(px(1.0)).bg(theme.border.opacity(0.6))
 }
 
+/// `icon` leads the label — a project group's icon, which its rows then omit.
 fn sidebar_disclosure_header(
     theme: &Theme,
+    icon: Option<AnyElement>,
     label: SharedString,
     action: Option<AnyElement>,
     chevron: AnyElement,
@@ -2120,6 +2216,7 @@ fn sidebar_disclosure_header(
         .h(px(SIDEBAR_DISCLOSURE_HEADER_HEIGHT))
         .px(px(Theme::SPACE_SM))
         .cursor_pointer()
+        .children(icon)
         .child(super::sidebar_faded_label(
             "sidebar-disclosure-label".into(),
             false,
@@ -3806,7 +3903,7 @@ impl Shell {
     }
 
     /// The sidebar's space-filter row: current filter ("All projects" or the
-    /// space's name) + chevron, the dropdown floating beneath while open.
+    /// space's name), the dropdown floating beneath while open.
     /// Sits OUTSIDE the sidebar's scroll region so the float never clips.
     pub(super) fn render_spaces_filter(
         &mut self,
@@ -3879,9 +3976,8 @@ impl Shell {
                     .flex_none()
                     .text_color(theme.text_muted),
             )
-            // flex_1 pushes the caret to the trigger's right edge and gives
-            // long space names a bound to fade against; the "@ device"
-            // tag hugs the name inside it rather than sitting by the caret.
+            // flex_1 gives long space names a bound to fade against; the
+            // "@ device" tag hugs the name inside it.
             .child(
                 div()
                     .flex_1()
@@ -3915,12 +4011,6 @@ impl Shell {
                             )
                         })
                     }),
-            )
-            .child(
-                icon(icons::ALT_ARROW_DOWN)
-                    .size(px(14.0))
-                    .flex_none()
-                    .text_color(theme.text_muted.opacity(0.6)),
             );
         let trigger = if self.spaces_menu.get().is_some() {
             let closing = self.spaces_menu.closing_since();
@@ -4268,9 +4358,7 @@ impl Shell {
             for chat in chats {
                 let key = Some((
                     if self.settings.sidebar_organization == SidebarOrganization::ByProject {
-                        chat.space_id
-                            .clone()
-                            .unwrap_or_else(|| format!("home:{}", chat.device_id))
+                        sidebar_project_group(state, &chat).0
                     } else {
                         chat.device_id.clone()
                     },
@@ -4314,14 +4402,10 @@ impl Shell {
 
     /// The group a chat's row sits under when the sidebar groups by device or
     /// by project; `None` in one list.
-    fn sidebar_group_key(&self, chat: &zeron_proto::Chat) -> Option<String> {
+    fn sidebar_group_key(&self, state: &AppState, chat: &zeron_proto::Chat) -> Option<String> {
         match self.settings.sidebar_organization {
             SidebarOrganization::ByDevice => Some(chat.device_id.clone()),
-            SidebarOrganization::ByProject => Some(
-                chat.space_id
-                    .clone()
-                    .unwrap_or_else(|| format!("home:{}", chat.device_id)),
-            ),
+            SidebarOrganization::ByProject => Some(sidebar_project_group(state, chat).0),
             SidebarOrganization::InOneList => None,
         }
     }
@@ -4384,7 +4468,7 @@ impl Shell {
                     }
                     self.queue_sidebar_reveal(&format!("custom:{}", section.id));
                 }
-            } else if let Some(group) = self.sidebar_group_key(chat) {
+            } else if let Some(group) = self.sidebar_group_key(self.state.read(cx), chat) {
                 let collapse_key = self.sidebar_group_collapse_key(&group);
                 if self.sidebar_collapsed_groups.remove(&collapse_key) {
                     self.queue_sidebar_reveal(&format!("group:{collapse_key}"));
@@ -4452,7 +4536,7 @@ impl Shell {
             .device_name(&chat.device_id)
             .unwrap_or("Unknown device")
             .to_string();
-        let mut folder = project.clone();
+        let mut folder = project;
         // Unknown device → no fragment, same as the archived list.
         if state.device_name(&chat.device_id).is_some() {
             folder = format!("{folder} @ {device}");
@@ -4468,13 +4552,11 @@ impl Shell {
             .change_request_for_chat(&chat)
             .cloned()
             .filter(|_| self.settings.sidebar_show_pull_request);
-        let group = self.sidebar_group_key(&chat).map(|key| {
-            let label = match self.settings.sidebar_organization {
-                SidebarOrganization::ByDevice => device,
-                _ => project,
-            };
-            (key, label)
-        });
+        let group = match self.settings.sidebar_organization {
+            SidebarOrganization::ByDevice => Some((chat.device_id.clone(), device)),
+            SidebarOrganization::ByProject => Some(sidebar_project_group(state, &chat)),
+            SidebarOrganization::InOneList => None,
+        };
         ActiveChatRow {
             status,
             chat: chat.clone(),
@@ -4720,6 +4802,16 @@ impl Shell {
                     .as_ref()
                     .map_or_else(|| "regular".to_owned(), |(key, _)| format!("regular:{key}"))
             };
+            // A project group wears the project icon on its header instead
+            // of repeating it on every row.
+            let project_group = self.settings.sidebar_organization
+                == SidebarOrganization::ByProject
+                && group
+                    .as_ref()
+                    .is_some_and(|(key, _)| !key.starts_with("section:"));
+            let header_icon_chat = (project_group && self.settings.sidebar_show_project_icon)
+                .then(|| rows.first().map(|row| row.chat.id.clone()))
+                .flatten();
             let mut rendered_rows = Vec::with_capacity(rows.len());
             for (group_index, row) in rows.into_iter().enumerate() {
                 let ActiveChatRow {
@@ -4804,6 +4896,7 @@ impl Shell {
                     is_moving,
                     if is_moving { None } else { drag },
                     jump_label,
+                    self.settings.sidebar_show_project_icon && !project_group,
                     None,
                     theme,
                     cx,
@@ -4939,14 +5032,27 @@ impl Shell {
             let chevron = self.sidebar_disclosure_chevron(&motion_key, !collapsed, theme);
             let toggle_key = collapse_key.clone();
             let toggle_motion_key = motion_key.clone();
+            let group_icon = header_icon_chat.map(|chat_id| {
+                self.render_project_group_icon(&chat_id, SIDEBAR_ACTIVE_HARNESS_ICON_SIZE, cx)
+            });
             // A real project's group gets a hover-revealed `+` that opens a new
-            // chat homed on it.
+            // chat homed on it — on this device's checkout when it has one
+            // (the project picker's local-first order), never silently on a
+            // possibly offline machine just because it cloned first. The
+            // device chip still switches among the repository's checkouts.
             let group_name = SharedString::from(format!("sidebar-group-hover-{collapse_key}"));
-            let new_chat_button = (self.settings.sidebar_organization
-                == SidebarOrganization::ByProject
-                && self.state.read(cx).space_row(&key).is_some())
-            .then(|| {
-                let project = key.clone();
+            let group_space = (self.settings.sidebar_organization
+                == SidebarOrganization::ByProject)
+                .then(|| {
+                    let state = self.state.read(cx);
+                    state
+                        .spaces
+                        .iter()
+                        .find(|space| zeron_proto::view::project_key(space) == key)
+                        .and_then(|space| state.project_members(space).first().map(|m| m.id.clone()))
+                })
+                .flatten();
+            let new_chat_button = group_space.map(|project| {
                 div()
                     .id(SharedString::from(format!(
                         "sidebar-group-new-chat-{collapse_key}"
@@ -4977,8 +5083,9 @@ impl Shell {
                     )
                     .into_any_element()
             });
-            let header = sidebar_disclosure_header(theme, visible_label, new_chat_button, chevron)
-                .group(group_name)
+            let header =
+                sidebar_disclosure_header(theme, group_icon, visible_label, new_chat_button, chevron)
+                    .group(group_name)
                 .id(SharedString::from(format!("sidebar-group-{collapse_key}")))
                 .on_click(cx.listener(move |this, _, _, cx| {
                     let was_open = !this.sidebar_collapsed_groups.contains(&toggle_key);
@@ -5038,7 +5145,7 @@ impl Shell {
             format!("Pinned ({})", items.len()).into()
         };
         let chevron = self.sidebar_disclosure_chevron("pinned", open, theme);
-        let header = sidebar_disclosure_header(theme, label, None, chevron)
+        let header = sidebar_disclosure_header(theme, None, label, None, chevron)
             .id("pinned-toggle")
             .debug_selector(|| "pinned-toggle".into())
             .on_drag_move::<SidebarSessionDrag>(cx.listener(
@@ -5119,7 +5226,7 @@ impl Shell {
             format!("Sessions ({count})").into()
         };
         let chevron = self.sidebar_disclosure_chevron("sessions", open, theme);
-        let header = sidebar_disclosure_header(theme, label, None, chevron)
+        let header = sidebar_disclosure_header(theme, None, label, None, chevron)
             .id("sessions-toggle")
             .debug_selector(|| "sessions-toggle".into())
             .on_drag_move::<SidebarSessionDrag>(cx.listener(
@@ -5258,7 +5365,7 @@ impl Shell {
             format!("Archived ({total})").into()
         };
         let chevron = self.sidebar_disclosure_chevron("archived", open, theme);
-        let header = sidebar_disclosure_header(theme, label, None, chevron)
+        let header = sidebar_disclosure_header(theme, None, label, None, chevron)
             .id("archived-toggle")
             .on_click(cx.listener(move |this, _, _, cx| {
                 let was_open = this.archived_open;
@@ -5306,6 +5413,7 @@ impl Shell {
                         false,
                         None,
                         None,
+                        self.settings.sidebar_show_project_icon,
                         None,
                         theme,
                         cx,
@@ -5859,6 +5967,7 @@ impl Shell {
             git_detected,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: Utc::now(),
         };
         self.state.update(cx, |s, cx| {
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index e85664b31b..47ad1874b1 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -503,11 +503,20 @@ impl Shell {
                                     button.bg(crate::theme::wash(0.09))
                                 }),
                             )
-                            .child(header_icon_button(
+                            .child(header_icon_button_with(
                                 "toggle-changes",
-                                icons::SIDEBAR_MINIMALISTIC,
+                                icons::sidebar_glyph(
+                                    motion::state_t(
+                                        "toggle-changes",
+                                        right_pane_open,
+                                        motion::GLYPH_STATE,
+                                        self.reduced_motion,
+                                    ),
+                                    true,
+                                    16.0,
+                                    theme.text_muted,
+                                ),
                                 ShortcutId::ToggleChanges.label(),
-                                &theme,
                                 cx.listener(|this, _, _, cx| this.toggle_right_pane(cx)),
                             )),
                     )
@@ -542,7 +551,7 @@ impl Shell {
                 .child(
                     header_icon_button(
                         "session-fork",
-                        icons::GIT_BRANCH,
+                        icons::FORK,
                         "Fork this session",
                         &theme,
                         cx.listener(|this, _, _, cx| this.create_side_chat(cx)),
diff --git a/crates/ui/src/state.rs b/crates/ui/src/state.rs
index cd485d7336..db5709b560 100644
--- a/crates/ui/src/state.rs
+++ b/crates/ui/src/state.rs
@@ -1854,17 +1854,22 @@ impl AppState {
     }
 
     /// Pick the composer's target device. Keeps the project pick consistent:
-    /// a project on another device can't survive the switch — fall back to
-    /// the first project on the new device, else "no project".
+    /// it moves to the project's checkout on the new device, else the first
+    /// project there, else "no project".
     pub fn select_device(&mut self, device_id: String, cx: &mut Context<Self>) {
-        let project_moves = self
+        let moving = self
             .selected_space_row()
-            .is_some_and(|s| s.device_id != device_id);
-        if project_moves {
+            .filter(|s| s.device_id != device_id);
+        if let Some(space) = moving {
             let first = self
-                .spaces_sorted()
-                .iter()
+                .project_members(space)
+                .into_iter()
                 .find(|s| s.device_id == device_id)
+                .or_else(|| {
+                    self.spaces_sorted()
+                        .into_iter()
+                        .find(|s| s.device_id == device_id)
+                })
                 .map(|s| s.id.clone());
             self.no_project = first.is_none();
             self.selected_space = first;
@@ -1890,6 +1895,35 @@ impl AppState {
         self.space_row(chat.space_id.as_deref()?)
     }
 
+    /// The space whose name and color stand for `space`'s whole project
+    /// ([`zeron_proto::view::representative_space`]).
+    pub fn representative_space<'a>(&'a self, space: &'a Space) -> &'a Space {
+        zeron_proto::view::representative_space(&self.spaces, space)
+    }
+
+    /// Every space of `space`'s project ([`zeron_proto::view::project_key`]):
+    /// this device's first, then by device name and path.
+    pub fn project_members(&self, space: &Space) -> Vec<&Space> {
+        let key = zeron_proto::view::project_key(space);
+        let local = self.local_device_id.as_deref();
+        let mut members: Vec<&Space> = self
+            .spaces
+            .iter()
+            .filter(|s| zeron_proto::view::project_key(s) == key)
+            .collect();
+        members.sort_by_key(|s| {
+            (
+                local != Some(s.device_id.as_str()),
+                self.device_name(&s.device_id)
+                    .unwrap_or_default()
+                    .to_lowercase(),
+                s.path.clone(),
+                s.id.clone(),
+            )
+        });
+        members
+    }
+
     /// Non-archived chats of a space in tab (creation) order. Chats with a
     /// dangling/missing `space_id` are invisible by construction.
     pub fn chats_in_space(&self, space_id: &str) -> Vec<&Chat> {
@@ -3713,6 +3747,7 @@ mod tests {
             git_detected: false,
             git_checked_at: None,
             checkout_id: None,
+            repository_id: None,
             created_at: base + TimeDelta::minutes(created_min),
         }
     }
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index 56072f2ce6..619c6b249b 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -6430,7 +6430,10 @@ impl Transcript {
 
     fn render_working_trailer(&mut self, cx: &mut Context<Self>) -> Option<AnyElement> {
         let now = chrono::Utc::now();
-        let (sending, queued, elapsed_secs, seed) = if let Some(doc_id) = &self.doc_override {
+        // `turn` (the turn's start, ms) keys the rolling word and timer, so a
+        // new turn's labels appear fresh instead of rolling from the last
+        // turn's final values.
+        let (sending, queued, elapsed_secs, seed, turn) = if let Some(doc_id) = &self.doc_override {
             // A subagent doc has no Session row — `indicator_for` would read
             // the PARENT chat's live state into this tab. Liveness rides the
             // doc itself instead: the sink's assistant entry streams until
@@ -6448,7 +6451,7 @@ impl Transcript {
                 return None;
             }
             let elapsed = ((now.timestamp_millis() - last.created_at).max(0) / 1000) as i64;
-            (false, false, elapsed, flavour_seed(doc_id))
+            (false, false, elapsed, flavour_seed(doc_id), last.created_at)
         } else {
             let chat_id = self.chat_id.clone()?;
             // Failed-send state first: past the grace window the trailer IS
@@ -6471,7 +6474,7 @@ impl Transcript {
                         .into_any_element(),
                 );
             }
-            let (sending, queued, elapsed) = {
+            let (sending, queued, elapsed, turn) = {
                 let state = self.state.read(cx);
                 if state.indicator_for(&chat_id, now) != crate::state::Indicator::Working {
                     return None;
@@ -6483,8 +6486,8 @@ impl Transcript {
                 // with no timer instead; the word + timer start with the
                 // turn.
                 let turn_started = state.session_for(&chat_id).and_then(|s| s.started_at);
-                let sending =
-                    sending_bridge(state.pending_send_started(&chat_id, now), turn_started);
+                let send_started = state.pending_send_started(&chat_id, now);
+                let sending = sending_bridge(send_started, turn_started);
                 // Degraded delivery path: the send is a durable local write
                 // waiting on connectivity — say so instead of faking
                 // progress. (The overlay holds while degraded, so this line
@@ -6493,9 +6496,14 @@ impl Transcript {
                 let elapsed = turn_started
                     .map(|t| now.signed_duration_since(t).num_seconds().max(0))
                     .unwrap_or(0);
-                (sending, queued, elapsed)
+                // While sending, the session row still carries the PREVIOUS
+                // turn: the bridge keys on its own send instead, so it never
+                // rolls out of that turn's word or an earlier send's.
+                let turn = if sending { send_started } else { turn_started }
+                    .map_or(0, |t| t.timestamp_millis());
+                (sending, queued, elapsed, turn)
             };
-            (sending, queued, elapsed, flavour_seed(&chat_id))
+            (sending, queued, elapsed, flavour_seed(&chat_id), turn)
         };
         if self.compact_mode && !sending && !queued && elapsed_secs > 0 {
             let entry_id = if let Some(doc_id) = &self.doc_override {
@@ -6541,6 +6549,7 @@ impl Transcript {
                     cx,
                 ))
                 .child(
+                    // The flavour word rotates every 7s; roll it as it turns.
                     div()
                         .text_size(crate::typography::ui_rems(12.0))
                         .text_color(if queued {
@@ -6548,19 +6557,29 @@ impl Transcript {
                         } else {
                             theme.text_muted
                         })
-                        .child(SharedString::from(if queued {
-                            word.to_string()
-                        } else {
-                            format!("{word}…")
-                        })),
+                        .child(crate::roll_text::roll_text(
+                            format!("working-word-{}-{turn}", cx.entity_id()),
+                            SharedString::from(if queued {
+                                word.to_string()
+                            } else {
+                                format!("{word}…")
+                            }),
+                            cx.reduce_motion(),
+                        )),
                 )
                 .when(!sending, |el| {
+                    // The timer ticks every second; its digits roll in place
+                    // (the unit suffix holds).
                     el.child(
                         div()
                             .relative()
                             .top(px(1.0))
                             .text_color(theme.text_faint)
-                            .child(SharedString::from(format_elapsed(elapsed_secs))),
+                            .child(crate::roll_text::roll_text(
+                                format!("working-timer-{}-{turn}", cx.entity_id()),
+                                SharedString::from(format_elapsed(elapsed_secs)),
+                                cx.reduce_motion(),
+                            )),
                     )
                 })
                 .into_any_element(),

From 9b3773082a8171cd29387b07f2a2b92a48c6ad0b Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Mon, 5 Oct 2026 07:45:09 +0000
Subject: [PATCH 47/74] Bump version to v0.2.103

---
 Cargo.lock | 36 ++++++++++++++++++------------------
 Cargo.toml |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 47644e8e73..b45634a9cf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12797,7 +12797,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "clap",
@@ -12819,7 +12819,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "async-trait",
  "chrono",
@@ -12843,7 +12843,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "chrono",
  "loro",
@@ -12857,7 +12857,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12898,7 +12898,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12925,14 +12925,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12950,7 +12950,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "serde",
  "serde_json",
@@ -12967,7 +12967,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12995,7 +12995,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -13006,7 +13006,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13025,7 +13025,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -13048,7 +13048,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -13082,7 +13082,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -13099,7 +13099,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "clap",
@@ -13114,7 +13114,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -13182,7 +13182,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "futures",
@@ -13198,7 +13198,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice"
-version = "0.2.102"
+version = "0.2.103"
 dependencies = [
  "anyhow",
  "cpal",
diff --git a/Cargo.toml b/Cargo.toml
index adfb758350..5b2f4f37b5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.102"
+version = "0.2.103"
 edition = "2024"
 license = "MIT"
 publish = false

From 73bd3c8429b48e73edc62a9b201fe13f1b50b6c9 Mon Sep 17 00:00:00 2001
From: notsapinho <52896767+notsapinho@users.noreply.github.com>
Date: Mon, 5 Oct 2026 15:33:45 -0300
Subject: [PATCH 48/74] Composer: mention images and files as chips (#775)

* Mention images and files in the composer as chips

Pasting, dropping or attaching a file now stages it and drops a chip at the
caret, so a prompt can say which attachment it means. Images read "Image N";
any other regular file (up to the existing 24 MB limit) is staged as opaque
bytes and its chip carries the file name and the file theme's icon.

Chips and attachments stay in step: removing the last chip for an attachment
unstages it (undo brings both back), removing a tile removes its chips, and
the `@` list pins staged attachments above project files. Chips share one pill
style across files, folders, skills, commands and attachments, in the composer,
the transcript and queue rows. The chip text is the plain label when a prompt
reaches a provider, which pairs with the upload of the same name; uploads and
the prompt trailer are unchanged.

Non-image attachments also render as file pills in sent messages and as icon
tiles in queue rows, and a queued message with files can be restored for
editing: uploads read back whatever their type, while workspace files stay
image-only.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Derive chip prefix and directory flag from the chip kind

FileMentionLink stored its kind alongside a prefix character and an is_dir
flag that the kind already determines; they are now methods on the link, and
the sent-message span drops its is_dir field. Attachment chips are converted
to plain labels in harness_prompt instead of inside file_mention_prompt, which
no longer knows about attachments, and the icon cache locks without a
poisoned-mutex branch.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Drop tiles for chipped attachments and center chip labels

A chip is the attachment's handle (hover previews it, deleting it unstages
it), so the composer and queue rows no longer repeat chipped attachments as
tiles; attachments without a chip keep theirs. Sent messages keep their
strip, which carries upload progress and opens the image.

Chip pills sat a pixel below the line box's middle, which left labels
looking high. Geist's cap height is centered on the line box, so the pill
now is too.

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

* Show sent attachments as chips only, with image chips opening the image

A sent message's chips stand in for their attachments, so the strip above
the bubble keeps only attachments without a chip (appshots, mobile sends).
An image chip carries its upload's path: clicking it opens the image full
size, as the thumbnail did, and its upload is loaded and kept with the row.

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

* Keep chips and attachments in step while editing a queued message

Chip deletion was never reconciled during a queued edit, so a file whose
chip was deleted still uploaded on save. Reconciliation was off because
restored files had no chip numbers and the edit shared the displaced
draft's numbering and undo stash.

Restored attachments now take the numbers of the chips that name them,
the edit gets its own numbering and stash (the draft's come back when it
ends), reconciliation runs during the edit, and a saved edit demotes chips
whose attachment is gone. When the edited row disappears and both drafts
merge, the edit's chips become their labels so numbers cannot collide.

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

* Show upload progress on sent chips

Chipped attachments left the strip above a sent message, and with it the
thumbnail's upload ring. A chip now carries the upload it names: while
the bytes are still crossing to the host its icon well shows the transfer
percent as a ring (or a spinner when no real position is known), and an
image that can't be read back shows a warning there. File chips get the
same progress; image chips still open the image once loaded.

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

* Show desktop file attachments as name pills on mobile

Desktop can now send any file, and those refs reach mobile through the
synced transcript. The mobile user row handed every attachment to an
image widget, so a ZIP became a broken thumbnail and a failed image load.
Non-image refs now render as a file-icon + name pill (upload prefix
stripped, pending refs included) using the existing Icon widget, so iOS
needs no changes. Composer chip links show as their plain label instead
of raw Markdown, and the "See the attached file(s)." placeholder is
hidden like the image one.

attachment_display_name moves to zeron-proto (desktop re-exports it),
next to a shared is_image_path using the desktop's decodable extensions,
so mobile splits images from files the same way.

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

* Cover external file drops end to end and run attachment tests on macOS

The file-chip tests called add_paths directly, so nothing exercised the
ExternalPaths receiver a real Finder or file-manager drop goes through.
The new test dispatches FileDropEvent enter/hover/drop with a zip, a PNG,
a folder and an oversize file into the main chat and both side chats,
and checks chips, staged files and the error notice in each.

A mixed drop showed only the last refusal, so a folder's error was hidden
behind an oversize file's. Refusals from one drop now share the notice.

The macOS job's nextest filter now includes the attachment staging, chip,
drop and queue/transcript chip regressions.

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

* Open image chips full size on click instead of on hover

The composer's tiles opened an image full size on click; with them gone,
image chips previewed on hover instead. A click on an image chip now opens
the same full-size viewer, with the pointing hand over it, and its hover
card is gone. A drag across the chip still only selects text; file chips
keep their name tooltip.

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

* Show the desktop's chips in iOS message bubbles

Synced prompts on iOS showed file mentions as accent "@name" text and
attachment chips as plain labels, beside a thumbnail strip that repeated
them. Bubbles now draw every chip kind (files, folders, skills, commands,
images, file attachments) as the desktop's soft pill with an icon well,
using the tool badge's colors and the bundled file-theme icons.

As on the desktop, attachments a chip names leave the strip above the
bubble, and tapping an image chip opens its upload in the image viewer.
The chip-to-upload match moves into zeron-proto so both clients share it,
and the demo's veil chat now opens on a prompt with chips.

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

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Wing <contact@winglee.io>
---
 .github/workflows/macos.yml                   |    5 +-
 .../ios/Zeron/Session/CoreSessionSource.swift |    9 +
 apps/ios/Zeron/Session/SessionSource.swift    |    3 +
 .../Zeron/Session/SessionViewController.swift |    1 +
 .../Zeron/Transcript/TranscriptListView.swift |   13 +
 crates/client/src/attachments.rs              |    8 +-
 crates/client/src/demo/transcripts.rs         |   24 +-
 crates/engine/src/uploads.rs                  |   53 +-
 .../tests/m5c_accounts_uploads_titles.rs      |   16 +-
 crates/engine/tests/queued_attachments.rs     |   88 ++
 crates/mobile/src/layout/markdown.rs          |   21 +
 crates/mobile/src/layout/rows.rs              |  185 ++-
 crates/mobile/src/layout/tests.rs             |   55 +-
 crates/mobile/src/layout/tools.rs             |    1 +
 crates/proto/src/attachment_mentions.rs       |  314 +++++
 crates/proto/src/file_mentions.rs             |    2 +-
 crates/proto/src/invocation.rs                |   22 +-
 crates/proto/src/lib.rs                       |    1 +
 crates/ui/assets/icons/gallery.svg            |    1 +
 crates/ui/src/appshots.rs                     |   10 +-
 crates/ui/src/attachments.rs                  |  429 ++++++-
 crates/ui/src/composer.rs                     | 1069 +++++++++++++----
 .../ui/src/composer/attachment_chip_tests.rs  |  792 ++++++++++++
 crates/ui/src/composer/chip.rs                |  153 +++
 crates/ui/src/file_icons.rs                   |   23 +-
 crates/ui/src/files/mod.rs                    |    1 +
 crates/ui/src/icons.rs                        |    2 +
 crates/ui/src/loaders.rs                      |   69 +-
 crates/ui/src/pickers.rs                      |    1 +
 crates/ui/src/queue.rs                        |  247 +++-
 crates/ui/src/shell.rs                        |    7 +-
 crates/ui/src/shell/chat_dropzone_tests.rs    |  121 ++
 crates/ui/src/transcript.rs                   |  617 +++++++++-
 33 files changed, 3902 insertions(+), 461 deletions(-)
 create mode 100644 crates/proto/src/attachment_mentions.rs
 create mode 100644 crates/ui/assets/icons/gallery.svg
 create mode 100644 crates/ui/src/composer/attachment_chip_tests.rs
 create mode 100644 crates/ui/src/composer/chip.rs

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 01711a1f4a..205201f688 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -117,11 +117,12 @@ jobs:
       - name: Updater, preview, CoreText and native UI regressions
         run: |
           # zeron-text's coretext tests are macOS-only (#![cfg(target_os = "macos")]); its other
-          # tests run on Linux in ios-core.
+          # tests run on Linux in ios-core. The attachment filters cover file staging, chips and
+          # external Finder drops, whose paths and file metadata are platform-specific.
           cargo nextest run --no-fail-fast --locked \
             -p zeron-update -p zeron-preview -p zeron-ui -p zeron-text \
             --features zeron-ui/browser-fixture --lib --tests \
-            -E 'package(zeron-update) | package(zeron-preview) | binary_id(zeron-text::coretext) | (binary_id(zeron-ui) & (test(native_diff_font_geometry) | test(/notify::tests::/)))'
+            -E 'package(zeron-update) | package(zeron-preview) | binary_id(zeron-text::coretext) | (binary_id(zeron-ui) & (test(native_diff_font_geometry) | test(/notify::tests::/) | test(/^attachments::tests::/) | test(/composer::attachment_chip_tests::/) | test(/shell::chat_dropzone_tests::/) | test(=queue::tests::queue_rows_label_attachment_chips_and_file_only_sends) | test(=transcript::tests::user_bubbles_project_attachment_chips_in_place_of_the_strip) | test(=transcript::tests::sent_chips_show_upload_progress_until_their_bytes_land)))'
       - name: Native browser regression and screenshots
         timeout-minutes: 7
         env:
diff --git a/apps/ios/Zeron/Session/CoreSessionSource.swift b/apps/ios/Zeron/Session/CoreSessionSource.swift
index 609c10fc79..8d5c490702 100644
--- a/apps/ios/Zeron/Session/CoreSessionSource.swift
+++ b/apps/ios/Zeron/Session/CoreSessionSource.swift
@@ -247,6 +247,15 @@ final class CoreSessionSource: SessionSource {
 
     private static let images = NSCache<NSString, UIImage>()
 
+    func image(_ reference: String) async -> UIImage? {
+        if let hit = Self.images.object(forKey: reference as NSString) { return hit }
+        guard let data = try? await client.readAttachment(deviceId: hostDevice, path: reference),
+              let image = await UIImage(data: data)?.byPreparingForDisplay()
+        else { return nil }
+        Self.images.setObject(image, forKey: reference as NSString)
+        return image
+    }
+
     func loadImage(_ reference: String, into view: UIImageView) {
         // Claim the view first: a slower load for a row it used to show
         // must not land on top of this one.
diff --git a/apps/ios/Zeron/Session/SessionSource.swift b/apps/ios/Zeron/Session/SessionSource.swift
index 687ea474b4..d5cfcc9072 100644
--- a/apps/ios/Zeron/Session/SessionSource.swift
+++ b/apps/ios/Zeron/Session/SessionSource.swift
@@ -76,6 +76,8 @@ protocol SessionSource: AnyObject {
     /// Menu for a composer chip (model, effort, branch…), or nil.
     func chipMenu(_ id: String) -> UIMenu?
     func loadImage(_ reference: String, into view: UIImageView)
+    /// An attachment's picture, for opening it full size (an image chip).
+    func image(_ reference: String) async -> UIImage?
     /// Workspace files for `@` mentions.
     func searchFiles(_ query: String) async -> [FileMatch]
 }
@@ -227,5 +229,6 @@ final class FixtureSessionSource: SessionSource {
         }
     }
     func loadImage(_ reference: String, into view: UIImageView) {}
+    func image(_ reference: String) async -> UIImage? { nil }
     func searchFiles(_ query: String) async -> [FileMatch] { [] }
 }
diff --git a/apps/ios/Zeron/Session/SessionViewController.swift b/apps/ios/Zeron/Session/SessionViewController.swift
index 504938fc00..d5587a13d7 100644
--- a/apps/ios/Zeron/Session/SessionViewController.swift
+++ b/apps/ios/Zeron/Session/SessionViewController.swift
@@ -45,6 +45,7 @@ final class SessionViewController: UIViewController, UIGestureRecognizerDelegate
         list.autoresizingMask = [.flexibleWidth, .flexibleHeight]
         list.accessibilityIdentifier = "transcript"
         list.imageLoader = { [weak self] ref, iv in self?.source.loadImage(ref, into: iv) }
+        list.imageFetcher = { [weak self] ref in await self?.source.image(ref) }
         // Hidden while following (the runway glide and tail spring travel).
         list.onDistanceFromBottom = { [weak self] d in
             guard let self else { return }
diff --git a/apps/ios/Zeron/Transcript/TranscriptListView.swift b/apps/ios/Zeron/Transcript/TranscriptListView.swift
index a4aa052855..514b7d8244 100644
--- a/apps/ios/Zeron/Transcript/TranscriptListView.swift
+++ b/apps/ios/Zeron/Transcript/TranscriptListView.swift
@@ -38,6 +38,8 @@ final class TranscriptListView: UIScrollView, RowViewDelegate, UIScrollViewDeleg
     var onFollowChange: ((Bool) -> Void)?
     var onDistanceFromBottom: ((CGFloat) -> Void)?
     var imageLoader: ((String, UIImageView) -> Void)?
+    /// An attachment's picture, for an image chip opened full size.
+    var imageFetcher: ((String) async -> UIImage?)?
 
     // MARK: Runway (desktop transcript.rs `OwnTurnAnchor`)
     //
@@ -571,6 +573,17 @@ final class TranscriptListView: UIScrollView, RowViewDelegate, UIScrollViewDeleg
 
     func rowView(_ view: RowView, open url: URL) {
         guard let vc = findViewController() else { return }
+        // An image chip opens its upload full size, as its thumbnail did.
+        if url.scheme == "zeron-preview" {
+            guard let reference = URLComponents(url: url, resolvingAgainstBaseURL: false)?
+                .queryItems?.first(where: { $0.name == "ref" })?.value
+            else { return }
+            Task { @MainActor [weak self, weak view, weak vc] in
+                guard let image = await self?.imageFetcher?(reference), let view, let vc else { return }
+                vc.present(ImageViewer(image: image, source: view), animated: true)
+            }
+            return
+        }
         if url.scheme == "http" || url.scheme == "https" {
             let safari = SFSafariViewController(url: url)
             safari.preferredControlTintColor = Palette.accent
diff --git a/crates/client/src/attachments.rs b/crates/client/src/attachments.rs
index fb9d404b17..13009b167d 100644
--- a/crates/client/src/attachments.rs
+++ b/crates/client/src/attachments.rs
@@ -20,6 +20,8 @@ use crate::lock;
 
 /// Body used when a message has only attachments.
 pub const ATTACHMENT_ONLY_TEXT: &str = "See the attached image(s).";
+/// Body the desktop uses when any attachment is not an image.
+pub const FILE_ATTACHMENT_ONLY_TEXT: &str = "See the attached file(s).";
 /// The trailer marker line.
 pub const ATTACHMENT_MARKER: &str = "Attached images (local files — open them to view):";
 /// Appshot context marker: everything after it is untrusted observed content.
@@ -204,7 +206,7 @@ pub fn parse_user_message(content: &str) -> ParsedUserMessage {
     let body = lines[..marker - 1].join("\n");
     let visible = visible_text(body.trim()).to_owned();
     ParsedUserMessage {
-        text: if visible == ATTACHMENT_ONLY_TEXT {
+        text: if visible == ATTACHMENT_ONLY_TEXT || visible == FILE_ATTACHMENT_ONLY_TEXT {
             String::new()
         } else {
             visible
@@ -300,6 +302,10 @@ mod tests {
         let only = with_attachments("", &paths[..1]);
         assert_eq!(parse_user_message(&only).text, "");
         assert_eq!(queue_visible_text(&only, &paths[..1]), ATTACHMENT_ONLY_TEXT);
+        let files = format!(
+            "{FILE_ATTACHMENT_ONLY_TEXT}\n\n{ATTACHMENT_MARKER}\n- /tmp/ab12cd34-notes.zip"
+        );
+        assert_eq!(parse_user_message(&files).text, "");
     }
 
     #[test]
diff --git a/crates/client/src/demo/transcripts.rs b/crates/client/src/demo/transcripts.rs
index 758c84aace..e99691811d 100644
--- a/crates/client/src/demo/transcripts.rs
+++ b/crates/client/src/demo/transcripts.rs
@@ -101,7 +101,12 @@ fn assistant(id: &str, host: &str, at: i64, parts: Vec<MessagePart>) -> SessionM
 
 /// Paths the demo serves generated images for.
 pub(crate) const DEMO_IMAGES: &[(&str, u32, u32, u32)] = &[
-    ("/Users/dev/.zeron/uploads/veil-before.png", 960, 540, 1),
+    (
+        "/Users/dev/.zeron/uploads/4f1c9a2e-Image_1.png",
+        960,
+        540,
+        1,
+    ),
     ("/Users/dev/.zeron/uploads/scroll-tall.png", 400, 800, 2),
     ("/Users/dev/.zeron/uploads/square.png", 600, 600, 3),
 ];
@@ -201,9 +206,22 @@ gh pr create --base main --title "Stream pull request status on every client"
 PR **#90** is open: https://github.com/zeron-sh/zeron/pull/90"#;
 
 fn veil(host: &str, now: i64) -> Vec<SessionMessageEntry> {
+    // Sent from the desktop composer: file, folder and skill chips, plus the
+    // image and recording it attached, each mentioned by its chip.
+    let review = zeron_proto::invocation::Invocation::Skill {
+        name: "review".into(),
+        path: "/Users/dev/.claude/skills/review/SKILL.md".into(),
+        command: None,
+    };
     let attach = crate::attachments::with_attachments(
-        "Port the streaming fade-in veil from the desktop transcript. It must never affect layout — opacity only, split at chunk boundaries. Here's how it looks today:",
-        &[DEMO_IMAGES[0].0.to_owned()],
+        &format!(
+            "Port the streaming fade-in veil from [transcript.rs](zeron-file:crates/ui/src/transcript.rs) into [Transcript](zeron-file:apps/ios/Zeron/Transcript/). It must never affect layout — opacity only, split at chunk boundaries. Here's how it looks today: [Image 1](zeron-image:1), and the fade is in [veil-recording.zip](zeron-attachment:2). Run {} when done.",
+            review.link()
+        ),
+        &[
+            DEMO_IMAGES[0].0.to_owned(),
+            "/Users/dev/.zeron/uploads/7d03b6e1-veil-recording.zip".to_owned(),
+        ],
     );
     let mut live = assistant(
         "m6",
diff --git a/crates/engine/src/uploads.rs b/crates/engine/src/uploads.rs
index 9f10ff5f0b..2557681375 100644
--- a/crates/engine/src/uploads.rs
+++ b/crates/engine/src/uploads.rs
@@ -10,10 +10,11 @@
 //! Attachments live only on the host device — every read proxies through the
 //! owning device via `ReadAttachmentChunk`; nothing is mirrored to the edge.
 //!
-//! `read_chunk` serves transcript images back in 45KB base64 chunks. Path jail:
+//! `read_chunk` serves attachments back in 45KB base64 chunks. Path jail:
 //! only files under the uploads dir or a workspace-known chat cwd are readable
-//! (the RPC layer supplies the cwd roots) — and only supported image types, as
-//! in zeron.
+//! (the RPC layer supplies the cwd roots). Workspace files must be supported
+//! image types, as in zeron; files in the uploads dir read back whatever their
+//! type, so a queued message can restore them for editing.
 
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
@@ -354,8 +355,21 @@ impl Uploads {
         if meta.len() > MAX_BYTES {
             return Err(EngineError::Other("Attachment is too large".into()));
         }
-        let mime_type = mime_by_ext(&resolved)
-            .ok_or_else(|| EngineError::Other("Attachment is not a supported image".into()))?;
+        // Files the user attached themselves read back whatever their type (a
+        // queued message restores them for editing); other roots stay image-only.
+        let mime_type = match mime_by_ext(&resolved) {
+            Some(mime) => mime,
+            None if std::fs::canonicalize(&self.inner.dir)
+                .is_ok_and(|uploads| resolved.starts_with(uploads)) =>
+            {
+                "application/octet-stream"
+            }
+            None => {
+                return Err(EngineError::Other(
+                    "Attachment is not a supported image".into(),
+                ));
+            }
+        };
         Ok(InspectedFile {
             name: resolved
                 .file_name()
@@ -544,6 +558,35 @@ mod tests {
         assert!(pending_refs_in("mentions pending://u1/x.png inline only").is_empty());
     }
 
+    #[test]
+    fn uploaded_files_of_any_type_read_back_but_other_roots_stay_image_only() {
+        let dir = tempfile::tempdir().unwrap();
+        let workspace = tempfile::tempdir().unwrap();
+        let uploads = Uploads::from_root(dir.path());
+        for (id, name, bytes) in [
+            ("u1", "notes.md", &b"# notes"[..]),
+            ("u2", "empty.bin", b""),
+        ] {
+            uploads.append(id, &BASE64.encode(bytes), Some(0)).unwrap();
+            let path = uploads.commit(id, name).unwrap();
+            let chunk = uploads.read_chunk(&path, 0, &[]).unwrap();
+            assert_eq!(chunk.mime_type, "application/octet-stream");
+            assert!(chunk.done);
+        }
+        // A non-image in a workspace root is still refused.
+        let notes = workspace.path().join("notes.md");
+        std::fs::write(&notes, "# not an upload").unwrap();
+        assert!(
+            uploads
+                .read_chunk(
+                    notes.to_str().unwrap(),
+                    0,
+                    &[workspace.path().to_path_buf()]
+                )
+                .is_err()
+        );
+    }
+
     #[test]
     fn pending_ref_traversal_cannot_escape_the_jail() {
         let dir = tempfile::tempdir().unwrap();
diff --git a/crates/engine/tests/m5c_accounts_uploads_titles.rs b/crates/engine/tests/m5c_accounts_uploads_titles.rs
index 00ab909836..5ddf42e489 100644
--- a/crates/engine/tests/m5c_accounts_uploads_titles.rs
+++ b/crates/engine/tests/m5c_accounts_uploads_titles.rs
@@ -885,11 +885,23 @@ async fn uploads_chunk_commit_readback_and_jail() {
         .read_chunk(&outside.to_string_lossy(), 0, &[tmp.path().to_path_buf()])
         .expect("cwd-rooted read");
     assert_eq!(BASE64.decode(&ok.data).expect("data"), b"nope");
-    // Non-image extensions are refused even inside the jail (zeron parity).
+    // Files the user uploaded read back whatever their type (a queued message
+    // restores them for editing)…
     let text = PathBuf::from(uploads.dir()).join("notes.txt");
     std::fs::create_dir_all(uploads.dir()).expect("uploads dir");
     std::fs::write(&text, b"text").expect("txt");
-    assert!(uploads.read_chunk(&text.to_string_lossy(), 0, &[]).is_err());
+    let chunk = uploads
+        .read_chunk(&text.to_string_lossy(), 0, &[])
+        .expect("an uploaded file reads back");
+    assert_eq!(chunk.mime_type, "application/octet-stream");
+    // …but a non-image in a workspace root is still refused (zeron parity).
+    let in_root = tmp.path().join("notes.txt");
+    std::fs::write(&in_root, b"text").expect("txt");
+    assert!(
+        uploads
+            .read_chunk(&in_root.to_string_lossy(), 0, &[tmp.path().to_path_buf()])
+            .is_err()
+    );
 
     // Bogus upload ids never become paths.
     assert!(uploads.append("../evil", "aGk=", None).is_err());
diff --git a/crates/engine/tests/queued_attachments.rs b/crates/engine/tests/queued_attachments.rs
index 2d67cedc51..bb75950443 100644
--- a/crates/engine/tests/queued_attachments.rs
+++ b/crates/engine/tests/queued_attachments.rs
@@ -239,6 +239,94 @@ async fn run_defers_until_attachment_bytes_land_then_executes_rewritten() {
     core.shutdown().await;
 }
 
+/// A file that is not an image rides the same deferred-run transport: it waits
+/// for its bytes, runs with the committed path, and reads back as opaque bytes
+/// so a queued message can be restored for editing.
+#[tokio::test(flavor = "multi_thread")]
+async fn run_with_a_non_image_file_defers_executes_and_reads_back() {
+    let tmp = tempfile::tempdir().unwrap();
+    let registry = HarnessRegistry::new();
+    registry.register(Arc::new(AckHarness));
+    let core = EngineCore::assemble(
+        &tmp.path().join("data"),
+        Arc::new(registry),
+        HarnessId::Mock,
+        None,
+    )
+    .expect("engine core assembles");
+    let client = zeron_rpc::memory_client(core.rpc_service());
+    client
+        .call(
+            zeron_rpc::methods::MUTATE,
+            serde_json::json!({ "op": "createChat", "chatId": CHAT, "deviceId": core.device_id }),
+        )
+        .await
+        .expect("createChat");
+    core.workspace
+        .rename_chat(CHAT, "Pre-titled")
+        .expect("rename chat");
+
+    core.doc_host
+        .queue_command(CHAT, run_payload("msg-file-1", "pending://att-2/notes.md"))
+        .expect("queue run command");
+    tokio::time::sleep(Duration::from_millis(400)).await;
+    assert_eq!(
+        complete_assistant_count(&core),
+        0,
+        "run must defer while the file is in transit"
+    );
+
+    client
+        .call(
+            zeron_rpc::methods::UPLOAD_CHUNK,
+            serde_json::json!({ "uploadId": "att-2", "seq": 0, "data": BASE64.encode(b"# notes") }),
+        )
+        .await
+        .expect("upload chunk");
+    client
+        .call(
+            zeron_rpc::methods::UPLOAD_COMMIT,
+            serde_json::json!({ "uploadId": "att-2", "fileName": "notes.md" }),
+        )
+        .await
+        .expect("upload commit");
+    wait_for(
+        || complete_assistant_count(&core) == 1,
+        "deferred run to execute",
+    )
+    .await;
+
+    let user_text = entries(&core)
+        .iter()
+        .find(|e| e.role == MessageRole::User)
+        .and_then(|e| {
+            e.parts.iter().find_map(|p| match p {
+                zeron_doc::MessagePart::Text { text, .. } => Some(text.clone()),
+                _ => None,
+            })
+        })
+        .expect("user entry persisted");
+    assert!(!user_text.contains("pending://"), "{user_text}");
+    let committed = user_text
+        .lines()
+        .find(|line| line.ends_with("att-2-notes.md"))
+        .and_then(|line| line.strip_prefix("- "))
+        .unwrap_or_else(|| panic!("committed path missing: {user_text}"));
+
+    // Restoring the queued message for editing reads the file back.
+    let chunk = client
+        .call(
+            zeron_rpc::methods::READ_ATTACHMENT_CHUNK,
+            serde_json::json!({ "path": committed, "offset": 0 }),
+        )
+        .await
+        .expect("read back the uploaded file");
+    assert_eq!(chunk["mimeType"], "application/octet-stream");
+    assert_eq!(chunk["data"], BASE64.encode(b"# notes"));
+
+    core.shutdown().await;
+}
+
 /// Mobile sends made while a turn runs park on the shared queue with
 /// `pending://` refs (the bytes chase them over the peer link). The queue
 /// drain must wait for those bytes and hand the harness the committed local
diff --git a/crates/mobile/src/layout/markdown.rs b/crates/mobile/src/layout/markdown.rs
index f5e59e9b48..641408ccfb 100644
--- a/crates/mobile/src/layout/markdown.rs
+++ b/crates/mobile/src/layout/markdown.rs
@@ -35,6 +35,9 @@ pub(crate) struct PText {
     pub links: Vec<String>,
     /// Chip rect within a line box: (top offset, height).
     pub chip: (f32, f32),
+    /// Spans painted as mention chips (the desktop's file badge: a soft pill
+    /// with an icon well at its start), with each one's icon.
+    pub badges: Vec<(usize, String)>,
 }
 
 pub(crate) struct PCode {
@@ -168,6 +171,7 @@ pub(crate) fn prepare_runs(ctx: &mut Ctx, runs: &[InlineRun], kind: TextKind, mu
         paints,
         links,
         chip: ((lh - chip_h) / 2.0, chip_h),
+        badges: Vec::new(),
     }
 }
 
@@ -210,6 +214,7 @@ pub(crate) fn prepare_plain(
         }],
         links: Vec::new(),
         chip: (0.0, 0.0),
+        badges: Vec::new(),
     }
 }
 
@@ -387,6 +392,7 @@ fn prepare_code(ctx: &mut Ctx, language: Option<&str>, code: &str) -> PCode {
             .collect(),
         links: Vec::new(),
         chip: (0.0, 0.0),
+        badges: Vec::new(),
     };
     let label = language.filter(|l| !l.is_empty()).map(|l| {
         let (size, lh) = TYPE.small;
@@ -461,6 +467,21 @@ pub(crate) fn place_text(t: &PText, x: f32, y: f32, width: f32, out: Option<&mut
             if paint.chip {
                 out.fill(x + f.x, top + t.chip.0, f.width, t.chip.1, 5.0, ColorRole::InlineCodeBackground);
             }
+            if let Some((_, icon)) = t.badges.iter().find(|(span, _)| *span == f.span) {
+                let (chip_top, chip_h) = t.chip;
+                out.fill(x + f.x, top + chip_top, f.width, chip_h, 5.0, ColorRole::ToolBadge);
+                if f.range.start == span.range.start {
+                    let well = chip_h - 2.0;
+                    let (wx, wy) = (x + f.x + 1.0, top + chip_top + 1.0);
+                    out.fill(wx, wy, well, well, 4.0, ColorRole::ToolWell);
+                    let size = well - 4.0;
+                    out.widget(
+                        WidgetKind::Icon { name: icon.clone(), color: ColorRole::TextSoft },
+                        (wx + (well - size) / 2.0, wy + (well - size) / 2.0, size, size),
+                        None,
+                    );
+                }
+            }
             if f.utf16.is_empty() {
                 continue;
             }
diff --git a/crates/mobile/src/layout/rows.rs b/crates/mobile/src/layout/rows.rs
index 915535b616..272721dc85 100644
--- a/crates/mobile/src/layout/rows.rs
+++ b/crates/mobile/src/layout/rows.rs
@@ -18,6 +18,7 @@ use zeron_markdown::parser::{IncrementalParser, TopBlock};
 use zeron_text::WhiteSpace;
 
 use super::display::{ColorRole, DisplayBuilder, FadeEdge, TextRun, WidgetKind};
+use super::file_icons::file_icon_asset;
 use super::markdown::{Ctx, PBlock, PText, Px, place, place_text, prepare_block, prepare_plain};
 use super::style::{Family, TYPE, Weight};
 use super::tools::{ThoughtState, ToolGroup, place_tools};
@@ -69,6 +70,8 @@ pub(crate) fn next_version() -> u64 {
 pub(crate) struct UserBubble {
     pub text: PText,
     pub images: Vec<String>,
+    /// Non-image attachments (desktop-sent ZIPs, docs): icon asset + name.
+    pub files: Vec<(String, PText)>,
     pub pending: bool,
     pub expanded: bool,
     pub more: PText,
@@ -134,6 +137,7 @@ pub(crate) mod geom {
     pub const BUBBLE_FOLD_LINES: usize = 8;
     pub const BUBBLE_FOLD_SHOW: usize = 6;
     pub const THUMB: f32 = 76.0;
+    pub const FILE_PILL: f32 = 32.0;
     pub const CHIP_LINE: f32 = 32.0;
     pub const IMAGE: f32 = 260.0;
     pub const WORKING: f32 = 36.0;
@@ -476,14 +480,41 @@ impl RowBuilder {
         let key = row_key(&format!("{id}#u"));
         // Shared parser: strips the image trailer *and* hidden Appshot context.
         let parsed = zeron_client::attachments::parse_user_message(content);
-        let body = parsed.text.as_str();
-        let images: Vec<String> = parsed.images.into_iter().map(|i| i.path).collect();
         let (size, lh) = TYPE.body;
         let style = ctx.typo.style(Family::Sans, Weight::Regular, false, size);
         let lh = ctx.typo.px(lh);
-        let text = prepare_user_text(ctx, body.trim(), style, lh);
+        // Chips stand in for their attachments (as on the desktop): those
+        // leave the strip, and an image chip opens its upload on tap.
+        let mentions = zeron_proto::attachment_mentions::attachment_mentions(&parsed.text);
+        let chipped = |path: &str| mentions.iter().any(|mention| mention.names_attachment(path));
+        let previews: Vec<(u32, String)> = mentions
+            .iter()
+            .filter(|mention| mention.is_image)
+            .filter_map(|mention| {
+                let image = parsed.images.iter().find(|image| mention.names_attachment(&image.path))?;
+                Some((mention.index, image.path.clone()))
+            })
+            .collect();
+        let text = prepare_user_text(ctx, parsed.text.trim(), style, lh, &previews);
+        // Copied text reads attachment chips as their plain label.
+        let body = zeron_proto::attachment_mentions::attachment_mention_prompt(&parsed.text);
         let (msize, mlh) = TYPE.small;
         let mstyle = ctx.typo.style(Family::Sans, Weight::Medium, false, msize);
+        // Only images go to image widgets; other files (desktop-sent ZIPs)
+        // get a name pill, never an image load.
+        let (images, others): (Vec<_>, Vec<_>) = parsed
+            .images
+            .into_iter()
+            .filter(|i| !chipped(&i.path))
+            .partition(|i| zeron_proto::attachment_mentions::is_image_path(&i.path));
+        let images = images.into_iter().map(|i| i.path).collect();
+        let files = others
+            .iter()
+            .map(|f| {
+                let name = zeron_proto::attachment_mentions::attachment_display_name(&f.name);
+                (file_icon_asset(name), prepare_plain(ctx, name, mstyle, ctx.typo.px(mlh), ColorRole::Text, WhiteSpace::Pre))
+            })
+            .collect();
         let expanded = self.expanded.contains(&key);
         let more = prepare_plain(
             ctx,
@@ -501,55 +532,132 @@ impl RowBuilder {
             content: Content::User(UserBubble {
                 text,
                 images,
+                files,
                 pending,
                 expanded,
                 more,
             }),
-            copy_text: body.to_owned(),
+            copy_text: body,
         }
     }
 
 }
 
-/// User prompt text with `[name](zeron-file:path)` mentions shown as atomic
-/// accent `@name` chips (the desktop's file-chip rendering).
-fn prepare_user_text(ctx: &mut Ctx, body: &str, style: super::style::Resolved, lh: f32) -> PText {
-    let links = zeron_proto::file_mentions::file_mention_links(body);
-    if links.is_empty() {
+/// One chip in a sent prompt: its source range, label and icon, and for an
+/// image chip the link that opens its upload.
+struct UserChip {
+    range: std::ops::Range<usize>,
+    label: String,
+    icon: String,
+    open: Option<String>,
+}
+
+/// The link an image chip opens: the host attachment ref, percent-encoded.
+fn image_preview_link(reference: &str) -> String {
+    let mut out = String::from("zeron-preview://image?ref=");
+    for byte in reference.bytes() {
+        if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'.' | b'_' | b'~') {
+            out.push(byte as char);
+        } else {
+            out.push_str(&format!("%{byte:02X}"));
+        }
+    }
+    out
+}
+
+/// The chips a sent prompt's canonical links read as, like the desktop's:
+/// files and folders (`zeron-file:`), skills and commands (`zeron-invoke:`),
+/// and attachments (`zeron-image:` / `zeron-attachment:`), in text order.
+/// `previews` pairs image chip numbers with the uploads they open.
+fn user_chips(body: &str, previews: &[(u32, String)]) -> Vec<UserChip> {
+    let mut chips: Vec<UserChip> = zeron_proto::file_mentions::file_mention_links(body)
+        .into_iter()
+        .map(|link| UserChip {
+            icon: if link.is_dir { "fileicon-folders-folder".to_owned() } else { file_icon_asset(&link.path) },
+            range: link.range,
+            label: link.basename,
+            open: None,
+        })
+        .collect();
+    chips.extend(zeron_proto::invocation::invocation_links(body).into_iter().map(|(range, invocation)| UserChip {
+        range,
+        label: invocation.name().to_owned(),
+        icon: if invocation.prefix() == '/' { "command" } else { "wand.and.stars" }.to_owned(),
+        open: None,
+    }));
+    chips.extend(zeron_proto::attachment_mentions::attachment_mentions(body).into_iter().map(|mention| UserChip {
+        range: mention.range,
+        icon: if mention.is_image { "photo".to_owned() } else { file_icon_asset(&mention.label) },
+        open: previews
+            .iter()
+            .find(|(index, _)| mention.is_image && *index == mention.index)
+            .map(|(_, reference)| image_preview_link(reference)),
+        label: mention.label,
+    }));
+    chips.sort_by_key(|chip| chip.range.start);
+    // Links never nest; drop any overlap rather than paint two chips at once.
+    let mut end = 0;
+    chips.retain(|chip| {
+        let keep = chip.range.start >= end;
+        if keep {
+            end = chip.range.end;
+        }
+        keep
+    });
+    chips
+}
+
+/// User prompt text with its canonical links shown as atomic chips: the
+/// desktop's soft pill with an icon well, the label in the body font.
+fn prepare_user_text(ctx: &mut Ctx, body: &str, style: super::style::Resolved, lh: f32, previews: &[(u32, String)]) -> PText {
+    let chips = user_chips(body, previews);
+    if chips.is_empty() {
         return prepare_plain(ctx, body, style, lh, ColorRole::Text, WhiteSpace::PreWrap);
     }
-    let (size, _) = TYPE.body;
-    let chip = ctx.typo.style(Family::Sans, Weight::Medium, false, size);
+    // The pill sits two points inside the line box, centered like the
+    // desktop's; its icon well is the pill's height less a point each side.
+    let chip_h = lh - ctx.typo.px(4.0);
+    let chip_pad = (1.0 + (chip_h - 2.0) + ctx.typo.px(5.0), ctx.typo.px(6.0));
     let mut text = String::with_capacity(body.len());
     let mut spans = Vec::new();
     let mut paints = Vec::new();
+    let mut badges = Vec::new();
+    let mut links = Vec::new();
     let mut at = 0;
-    let mut push = |text: &mut String, piece: &str, style: zeron_text::StyleId, atomic: bool, color: ColorRole| {
+    // Returns the index of the span pushed for a non-empty piece.
+    let mut push = |text: &mut String, piece: &str, pad: (f32, f32), atomic: bool, link: Option<u16>| {
         if piece.is_empty() {
-            return;
+            return None;
         }
         let start = text.len();
         text.push_str(piece);
         spans.push(zeron_text::Span {
             range: start..text.len(),
-            style,
-            pad_start: 0.0,
-            pad_end: 0.0,
+            style: style.id,
+            pad_start: pad.0,
+            pad_end: pad.1,
             atomic,
         });
         paints.push(super::markdown::SpanPaint {
-            color,
+            color: ColorRole::Text,
             decoration: super::display::Decoration::None,
-            link: None,
+            link,
             chip: false,
         });
+        Some(spans.len() - 1)
     };
-    for link in &links {
-        push(&mut text, &body[at..link.range.start], style.id, false, ColorRole::Text);
-        push(&mut text, &format!("@{}", link.basename), chip.id, true, ColorRole::Link);
-        at = link.range.end;
+    for chip in chips {
+        push(&mut text, &body[at..chip.range.start], (0.0, 0.0), false, None);
+        let link = chip.open.map(|url| {
+            links.push(url);
+            (links.len() - 1) as u16
+        });
+        if let Some(span) = push(&mut text, &chip.label, chip_pad, true, link) {
+            badges.push((span, chip.icon));
+        }
+        at = chip.range.end;
     }
-    push(&mut text, &body[at..], style.id, false, ColorRole::Text);
+    push(&mut text, &body[at..], (0.0, 0.0), false, None);
     let p = zeron_text::prepare(
         &ctx.typo.book,
         ctx.cache,
@@ -566,8 +674,9 @@ fn prepare_user_text(ctx: &mut Ctx, body: &str, style: super::style::Resolved, l
         lh,
         base: super::style::baseline(lh, style),
         paints,
-        links: Vec::new(),
-        chip: (0.0, 0.0),
+        links,
+        chip: ((lh - chip_h) / 2.0, chip_h),
+        badges,
     }
 }
 
@@ -690,18 +799,36 @@ fn place_user(u: &UserBubble, px: Px, x: f32, y: f32, cw: f32, out: Option<&mut
     let more_h = if folds { u.more.lh + px.v(4.0) } else { 0.0 };
     let bubble_w = if folds { max_w } else { stats.max_line_width.ceil() + pad_x * 2.0 };
     let bubble_h = if stats.line_count == 0 { 0.0 } else { text_h + more_h + pad_y * 2.0 };
-    let thumbs_h = if u.images.is_empty() { 0.0 } else { px.v(THUMB) + if bubble_h > 0.0 { px.v(8.0) } else { 0.0 } };
+    let side = px.v(THUMB);
+    let gap = px.v(6.0);
+    let pill_h = px.v(FILE_PILL);
+    // Thumbnails row, then one pill per file, stacked above the bubble.
+    let files_y = if u.images.is_empty() { 0.0 } else { side + gap };
+    let attach_h = (files_y + u.files.len() as f32 * (pill_h + gap) - gap).max(0.0);
+    let thumbs_h = if attach_h > 0.0 { attach_h + if bubble_h > 0.0 { px.v(8.0) } else { 0.0 } } else { 0.0 };
     let h = thumbs_h + bubble_h;
     let Some(out) = out else { return h };
     // Thumbnails right-aligned above the bubble.
-    let side = px.v(THUMB);
-    let gap = px.v(6.0);
     let mut tx = x + cw - side;
     for img in u.images.iter().rev() {
         out.fill(tx, y, side, side, px.v(12.0), ColorRole::ChipBackground);
         out.widget(WidgetKind::Image { reference: img.clone() }, (tx, y, side, side), None);
         tx -= side + gap;
     }
+    // Files: right-aligned icon + name pills; long names fade at the edge.
+    let is = px.v(16.0);
+    let inset = px.v(10.0) + is + px.v(8.0);
+    let chrome = inset + px.v(12.0);
+    let name_w = (max_w - chrome).max(1.0);
+    let mut fy = y + files_y;
+    for (icon, name) in &u.files {
+        let pw = chrome + name.p.max_content_width().ceil().min(name_w);
+        let fx = x + cw - pw;
+        out.fill(fx, fy, pw, pill_h, px.v(12.0), ColorRole::ChipBackground);
+        out.widget(WidgetKind::Icon { name: icon.clone(), color: ColorRole::TextSoft }, (fx + px.v(10.0), fy + (pill_h - is) / 2.0, is, is), None);
+        place_text_lines(name, fx + inset, fy + (pill_h - name.lh) / 2.0, name_w, 1, px, out);
+        fy += pill_h + gap;
+    }
     if bubble_h > 0.0 {
         let bx = x + cw - bubble_w;
         let by = y + thumbs_h;
@@ -740,7 +867,7 @@ pub(crate) fn content_heap_bytes(content: &Content) -> usize {
     }
     match content {
         Content::Block(b) => block(b),
-        Content::User(u) => u.text.p.heap_bytes() + u.more.p.heap_bytes(),
+        Content::User(u) => u.text.p.heap_bytes() + u.more.p.heap_bytes() + u.files.iter().map(|(_, n)| n.p.heap_bytes()).sum::<usize>(),
         Content::Tools(t) => super::tools::heap_bytes(t),
         Content::Chip(c) => c.text.p.heap_bytes(),
         Content::Image { reference } => reference.len(),
diff --git a/crates/mobile/src/layout/tests.rs b/crates/mobile/src/layout/tests.rs
index 01ac1c72cb..d503e96903 100644
--- a/crates/mobile/src/layout/tests.rs
+++ b/crates/mobile/src/layout/tests.rs
@@ -464,15 +464,31 @@ fn bench_layout_passes() {
 }
 
 #[test]
-fn user_mentions_render_as_accent_chips() {
+fn user_mentions_render_as_chips() {
+    // The desktop's chips: a soft pill with the file theme's icon on a well,
+    // the label in the body color — for files, folders, skills and commands.
     let mut w = worker(390.0);
-    let text = "Look at [mod.rs](zeron-file:crates/mobile/src/layout/mod.rs) please".to_owned();
+    let skill = zeron_proto::invocation::Invocation::Skill { name: "review".into(), path: "/repo/SKILL.md".into(), command: None };
+    let text = format!(
+        "Look at [mod.rs](zeron-file:crates/mobile/src/layout/mod.rs) in [layout](zeron-file:crates/mobile/src/layout/) with {}",
+        skill.link()
+    );
     w.input = debug_input(vec![DebugEntry { id: "u".into(), user: true, text, streaming: false }], false);
     let frame = w.pass();
     let d = frame.display(0).unwrap();
-    assert!(d.text.contains("@mod.rs"), "{}", d.text);
-    assert!(!d.text.contains("zeron-file:"));
-    assert!(d.runs.iter().any(|r| r.color == display::ColorRole::Link));
+    assert!(d.text.contains("mod.rs") && !d.text.contains("@mod.rs"), "{}", d.text);
+    assert!(!d.text.contains("zeron-"), "{}", d.text);
+    assert!(d.runs.iter().all(|r| r.color != display::ColorRole::Link));
+    let icons: Vec<&str> = d
+        .widgets
+        .iter()
+        .filter_map(|w| match &w.kind {
+            display::WidgetKind::Icon { name, .. } => Some(name.as_str()),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(icons, ["fileicon-files-rust", "fileicon-folders-folder", "wand.and.stars"]);
+    assert_eq!(d.boxes.iter().filter(|b| b.color == display::ColorRole::ToolBadge).count(), 3);
 }
 
 #[test]
@@ -487,6 +503,35 @@ fn user_attachments_render_as_images_not_trailer_text() {
     assert!(d.widgets.iter().any(|w| matches!(&w.kind, display::WidgetKind::Image { reference } if reference.ends_with("shot.png"))));
 }
 
+#[test]
+fn synced_file_attachments_render_as_chips_and_name_pills() {
+    // A desktop send mixing an image and ZIPs (one still a queued-upload ref),
+    // with composer chips in the prompt. Chipped attachments show as their
+    // chip only; the image chip opens its upload; the unchipped ZIP keeps a
+    // name pill and never reaches image loading.
+    let mut w = worker(390.0);
+    let text = "Compare [Image 1](zeron-image:1) with [notes.zip](zeron-attachment:2)\n\nAttached images (local files — open them to view):\n- /tmp/uploads/ab12cd34-Image_1.png\n- /tmp/uploads/ab12cd34-notes.zip\n- pending://up-3/logs.zip".to_owned();
+    w.input = debug_input(vec![DebugEntry { id: "u".into(), user: true, text, streaming: false }], false);
+    let frame = w.pass();
+    let d = frame.display(0).unwrap();
+    assert!(!d.widgets.iter().any(|w| matches!(&w.kind, display::WidgetKind::Image { .. })));
+    let icons: Vec<&str> = d
+        .widgets
+        .iter()
+        .filter_map(|w| match &w.kind {
+            display::WidgetKind::Icon { name, .. } => Some(name.as_str()),
+            _ => None,
+        })
+        .collect();
+    // The unchipped ZIP's pill, then the bubble's two chips.
+    assert_eq!(icons, ["fileicon-files-compressed", "photo", "fileicon-files-compressed"]);
+    assert!(d.text.contains("Compare Image 1 with notes.zip"), "{}", d.text);
+    assert!(d.text.contains("logs.zip") && !d.text.contains("ab12cd34-"), "{}", d.text);
+    assert!(!d.text.contains("zeron-image") && !d.text.contains("zeron-attachment"), "{}", d.text);
+    let links: Vec<&str> = d.links.iter().map(|l| l.url.as_str()).collect();
+    assert_eq!(links, ["zeron-preview://image?ref=%2Ftmp%2Fuploads%2Fab12cd34-Image_1.png"]);
+}
+
 #[test]
 fn folded_user_message_fades_its_last_line() {
     let mut w = worker(390.0);
diff --git a/crates/mobile/src/layout/tools.rs b/crates/mobile/src/layout/tools.rs
index f815276e39..8a3bd8458e 100644
--- a/crates/mobile/src/layout/tools.rs
+++ b/crates/mobile/src/layout/tools.rs
@@ -653,6 +653,7 @@ fn prepare_thought(ctx: &mut Ctx, st: &Styles, lines: &[Vec<InlineRun>], more: b
             paints,
             links: Vec::new(),
             chip: (0.0, 0.0),
+            badges: Vec::new(),
         };
         prepared.push(ThoughtLine { indent, gutter, bars, body: Some(body) });
     }
diff --git a/crates/proto/src/attachment_mentions.rs b/crates/proto/src/attachment_mentions.rs
new file mode 100644
index 0000000000..54eb15398c
--- /dev/null
+++ b/crates/proto/src/attachment_mentions.rs
@@ -0,0 +1,314 @@
+//! Canonical attachment chips shared by the editor, transcript and harness
+//! delivery.
+//!
+//! A composer attachment is referenced from the prompt by a strict local
+//! Markdown link carrying only its per-draft number, never a path. Images read
+//! `[Image N]`; other files carry their file name. The editor projects either
+//! to a chip; providers receive the plain label, which pairs with the upload of
+//! the same name.
+use std::ops::Range;
+
+pub const IMAGE_MENTION_SCHEME: &str = "zeron-image:";
+pub const ATTACHMENT_MENTION_SCHEME: &str = "zeron-attachment:";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AttachmentMention {
+    pub range: Range<usize>,
+    pub index: u32,
+    /// `Image N` for images, the file name for other attachments.
+    pub label: String,
+    pub is_image: bool,
+}
+
+impl AttachmentMention {
+    /// Whether this chip names the attachment at `path`. Images match by
+    /// draft number (`Image 2` ↔ `ab12cd34-Image_2.png`), files by name as
+    /// the engine sanitizes it.
+    pub fn names_attachment(&self, path: &str) -> bool {
+        if self.is_image {
+            return image_index_from_name(path) == Some(self.index);
+        }
+        let sanitized = |name: &str| -> String {
+            name.chars()
+                .map(|c| {
+                    if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') {
+                        c
+                    } else {
+                        '_'
+                    }
+                })
+                .collect()
+        };
+        let name = attachment_display_name(path.rsplit(['/', '\\']).next().unwrap_or(path));
+        sanitized(&self.label) == sanitized(name)
+    }
+}
+
+/// The user-visible name of the `index`th image of a draft.
+pub fn image_label(index: u32) -> String {
+    format!("Image {index}")
+}
+
+/// The chip link for attachment `index`: an image when `file_name` is `None`.
+pub fn attachment_mention_link(index: u32, file_name: Option<&str>) -> String {
+    match file_name {
+        None => format!("[{}]({IMAGE_MENTION_SCHEME}{index})", image_label(index)),
+        Some(name) => format!(
+            "[{}]({ATTACHMENT_MENTION_SCHEME}{index})",
+            crate::file_mentions::escape_mention_label(name)
+        ),
+    }
+}
+
+/// Recover the draft number from an upload or staged image name such as
+/// `Image 2.png` / `ab12cd34-Image_2.png` (uploads sanitize spaces).
+pub fn image_index_from_name(name: &str) -> Option<u32> {
+    let name = name.rsplit(['/', '\\']).next()?;
+    let stem = name.rsplit_once('.').map_or(name, |(stem, _)| stem);
+    let digits_at = stem.trim_end_matches(|c: char| c.is_ascii_digit()).len();
+    let (head, digits) = stem.split_at(digits_at);
+    let head = head.strip_suffix([' ', '_'])?;
+    if !(head == "Image" || head.ends_with("-Image")) {
+        return None;
+    }
+    digits.parse().ok().filter(|index| *index > 0)
+}
+
+/// Whether an attachment ref names an image, as opposed to any other file.
+/// The same extensions the desktop decodes (`format_by_extension`), so every
+/// client shows a given attachment the same way.
+pub fn is_image_path(path: &str) -> bool {
+    path.rsplit_once('.').is_some_and(|(_, extension)| {
+        matches!(
+            extension.to_ascii_lowercase().as_str(),
+            "png" | "jpg" | "jpeg" | "gif" | "webp" | "svg" | "bmp" | "tif" | "tiff"
+        )
+    })
+}
+
+/// The file name to show for an attachment ref: uploads are stored as
+/// `{id8}-{name}`, and the prefix is not part of the name.
+pub fn attachment_display_name(name: &str) -> &str {
+    match name.split_once('-') {
+        Some((id, rest)) if id.len() == 8 && id.bytes().all(|b| b.is_ascii_hexdigit()) => rest,
+        _ => name,
+    }
+}
+
+/// Undo [`crate::file_mentions::escape_mention_label`], rejecting any label
+/// that is not exactly what escaping produces.
+fn unescape_label(raw: &str) -> Option<String> {
+    let mut out = String::new();
+    let mut chars = raw.chars();
+    while let Some(c) = chars.next() {
+        match c {
+            '\\' => match chars.next()? {
+                escaped @ ('\\' | '[' | ']' | '`') => out.push(escaped),
+                _ => return None,
+            },
+            '[' | ']' | '`' => return None,
+            c if c.is_control() => return None,
+            c => out.push(c),
+        }
+    }
+    (!out.is_empty()).then_some(out)
+}
+
+/// Only canonical chip links are decoded, never escaped text or code examples.
+pub fn attachment_mentions(text: &str) -> Vec<AttachmentMention> {
+    if !text.contains(IMAGE_MENTION_SCHEME) && !text.contains(ATTACHMENT_MENTION_SCHEME) {
+        return Vec::new();
+    }
+    let mut image_depth = 0;
+    pulldown_cmark::Parser::new(text)
+        .into_offset_iter()
+        .filter_map(|(event, range)| {
+            match &event {
+                pulldown_cmark::Event::Start(pulldown_cmark::Tag::Image { .. }) => {
+                    image_depth += 1;
+                }
+                pulldown_cmark::Event::End(pulldown_cmark::TagEnd::Image) => {
+                    image_depth -= 1;
+                }
+                _ => {}
+            }
+            if image_depth > 0 {
+                return None;
+            }
+            let pulldown_cmark::Event::Start(pulldown_cmark::Tag::Link { dest_url, .. }) = event
+            else {
+                return None;
+            };
+            let (scheme, is_image) = if dest_url.starts_with(IMAGE_MENTION_SCHEME) {
+                (IMAGE_MENTION_SCHEME, true)
+            } else {
+                (ATTACHMENT_MENTION_SCHEME, false)
+            };
+            let digits = dest_url.strip_prefix(scheme)?;
+            if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
+                return None;
+            }
+            let index: u32 = digits.parse().ok().filter(|index| *index > 0)?;
+            let source = &text[range.clone()];
+            let label = if is_image {
+                (source == attachment_mention_link(index, None)).then(|| image_label(index))?
+            } else {
+                let tail = format!("]({scheme}{index})");
+                unescape_label(source.strip_prefix('[')?.strip_suffix(&tail)?)?
+            };
+            Some(AttachmentMention {
+                range,
+                index,
+                label,
+                is_image,
+            })
+        })
+        .collect()
+}
+
+/// The attachment numbers a draft mentions, in order of appearance, without
+/// repeats.
+pub fn attachment_mention_indices(text: &str) -> Vec<u32> {
+    let mut seen = Vec::new();
+    for mention in attachment_mentions(text) {
+        if !seen.contains(&mention.index) {
+            seen.push(mention.index);
+        }
+    }
+    seen
+}
+
+/// Replace chips with their plain label. Providers read prose, and the label
+/// pairs with the attached upload.
+pub fn attachment_mention_prompt(text: &str) -> String {
+    replace_mentions(text, |_| true)
+}
+
+/// Replace chips whose attachment is not attached by plain text, so a dangling
+/// reference never leaves the composer as a link.
+pub fn demote_unattached_mentions(text: &str, attached: &[u32]) -> String {
+    replace_mentions(text, |index| !attached.contains(&index))
+}
+
+fn replace_mentions(text: &str, replace: impl Fn(u32) -> bool) -> String {
+    let mut out = String::new();
+    let mut at = 0;
+    for mention in attachment_mentions(text) {
+        if !replace(mention.index) {
+            continue;
+        }
+        out.push_str(&text[at..mention.range.start]);
+        out.push_str(&mention.label);
+        at = mention.range.end;
+    }
+    out.push_str(&text[at..]);
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn image(index: u32) -> String {
+        attachment_mention_link(index, None)
+    }
+
+    #[test]
+    fn links_round_trip_and_become_plain_labels() {
+        assert_eq!(image(2), "[Image 2](zeron-image:2)");
+        let notes = attachment_mention_link(3, Some("my [notes].md"));
+        assert_eq!(notes, "[my \\[notes\\].md](zeron-attachment:3)");
+        let text = format!("compare {} with {notes} and {}", image(2), image(10));
+        let mentions = attachment_mentions(&text);
+        assert_eq!(
+            mentions
+                .iter()
+                .map(|m| (m.index, m.label.as_str(), m.is_image))
+                .collect::<Vec<_>>(),
+            vec![
+                (2, "Image 2", true),
+                (3, "my [notes].md", false),
+                (10, "Image 10", true)
+            ]
+        );
+        assert_eq!(&text[mentions[1].range.clone()], notes);
+        assert_eq!(
+            attachment_mention_prompt(&text),
+            "compare Image 2 with my [notes].md and Image 10"
+        );
+        assert_eq!(
+            attachment_mention_indices(&format!("{}{}", image(2), image(2))),
+            vec![2]
+        );
+    }
+
+    #[test]
+    fn hostile_and_literal_links_stay_ordinary_text() {
+        let link = image(1);
+        let file = attachment_mention_link(1, Some("a.md"));
+        for literal in [
+            format!("`{link}`"),
+            format!("```\n{link}\n```"),
+            format!("\\{link}"),
+            format!("![example {link}](example.png)"),
+            format!("`{file}`"),
+            format!("\\{file}"),
+            "[Image 1](zeron-image:0)".to_string(),
+            "[Image 1](zeron-image:)".to_string(),
+            "[Image 1](zeron-image:1x)".to_string(),
+            "[Image 1](zeron-image:-1)".to_string(),
+            "[Image 1](zeron-image:../x)".to_string(),
+            "[Image 2](zeron-image:1)".to_string(),
+            "[Other](zeron-image:1)".to_string(),
+            "[Image 1](zeron-image:99999999999)".to_string(),
+            "[Image 01](zeron-image:01)".to_string(),
+            "[](zeron-attachment:1)".to_string(),
+            "[a.md](zeron-attachment:0)".to_string(),
+            "[a.md](zeron-attachment:1 \"title\")".to_string(),
+            "[a\nb.md](zeron-attachment:1)".to_string(),
+            "[a`b.md](zeron-attachment:1)".to_string(),
+            "[a\\xb.md](zeron-attachment:1)".to_string(),
+        ] {
+            assert!(attachment_mentions(&literal).is_empty(), "{literal}");
+            assert_eq!(attachment_mention_prompt(&literal), literal);
+        }
+    }
+
+    #[test]
+    fn unattached_mentions_demote_to_labels_only() {
+        let text = format!(
+            "{} and {}",
+            image(1),
+            attachment_mention_link(2, Some("a.md"))
+        );
+        assert_eq!(
+            demote_unattached_mentions(&text, &[2]),
+            format!("Image 1 and {}", attachment_mention_link(2, Some("a.md")))
+        );
+    }
+
+    #[test]
+    fn image_names_recover_their_number() {
+        for (name, index) in [
+            ("Image 3.png", Some(3)),
+            ("ab12cd34-Image_12.png", Some(12)),
+            ("/uploads/ab-Image_2.webp", Some(2)),
+            ("Image 0.png", None),
+            ("image.png", None),
+            ("Imaged 2.png", None),
+            ("cat.png", None),
+        ] {
+            assert_eq!(image_index_from_name(name), index, "{name}");
+        }
+    }
+
+    #[test]
+    fn attachment_refs_split_images_from_files() {
+        assert!(is_image_path("/uploads/ab12cd34-shot.PNG"));
+        assert!(is_image_path("pending://u1/Image_1.jpeg"));
+        assert!(!is_image_path("/uploads/ab12cd34-notes.zip"));
+        assert!(!is_image_path("/uploads/png"));
+        assert_eq!(attachment_display_name("ab12cd34-notes.zip"), "notes.zip");
+        assert_eq!(attachment_display_name("my-notes.zip"), "my-notes.zip");
+    }
+}
diff --git a/crates/proto/src/file_mentions.rs b/crates/proto/src/file_mentions.rs
index 93d916e576..990cdf4712 100644
--- a/crates/proto/src/file_mentions.rs
+++ b/crates/proto/src/file_mentions.rs
@@ -39,7 +39,7 @@ fn percent_decode_path(encoded: &str) -> Option<String> {
     String::from_utf8(bytes).ok()
 }
 
-fn escape_mention_label(label: &str) -> String {
+pub(crate) fn escape_mention_label(label: &str) -> String {
     label
         .replace('\\', "\\\\")
         .replace('[', "\\[")
diff --git a/crates/proto/src/invocation.rs b/crates/proto/src/invocation.rs
index 54c614cf5d..c33c800d32 100644
--- a/crates/proto/src/invocation.rs
+++ b/crates/proto/src/invocation.rs
@@ -207,7 +207,9 @@ pub fn validate_harness_invocations(text: &str, harness: crate::HarnessId) -> Re
 /// Keep selected skill identity intact until Codex builds native input blocks.
 /// Other providers receive readable Markdown and their advertised command text.
 pub fn harness_prompt(text: &str, harness: crate::HarnessId) -> String {
-    let text = crate::file_mentions::file_mention_prompt(text);
+    let text = crate::file_mentions::file_mention_prompt(
+        &crate::attachment_mentions::attachment_mention_prompt(text),
+    );
     if harness == crate::HarnessId::Codex {
         return text;
     }
@@ -250,6 +252,7 @@ pub fn harness_prompt(text: &str, harness: crate::HarnessId) -> String {
 }
 
 pub fn invocation_prompt(text: &str) -> String {
+    let text = &crate::attachment_mentions::attachment_mention_prompt(text);
     let mut result = String::new();
     let mut at = 0;
     for (range, invocation) in invocation_links(text) {
@@ -302,6 +305,23 @@ mod tests {
         crate::HarnessId::Opencode,
     ];
 
+    #[test]
+    fn image_chips_reach_every_provider_as_their_plain_label() {
+        let raw = format!(
+            "compare {} with {}",
+            crate::attachment_mentions::attachment_mention_link(1, None),
+            crate::attachment_mentions::attachment_mention_link(3, None)
+        );
+        assert_eq!(invocation_prompt(&raw), "compare Image 1 with Image 3");
+        for harness in HARNESSES {
+            assert_eq!(
+                harness_prompt(&raw, harness),
+                "compare Image 1 with Image 3",
+                "{harness:?}"
+            );
+        }
+    }
+
     #[test]
     fn leading_commands_respect_markdown_indentation() {
         for text in [
diff --git a/crates/proto/src/lib.rs b/crates/proto/src/lib.rs
index 92729dec72..b351940101 100644
--- a/crates/proto/src/lib.rs
+++ b/crates/proto/src/lib.rs
@@ -4,6 +4,7 @@
 //! Context occupancy is replicated per chat; billing `Usage` remains a harness passthrough.
 
 pub mod agent;
+pub mod attachment_mentions;
 pub mod entities;
 pub mod file_mentions;
 pub mod invocation;
diff --git a/crates/ui/assets/icons/gallery.svg b/crates/ui/assets/icons/gallery.svg
new file mode 100644
index 0000000000..86a2d57f05
--- /dev/null
+++ b/crates/ui/assets/icons/gallery.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="16" rx="4"/><circle cx="9" cy="10" r="1.75"/><path d="M3.5 16.5l4.6-4.2a2 2 0 0 1 2.7.1l2.7 2.6 1.9-1.6a2 2 0 0 1 2.6 0L20.5 15"/></svg>
diff --git a/crates/ui/src/appshots.rs b/crates/ui/src/appshots.rs
index 20d12f5e9e..26290b0e20 100644
--- a/crates/ui/src/appshots.rs
+++ b/crates/ui/src/appshots.rs
@@ -751,7 +751,9 @@ pub(crate) fn restore_queued_appshots(
         // their PNG. Normalize their bytes too, without changing attachment IDs.
         if png_dimensions(screenshot.bytes()).is_some() {
             if let Some(bytes) = trim_appshot_padding(screenshot.bytes()).map_err(|_| invalid())? {
-                screenshot.image = Arc::new(gpui::Image::from_bytes(gpui::ImageFormat::Png, bytes));
+                screenshot.content = crate::attachments::AttachmentContent::Image(Arc::new(
+                    gpui::Image::from_bytes(gpui::ImageFormat::Png, bytes),
+                ));
             }
         }
         let content = node.text().unwrap_or_default();
@@ -938,7 +940,11 @@ pub(crate) mod tests {
             screenshot: StagedAttachment {
                 id: "image-1".into(),
                 name: "Safari Appshot.png".into(),
-                image: Arc::new(Image::from_bytes(ImageFormat::Png, Vec::new())),
+                content: crate::attachments::AttachmentContent::Image(Arc::new(Image::from_bytes(
+                    ImageFormat::Png,
+                    Vec::new(),
+                ))),
+                mention: None,
             },
             screenshot_dimensions: Some((1440, 900)),
             app_icon: None,
diff --git a/crates/ui/src/attachments.rs b/crates/ui/src/attachments.rs
index 1f3078cafc..38fa5195bf 100644
--- a/crates/ui/src/attachments.rs
+++ b/crates/ui/src/attachments.rs
@@ -46,6 +46,64 @@ const MAX_READ_CHUNKS: usize = 1_000;
 
 /// The body used for image-only sends (`use-attachments.ts`).
 pub const ATTACHMENT_ONLY_TEXT: &str = "See the attached image(s).";
+/// The body used when any attachment is not an image.
+pub const FILE_ATTACHMENT_ONLY_TEXT: &str = "See the attached file(s).";
+
+/// Whether `text` is the placeholder body of an attachments-only send.
+pub fn is_attachment_only_text(text: &str) -> bool {
+    text == ATTACHMENT_ONLY_TEXT || text == FILE_ATTACHMENT_ONLY_TEXT
+}
+
+/// The placeholder body for an attachments-only send of `paths`.
+pub fn attachment_only_text(paths: &[String]) -> &'static str {
+    if paths.iter().all(|path| is_image_path(path)) {
+        ATTACHMENT_ONLY_TEXT
+    } else {
+        FILE_ATTACHMENT_ONLY_TEXT
+    }
+}
+
+/// Whether an attachment ref names an image, as opposed to any other file.
+pub fn is_image_path(path: &str) -> bool {
+    format_by_extension(Path::new(path)).is_some()
+}
+
+pub use zeron_proto::attachment_mentions::attachment_display_name;
+
+/// Whether `mention` is the chip for the attachment at `path`.
+pub fn chip_names_attachment(
+    mention: &zeron_proto::attachment_mentions::AttachmentMention,
+    path: &str,
+) -> bool {
+    mention.names_attachment(path)
+}
+
+/// Number restored attachments after the chips in `text` that name them, so
+/// those chips stay live; an attachment no chip names is left unnumbered.
+pub fn pair_with_chips(text: &str, attachments: &mut [StagedAttachment]) {
+    let chips = zeron_proto::attachment_mentions::attachment_mentions(text);
+    for att in attachments {
+        att.mention = chips
+            .iter()
+            .find(|chip| chip_names_attachment(chip, &att.name))
+            .map(|chip| chip.index);
+    }
+}
+
+/// The attachments no chip in `text` stands for, in order. A chip is the
+/// attachment's handle wherever it shows, so only these still need a tile;
+/// anything a chip can't be matched to keeps its tile.
+pub fn unchipped_attachments<'a>(text: &str, paths: &'a [String]) -> Vec<&'a String> {
+    let mentions = zeron_proto::attachment_mentions::attachment_mentions(text);
+    paths
+        .iter()
+        .filter(|path| {
+            !mentions
+                .iter()
+                .any(|mention| chip_names_attachment(mention, path))
+        })
+        .collect()
+}
 
 /// How attachments ride the prompt (use-attachments.ts `withAttachments`):
 /// plain local paths appended to the text — the files are staged on the device
@@ -57,7 +115,7 @@ pub fn with_attachments(text: &str, paths: &[String]) -> String {
     }
     let refs: Vec<String> = paths.iter().map(|p| format!("- {p}")).collect();
     let body = if text.is_empty() {
-        ATTACHMENT_ONLY_TEXT
+        attachment_only_text(paths)
     } else {
         text
     };
@@ -153,7 +211,7 @@ pub fn parse_user_message_images(content: &str) -> ParsedUserMessage {
         };
     }
     ParsedUserMessage {
-        text: if body.trim() == ATTACHMENT_ONLY_TEXT {
+        text: if is_attachment_only_text(body.trim()) {
             String::new()
         } else {
             body.to_string()
@@ -169,10 +227,19 @@ pub fn user_message_rail_text(content: &str) -> String {
     if !parsed.text.trim().is_empty() {
         return parsed.text;
     }
+    let kind = if parsed
+        .attachments
+        .iter()
+        .all(|att| is_image_path(&att.path))
+    {
+        "image"
+    } else {
+        "file"
+    };
     match parsed.attachments.len() {
         0 => content.to_string(),
-        1 => "Attached image".to_string(),
-        n => format!("{n} attached images"),
+        1 => format!("Attached {kind}"),
+        n => format!("{n} attached {kind}s"),
     }
 }
 
@@ -180,21 +247,62 @@ pub fn user_message_rail_text(content: &str) -> String {
 // Staging (use-attachments.ts intake)
 // ---------------------------------------------------------------------------
 
-/// An image staged in the composer, before upload. The raw bytes live inside
-/// the [`Image`] (gpui decodes them at paint; the same Arc feeds thumbnails,
-/// the lightbox, the upload, and the post-send cache seed).
+/// What a staged attachment holds. Images keep their decoded-at-paint
+/// [`Image`], which feeds thumbnails, the lightbox, the upload and the
+/// post-send cache seed; any other file stays opaque bytes.
+#[derive(Clone)]
+pub enum AttachmentContent {
+    Image(Arc<Image>),
+    File(Arc<Vec<u8>>),
+}
+
+/// A file staged in the composer, before upload.
 #[derive(Clone)]
 pub struct StagedAttachment {
     pub id: String,
-    /// File name with a type-matching extension (use-attachments.ts
+    /// File name. Images carry a type-matching extension (use-attachments.ts
     /// `ensureExtension` — agents sniff images by extension).
     pub name: String,
-    pub image: Arc<Image>,
+    pub content: AttachmentContent,
+    /// The composer's chip number when a chip in the draft mentions this
+    /// attachment. `None` for attachments the prompt does not reference
+    /// (appshots, drafts restored from before chips).
+    pub mention: Option<u32>,
 }
 
 impl StagedAttachment {
     pub fn bytes(&self) -> &[u8] {
-        &self.image.bytes
+        match &self.content {
+            AttachmentContent::Image(image) => &image.bytes,
+            AttachmentContent::File(bytes) => bytes,
+        }
+    }
+
+    /// The picture, for attachments that are images.
+    pub fn image(&self) -> Option<&Arc<Image>> {
+        match &self.content {
+            AttachmentContent::Image(image) => Some(image),
+            AttachmentContent::File(_) => None,
+        }
+    }
+
+    fn new(name: String, content: AttachmentContent) -> Self {
+        Self {
+            id: uuid::Uuid::new_v4().to_string(),
+            name,
+            content,
+            mention: None,
+        }
+    }
+
+    fn from_image(name: String, image: Image) -> Self {
+        Self::new(name, AttachmentContent::Image(Arc::new(image)))
+    }
+
+    fn from_file(name: &str, bytes: Vec<u8>) -> Self {
+        // Attachment refs ride the prompt one per line; a name must not add lines.
+        let name = name.replace(['\r', '\n'], "_");
+        Self::new(name, AttachmentContent::File(Arc::new(bytes)))
     }
 }
 
@@ -231,15 +339,22 @@ pub fn ensure_extension(name: &str, format: ImageFormat) -> String {
     }
 }
 
-/// Stage a file from disk (picker / drop / pasted path); a BMP is converted to
-/// PNG, which agents can read. `Err` carries the user-facing message (mirrors
-/// the old `onError` copy).
+/// Stage a file from disk (picker / drop / pasted path). An image keeps its
+/// thumbnail (a BMP is converted to PNG, which agents can read); any other
+/// regular file is staged as opaque bytes. `Err` carries the user-facing
+/// message (mirrors the old `onError` copy).
 pub fn stage_file(path: &Path) -> Result<StagedAttachment, String> {
+    if format_by_extension(path).is_none() {
+        return stage_plain_file(path);
+    }
     let mut staged = stage_file_verbatim(path)?;
-    if staged.image.format == ImageFormat::Bmp {
-        let png = bmp_to_png(&staged.image)
-            .map_err(|_| format!("{} is not a valid image.", staged.name))?;
-        staged.image = Arc::new(png);
+    if let Some(image) = staged
+        .image()
+        .filter(|image| image.format == ImageFormat::Bmp)
+    {
+        let png =
+            bmp_to_png(image).map_err(|_| format!("{} is not a valid image.", staged.name))?;
+        staged.content = AttachmentContent::Image(Arc::new(png));
         staged.name = Path::new(&staged.name)
             .with_extension("png")
             .to_string_lossy()
@@ -248,26 +363,45 @@ pub fn stage_file(path: &Path) -> Result<StagedAttachment, String> {
     Ok(staged)
 }
 
+/// Read a regular file within the attachment size limit. `Err` carries the
+/// user-facing message.
+fn read_regular_file(path: &Path, name: &str) -> Result<Vec<u8>, String> {
+    let meta = std::fs::metadata(path).map_err(|_| format!("{name} could not be read."))?;
+    if !meta.is_file() {
+        return Err(format!("{name} is not a file."));
+    }
+    if meta.len() > MAX_ATTACHMENT_BYTES {
+        return Err(format!("{name} is too large (24 MB max)."));
+    }
+    std::fs::read(path).map_err(|_| format!("{name} could not be read."))
+}
+
+fn file_name(path: &Path, fallback: &str) -> String {
+    path.file_name().map_or_else(
+        || fallback.to_string(),
+        |n| n.to_string_lossy().into_owned(),
+    )
+}
+
 /// Stage a file's bytes exactly as stored, for callers that decode the image
 /// themselves (wallpapers) rather than hand it to an agent.
 pub fn stage_file_verbatim(path: &Path) -> Result<StagedAttachment, String> {
-    let display_name = path
-        .file_name()
-        .map(|n| n.to_string_lossy().to_string())
-        .unwrap_or_else(|| "image".to_string());
+    let name = file_name(path, "image");
     let Some(format) = format_by_extension(path) else {
-        return Err(format!("{display_name} is not a supported image."));
+        return Err(format!("{name} is not a supported image."));
     };
-    let meta = std::fs::metadata(path).map_err(|_| format!("{display_name} could not be read."))?;
-    if meta.len() > MAX_ATTACHMENT_BYTES {
-        return Err(format!("{display_name} is too large (24 MB max)."));
-    }
-    let bytes = std::fs::read(path).map_err(|_| format!("{display_name} could not be read."))?;
-    Ok(StagedAttachment {
-        id: uuid::Uuid::new_v4().to_string(),
-        name: ensure_extension(&display_name, format),
-        image: Arc::new(Image::from_bytes(format, bytes)),
-    })
+    let bytes = read_regular_file(path, &name)?;
+    Ok(StagedAttachment::from_image(
+        ensure_extension(&name, format),
+        Image::from_bytes(format, bytes),
+    ))
+}
+
+/// Stage any other regular file as opaque bytes.
+fn stage_plain_file(path: &Path) -> Result<StagedAttachment, String> {
+    let name = file_name(path, "file");
+    let bytes = read_regular_file(path, &name)?;
+    Ok(StagedAttachment::from_file(&name, bytes))
 }
 
 /// Stage an image pasted from the clipboard. A BMP (what Windows puts there for
@@ -281,11 +415,7 @@ pub fn stage_clipboard_image(image: Image) -> StagedAttachment {
     } else {
         image
     };
-    StagedAttachment {
-        id: uuid::Uuid::new_v4().to_string(),
-        name: ensure_extension("image", image.format),
-        image: Arc::new(image),
-    }
+    StagedAttachment::from_image(ensure_extension("image", image.format), image)
 }
 
 /// Windows screenshots are BMP, but no agent harness inlines BMP and the
@@ -303,11 +433,10 @@ fn bmp_to_png(bmp: &Image) -> Result<Image, String> {
 /// Stage native macOS capture bytes without a temporary file. The capture
 /// service already encoded PNG and enforces the shared size limit.
 pub fn stage_png_bytes(name: String, bytes: Vec<u8>) -> StagedAttachment {
-    StagedAttachment {
-        id: uuid::Uuid::new_v4().to_string(),
-        name: ensure_extension(&name, ImageFormat::Png),
-        image: Arc::new(Image::from_bytes(ImageFormat::Png, bytes)),
-    }
+    StagedAttachment::from_image(
+        ensure_extension(&name, ImageFormat::Png),
+        Image::from_bytes(ImageFormat::Png, bytes),
+    )
 }
 
 // ---------------------------------------------------------------------------
@@ -500,14 +629,15 @@ pub struct LoadedAttachmentImage {
 }
 
 /// `ReadAttachmentChunk` loop: 45KB base64 chunks until `done` (bounded, with
-/// the same stuck-offset guard as zeron's `readAttachmentImage`).
-pub async fn read_attachment_image(
+/// the same stuck-offset guard as zeron's `readAttachmentImage`). Returns the
+/// file's name, MIME type and bytes.
+async fn read_attachment_bytes(
     engine: &EngineHandle,
     executor: &BackgroundExecutor,
     target_device_id: Option<&str>,
     path: &str,
     expected_raster_mime: Option<&str>,
-) -> Option<LoadedAttachmentImage> {
+) -> Option<(String, String, Vec<u8>)> {
     let mut name = String::new();
     let mut mime = String::new();
     let mut b64 = String::new();
@@ -533,10 +663,7 @@ pub async fn read_attachment_image(
             return None;
         }
         let data = chunk.get("data")?.as_str()?;
-        if expected_raster_mime.is_some()
-            && b64.len().saturating_add(data.len())
-                > (MAX_ATTACHMENT_BYTES as usize).div_ceil(3) * 4
-        {
+        if b64.len().saturating_add(data.len()) > (MAX_ATTACHMENT_BYTES as usize).div_ceil(3) * 4 {
             return None;
         }
         b64.push_str(data);
@@ -550,10 +677,46 @@ pub async fn read_attachment_image(
         }
         offset = next;
     }
-    if !done || b64.is_empty() {
+    if !done {
         return None;
     }
     let bytes = BASE64.decode(b64.as_bytes()).ok()?;
+    Some((name, mime, bytes))
+}
+
+/// Read back a staged file of any type (a queued message restored for editing).
+pub async fn read_attachment_file(
+    engine: &EngineHandle,
+    executor: &BackgroundExecutor,
+    target_device_id: Option<&str>,
+    path: &str,
+) -> Option<StagedAttachment> {
+    let (name, _, bytes) =
+        read_attachment_bytes(engine, executor, target_device_id, path, None).await?;
+    Some(StagedAttachment::from_file(
+        attachment_display_name(&name),
+        bytes,
+    ))
+}
+
+pub async fn read_attachment_image(
+    engine: &EngineHandle,
+    executor: &BackgroundExecutor,
+    target_device_id: Option<&str>,
+    path: &str,
+    expected_raster_mime: Option<&str>,
+) -> Option<LoadedAttachmentImage> {
+    let (name, mime, bytes) = read_attachment_bytes(
+        engine,
+        executor,
+        target_device_id,
+        path,
+        expected_raster_mime,
+    )
+    .await?;
+    if bytes.is_empty() {
+        return None;
+    }
     let image = if let Some(expected) = expected_raster_mime {
         if expected != mime
             || !matches!(
@@ -946,6 +1109,21 @@ pub fn seed_attachment(device_id: &str, path: &str, name: &str, image: Arc<Image
     store_loaded(device_id, path, name.to_string().into(), image);
 }
 
+/// [`seed_attachment`] for a staged attachment; a file that is not an image
+/// has no thumbnail to seed.
+pub fn seed_staged(device_id: &str, path: &str, att: &StagedAttachment) {
+    if let Some(image) = att.image() {
+        seed_attachment(device_id, path, &att.name, image.clone());
+    }
+}
+
+/// [`seed_attachment_alias`] for a staged attachment.
+pub fn seed_staged_alias(device_id: &str, upload_id: &str, att: &StagedAttachment) {
+    if let Some(image) = att.image() {
+        seed_attachment_alias(device_id, upload_id, &att.name, image.clone());
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Preview lightbox (attachment-ui.tsx AttachmentPreviewDialog)
 // ---------------------------------------------------------------------------
@@ -1126,6 +1304,77 @@ mod tests {
         assert!(thumbnail.bytes.len() < 160 * 112 * 4);
     }
 
+    #[test]
+    fn any_regular_file_stages_with_its_exact_bytes() {
+        let dir = tempfile::tempdir().unwrap();
+        for (name, bytes) in [
+            ("notes.md", &b"# notes\n"[..]),
+            ("archive.tar.gz", &[0x1f, 0x8b, 0, 0xff][..]),
+            ("LICENSE", b"MIT"),
+            ("empty.txt", b""),
+        ] {
+            let path = dir.path().join(name);
+            std::fs::write(&path, bytes).unwrap();
+            let staged = stage_file(&path).unwrap();
+            assert_eq!(staged.name, name);
+            assert_eq!(staged.bytes(), bytes);
+            assert!(staged.image().is_none());
+        }
+        // An image still keeps its thumbnail.
+        let png = dir.path().join("a.png");
+        std::fs::write(&png, b"not decoded here").unwrap();
+        assert!(stage_file(&png).unwrap().image().is_some());
+    }
+
+    #[test]
+    fn folders_and_oversize_files_are_refused_with_a_message() {
+        let dir = tempfile::tempdir().unwrap();
+        assert!(stage_file(dir.path()).err().unwrap().contains("not a file"));
+        let large = dir.path().join("large.bin");
+        std::fs::File::create(&large)
+            .unwrap()
+            .set_len(MAX_ATTACHMENT_BYTES + 1)
+            .unwrap();
+        assert!(stage_file(&large).err().unwrap().contains("too large"));
+        assert!(stage_file(&dir.path().join("missing.md")).is_err());
+    }
+
+    #[test]
+    fn a_staged_name_cannot_add_attachment_lines() {
+        let staged = StagedAttachment::from_file("a\n- injected.md", Vec::new());
+        assert_eq!(staged.name, "a_- injected.md");
+    }
+
+    #[test]
+    fn file_attachments_round_trip_with_their_own_placeholder() {
+        let only_files = with_attachments("", &["/uploads/ab12cd34-notes.md".to_string()]);
+        assert!(only_files.starts_with(FILE_ATTACHMENT_ONLY_TEXT));
+        let parsed = parse_user_message_images(&only_files);
+        assert_eq!(parsed.text, "");
+        assert_eq!(parsed.attachments[0].path, "/uploads/ab12cd34-notes.md");
+        assert_eq!(user_message_rail_text(&only_files), "Attached file");
+
+        // A mixed send reads as files; an image-only send is unchanged.
+        let mixed = with_attachments("", &["/a/cat.png".to_string(), "/a/notes.md".to_string()]);
+        assert!(mixed.starts_with(FILE_ATTACHMENT_ONLY_TEXT));
+        assert_eq!(user_message_rail_text(&mixed), "2 attached files");
+        let images = with_attachments("", &["/a/cat.png".to_string()]);
+        assert!(images.starts_with(ATTACHMENT_ONLY_TEXT));
+        assert!(is_attachment_only_text(ATTACHMENT_ONLY_TEXT));
+        assert!(is_attachment_only_text(FILE_ATTACHMENT_ONLY_TEXT));
+    }
+
+    #[test]
+    fn upload_prefixes_are_not_part_of_the_displayed_name() {
+        assert_eq!(attachment_display_name("ab12cd34-notes.md"), "notes.md");
+        assert_eq!(attachment_display_name("my-notes.md"), "my-notes.md");
+        assert_eq!(
+            attachment_display_name("zzzzzzzz-notes.md"),
+            "zzzzzzzz-notes.md"
+        );
+        assert_eq!(attachment_display_name("notes.md"), "notes.md");
+    }
+
     #[test]
     fn with_attachments_round_trips_through_parse() {
         let paths = vec!["/data/uploads/ab-cat.png".to_string(), "/x/dog.jpg".into()];
@@ -1243,7 +1492,7 @@ mod tests {
     #[test]
     fn pasted_bmp_screenshot_is_staged_as_an_opaque_png() {
         let staged = stage_clipboard_image(Image::from_bytes(ImageFormat::Bmp, clipboard_bmp()));
-        assert_eq!(staged.image.format, ImageFormat::Png);
+        assert_eq!(staged.image().unwrap().format, ImageFormat::Png);
         assert_eq!(staged.name, "image.png");
         let png = image::load_from_memory(staged.bytes()).unwrap();
         assert_eq!(png.into_rgba8().get_pixel(0, 0).0, [10, 20, 30, 255]);
@@ -1256,12 +1505,12 @@ mod tests {
         std::fs::write(&path, clipboard_bmp()).unwrap();
 
         let staged = stage_file(&path).unwrap();
-        assert_eq!(staged.image.format, ImageFormat::Png);
+        assert_eq!(staged.image().unwrap().format, ImageFormat::Png);
         assert_eq!(staged.name, "Screenshot 1.png");
         assert!(image::load_from_memory(staged.bytes()).is_ok());
 
         let verbatim = stage_file_verbatim(&path).unwrap();
-        assert_eq!(verbatim.image.format, ImageFormat::Bmp);
+        assert_eq!(verbatim.image().unwrap().format, ImageFormat::Bmp);
         assert_eq!(verbatim.name, "Screenshot 1.BMP");
         assert_eq!(verbatim.bytes(), clipboard_bmp());
     }
@@ -1288,7 +1537,7 @@ mod tests {
         );
 
         let pasted = stage_clipboard_image(Image::from_bytes(ImageFormat::Bmp, broken));
-        assert_eq!(pasted.image.format, ImageFormat::Bmp);
+        assert_eq!(pasted.image().unwrap().format, ImageFormat::Bmp);
         assert_eq!(pasted.name, "image.bmp");
     }
 
@@ -1512,6 +1761,78 @@ mod generated_image_tests {
         }
     }
 
+    struct FileRpc(Vec<u8>);
+
+    #[async_trait::async_trait]
+    impl zeron_rpc::RpcService for FileRpc {
+        async fn handle(
+            &self,
+            _: &str,
+            _: serde_json::Value,
+        ) -> Result<zeron_rpc::RpcReply, zeron_rpc::RpcError> {
+            zeron_rpc::RpcReply::value(&serde_json::json!({
+                "name": "ab12cd34-notes.md",
+                "mimeType": "application/octet-stream",
+                "data": BASE64.encode(&self.0),
+                "nextOffset": self.0.len(),
+                "done": true,
+            }))
+        }
+    }
+
+    #[test]
+    fn chips_stand_in_for_their_attachments() {
+        use zeron_proto::attachment_mentions::attachment_mention_link;
+        let paths: Vec<String> = [
+            "/uploads/ab12cd34-Image_1.png",
+            "pending://att-2/my notes.md",
+            "/uploads/ef56ab78-Image_3.png",
+            "/uploads/0a1b2c3d-Cargo.toml",
+        ]
+        .map(String::from)
+        .to_vec();
+        let text = format!(
+            "compare {} with {}",
+            attachment_mention_link(1, None),
+            attachment_mention_link(2, Some("my notes.md")),
+        );
+        // Image 3 and Cargo.toml have no chip, so they keep their tiles.
+        assert_eq!(unchipped_attachments(&text, &paths), [&paths[2], &paths[3]]);
+        // A committed upload sanitizes the name the chip still carries.
+        let committed = vec!["/uploads/12345678-my_notes.md".to_string()];
+        assert!(unchipped_attachments(&text, &committed).is_empty());
+        // Plain text keeps every tile.
+        assert_eq!(unchipped_attachments("Image 1", &paths).len(), 4);
+    }
+
+    #[tokio::test]
+    async fn a_queued_file_reads_back_with_its_bytes_and_display_name() {
+        let executor = gpui_platform::background_executor();
+        for bytes in [b"# notes\n".to_vec(), Vec::new()] {
+            let engine = EngineHandle::from_test_client(zeron_rpc::memory_client(Arc::new(
+                FileRpc(bytes.clone()),
+            )));
+            let file = read_attachment_file(&engine, &executor, None, "/uploads/ab12cd34-notes.md")
+                .await
+                .unwrap();
+            assert_eq!(file.name, "notes.md");
+            assert_eq!(file.bytes(), bytes);
+            assert!(file.image().is_none());
+            // An image read-back never accepts an empty body.
+            if bytes.is_empty() {
+                let image = read_attachment_image(
+                    &engine,
+                    &executor,
+                    None,
+                    "/uploads/ab12cd34-notes.md",
+                    None,
+                )
+                .await;
+                assert!(image.is_none());
+            }
+        }
+    }
+
     #[tokio::test]
     async fn generated_image_chunk_reader_targets_owner_and_bounds_decode() {
         let executor = gpui_platform::background_executor();
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 2230935e32..d0e173aac0 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -41,6 +41,11 @@ use crate::settings::{ComposerSendBehavior, platform_combo};
 use crate::state::{AppState, Indicator};
 use crate::theme::Theme;
 
+mod chip;
+pub use chip::ChipKind;
+use chip::*;
+pub(crate) use chip::{ChipIcon, chip_icon, chip_text, paint_chip};
+
 // ---------------------------------------------------------------------------
 // Constants + pure decision logic
 // ---------------------------------------------------------------------------
@@ -490,6 +495,25 @@ pub enum SendButtonMode {
     Stop,
 }
 
+/// Per-chat bookkeeping for attachment chips. Numbers only grow within a draft,
+/// so a removed attachment never renumbers or retargets an earlier mention.
+#[derive(Default)]
+struct AttachmentDraft {
+    /// The highest number handed out so far.
+    next: u32,
+    /// Attachments whose last chip or tile was removed. Undo that brings their
+    /// chip back restages the attachment from here.
+    unstaged: Vec<StagedAttachment>,
+}
+
+/// A staged attachment offered by the `@` list.
+struct AttachmentRow {
+    index: u32,
+    label: String,
+    /// The picture, for an image.
+    image: Option<std::sync::Arc<gpui::Image>>,
+}
+
 /// What the composer holds that a send could carry. A staged image or diff
 /// comment counts: both synthesize their own prompt body, so either alone is
 /// a legal send — and during a live run has to read as Queue, not Stop.
@@ -884,8 +908,24 @@ struct FileMentionLink {
     range: Range<usize>,
     basename: String,
     path: String,
-    is_dir: bool,
-    prefix: char,
+    kind: ChipKind,
+    /// The draft number when this chip references a staged attachment.
+    attachment: Option<u32>,
+}
+
+impl FileMentionLink {
+    /// The character that marks this kind of reference.
+    fn prefix(&self) -> char {
+        match self.kind {
+            ChipKind::Skill => '$',
+            ChipKind::Command => '/',
+            _ => '@',
+        }
+    }
+
+    fn is_dir(&self) -> bool {
+        self.kind == ChipKind::Directory
+    }
 }
 
 /// Build the text inserted when a workspace item is dropped at an arbitrary
@@ -902,16 +942,10 @@ fn reference_suffix(next: Option<char>) -> (&'static str, usize) {
     }
 }
 
-fn dropped_file_mention(
-    content: &str,
-    range: Range<usize>,
-    path: &str,
-    is_dir: bool,
-) -> Option<(String, usize)> {
-    if range.start > range.end
-        || !local_path_is_safe(path)
-        || !content.is_char_boundary(range.start)
-    {
+/// Place a reference link at an arbitrary selection, supplying the separators
+/// a completion would already have had around it.
+fn dropped_reference(content: &str, range: Range<usize>, link: &str) -> Option<(String, usize)> {
+    if range.start > range.end || !content.is_char_boundary(range.start) {
         return None;
     }
     let suffix = content.get(range.end..)?;
@@ -927,7 +961,7 @@ fn dropped_file_mention(
         ""
     };
     let (trailing, advance) = reference_suffix(suffix.chars().next());
-    let inserted = format!("{prefix}{}{trailing}", local_file_link(path, is_dir));
+    let inserted = format!("{prefix}{link}{trailing}");
     let cursor_advance = inserted.len() + advance;
     Some((inserted, cursor_advance))
 }
@@ -939,8 +973,12 @@ fn file_mention_links(text: &str) -> Vec<FileMentionLink> {
             range: link.range,
             basename: link.basename,
             path: link.path,
-            is_dir: link.is_dir,
-            prefix: '@',
+            kind: if link.is_dir {
+                ChipKind::Directory
+            } else {
+                ChipKind::File
+            },
+            attachment: None,
         })
         .collect()
 }
@@ -958,6 +996,9 @@ struct TextProjection {
 struct MentionTooltipTarget {
     range: Range<usize>,
     path: SharedString,
+    /// Set for attachment chips. An image chip has no tooltip: a click opens
+    /// the picture full size instead.
+    attachment: Option<u32>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1166,14 +1207,21 @@ fn wrap_reference_chips(line: &mut WrappedLine, chips: &[Range<usize>], width: P
 
 impl TextProjection {
     fn new(raw: &str) -> Self {
-        Self::project(raw, None, false)
+        Self::project(raw, None, false, None)
     }
 
-    fn rich(raw: &str, active: Option<Range<usize>>) -> Self {
-        Self::project(raw, active, true)
+    /// `live` names the attachments the draft still holds; a chip outside it is
+    /// a dangling reference and shows as its plain label.
+    fn rich(raw: &str, active: Option<Range<usize>>, live: Option<&HashSet<u32>>) -> Self {
+        Self::project(raw, active, true, live)
     }
 
-    fn project(raw: &str, active: Option<Range<usize>>, compact: bool) -> Self {
+    fn project(
+        raw: &str,
+        active: Option<Range<usize>>,
+        compact: bool,
+        live: Option<&HashSet<u32>>,
+    ) -> Self {
         let mut links = file_mention_links(raw);
         links.extend(
             zeron_proto::invocation::invocation_links(raw)
@@ -1186,8 +1234,33 @@ impl TextProjection {
                         invocation.name().to_string()
                     },
                     path: invocation.detail(),
-                    is_dir: false,
-                    prefix: invocation.prefix(),
+                    kind: if invocation.prefix() == '/' {
+                        ChipKind::Command
+                    } else {
+                        ChipKind::Skill
+                    },
+                    attachment: None,
+                }),
+        );
+        links.extend(
+            zeron_proto::attachment_mentions::attachment_mentions(raw)
+                .into_iter()
+                .map(|mention| FileMentionLink {
+                    range: mention.range,
+                    // A file attachment's chip names the file, so its icon
+                    // follows the name; an image has no path to follow.
+                    path: if mention.is_image {
+                        String::new()
+                    } else {
+                        mention.label.clone()
+                    },
+                    basename: mention.label,
+                    kind: if mention.is_image {
+                        ChipKind::Image
+                    } else {
+                        ChipKind::File
+                    },
+                    attachment: Some(mention.index),
                 }),
         );
         links.sort_by_key(|link| link.range.start);
@@ -1203,13 +1276,14 @@ impl TextProjection {
             .zip(labels)
             .map(|(link, label)| {
                 let label = label.replace(' ', "\u{00A0}");
-                let marker = link.prefix;
+                if let (Some(index), Some(live)) = (link.attachment, live)
+                    && !live.contains(&index)
+                {
+                    return (link.range.clone(), link.basename.clone(), None);
+                }
                 let pad = MENTION_SIDE_PAD;
-                (
-                    link.range.clone(),
-                    format!("{pad}{marker}{label}{pad}"),
-                    Some(link),
-                )
+                let display = format!("{pad}{CHIP_ICON_SLOT}{label}{CHIP_TRAILING_PAD}");
+                (link.range.clone(), display, Some(link))
             })
             .collect();
         if let Some(active) = active {
@@ -1327,7 +1401,7 @@ fn mention_display_labels(links: &[FileMentionLink]) -> Vec<String> {
     let mut groups: HashMap<(char, &str), Vec<&FileMentionLink>> = HashMap::new();
     for link in links {
         groups
-            .entry((link.prefix, &link.basename))
+            .entry((link.prefix(), &link.basename))
             .or_default()
             .push(link);
     }
@@ -1336,9 +1410,9 @@ fn mention_display_labels(links: &[FileMentionLink]) -> Vec<String> {
         .iter()
         .map(|link| {
             labels
-                .entry((link.prefix, &link.basename, &link.path))
+                .entry((link.prefix(), &link.basename, &link.path))
                 .or_insert_with(|| {
-                    let duplicates: Vec<_> = groups[&(link.prefix, link.basename.as_str())]
+                    let duplicates: Vec<_> = groups[&(link.prefix(), link.basename.as_str())]
                         .iter()
                         .filter(|other| other.path != link.path)
                         .collect();
@@ -1349,7 +1423,7 @@ fn mention_display_labels(links: &[FileMentionLink]) -> Vec<String> {
                     let suffix = (1..=parts.len())
                         .map(|count| parts[parts.len() - count..].join("/"))
                         .find(|suffix| {
-                            if link.prefix != '@' {
+                            if link.prefix() != '@' {
                                 duplicates.iter().all(|other| !other.path.ends_with(suffix))
                             } else {
                                 let suffix: Vec<_> = suffix.split('/').collect();
@@ -1364,7 +1438,7 @@ fn mention_display_labels(links: &[FileMentionLink]) -> Vec<String> {
                             }
                         })
                         .unwrap_or_else(|| link.path.clone());
-                    if link.prefix == '@' {
+                    if link.prefix() == '@' {
                         suffix
                     } else {
                         format!("{} · {suffix}", link.basename)
@@ -1383,7 +1457,19 @@ pub struct SentMentionSpan {
     pub range: Range<usize>,
     /// Full workspace-relative path (labels can be shortened to basenames).
     pub path: SharedString,
-    pub is_dir: bool,
+    pub kind: ChipKind,
+    /// The draft number of an attachment chip.
+    pub attachment: Option<u32>,
+    /// The upload an attachment chip names, once the transcript pairs them.
+    pub upload: Option<SharedString>,
+}
+
+/// Cheap probe: whether `raw` could hold a file, skill or attachment chip.
+fn has_mention_scheme(raw: &str) -> bool {
+    raw.contains(FILE_MENTION_SCHEME)
+        || raw.contains(zeron_proto::invocation::INVOCATION_SCHEME)
+        || raw.contains(zeron_proto::attachment_mentions::IMAGE_MENTION_SCHEME)
+        || raw.contains(zeron_proto::attachment_mentions::ATTACHMENT_MENTION_SCHEME)
 }
 
 /// Project a sent message's raw Markdown for transcript display: mention links
@@ -1392,9 +1478,7 @@ pub struct SentMentionSpan {
 /// substring probe keeps ordinary prompts on the zero-allocation path, so this
 /// is safe to call for every user row.
 pub fn sent_mention_display(raw: &str) -> Option<(String, Vec<SentMentionSpan>)> {
-    if !raw.contains(FILE_MENTION_SCHEME)
-        && !raw.contains(zeron_proto::invocation::INVOCATION_SCHEME)
-    {
+    if !has_mention_scheme(raw) {
         return None;
     }
     let projection = TextProjection::new(raw);
@@ -1409,9 +1493,11 @@ pub fn sent_mention_display(raw: &str) -> Option<(String, Vec<SentMentionSpan>)>
             path: SharedString::from(format!(
                 "{}{}",
                 link.path,
-                if link.is_dir { "/" } else { "" }
+                if link.is_dir() { "/" } else { "" }
             )),
-            is_dir: link.is_dir,
+            kind: link.kind,
+            attachment: link.attachment,
+            upload: None,
         })
         .collect();
     Some((projection.display, spans))
@@ -1696,6 +1782,8 @@ pub enum ComposerInputEvent {
         range: Range<usize>,
         revision: u64,
     },
+    /// An image chip was clicked: open its picture full size.
+    OpenAttachment(u32),
 }
 
 #[derive(Clone)]
@@ -1921,6 +2009,15 @@ pub struct ComposerInput {
     /// Last prepainted chip bounds; the paint-phase pointer listener uses
     /// these instead of attempting to infer text geometry from the cursor.
     mention_hits: Vec<MentionHit>,
+    /// The image chip a click started on, and where.
+    chip_press: Option<(u32, Point<Pixels>)>,
+    /// The attachments the draft holds, by chip number, with each image's
+    /// picture. `None` outside the composer, where every attachment link is
+    /// shown as a chip.
+    attachment_chips: Option<HashMap<u32, ChipAttachment>>,
+    /// The draft the attachment chips belong to; copied chips carry it so a paste
+    /// into another draft can tell it must not reuse their numbers.
+    attachment_scope: String,
     mention_tooltip: MentionTooltipPhase,
     mention_tooltip_generation: u64,
     mention_tooltip_popup: Option<Bounds<Pixels>>,
@@ -2006,6 +2103,9 @@ impl ComposerInput {
             mention_open: false,
             mention_has_selection: false,
             mention_hits: Vec::new(),
+            chip_press: None,
+            attachment_chips: None,
+            attachment_scope: String::new(),
             mention_tooltip: MentionTooltipPhase::Hidden,
             mention_tooltip_generation: 0,
             mention_tooltip_popup: None,
@@ -2108,7 +2208,15 @@ impl ComposerInput {
 
     fn refresh_projection(&mut self) {
         self.projection = if self.mentions_enabled {
-            TextProjection::rich(&self.content, Some(self.editing_source_range()))
+            let live: Option<HashSet<u32>> = self
+                .attachment_chips
+                .as_ref()
+                .map(|images| images.keys().copied().collect());
+            TextProjection::rich(
+                &self.content,
+                Some(self.editing_source_range()),
+                live.as_ref(),
+            )
         } else {
             TextProjection {
                 display: self.content.clone(),
@@ -2126,13 +2234,25 @@ impl ComposerInput {
         is_dir: bool,
         cx: &mut Context<Self>,
     ) {
-        if self.read_only || self.marked_range.is_some() || !local_path_is_safe(path) {
+        if !local_path_is_safe(path) {
+            return;
+        }
+        self.replace_mention_link(range, &local_file_link(path, is_dir), cx);
+    }
+
+    /// Replace a completed `@query` token with a canonical reference link.
+    pub(crate) fn replace_mention_link(
+        &mut self,
+        range: Range<usize>,
+        link: &str,
+        cx: &mut Context<Self>,
+    ) {
+        if self.read_only || self.marked_range.is_some() {
             return;
         }
         self.invalidate_mention_tooltip();
-        let path = local_file_link(path, is_dir);
         let (trailing, advance) = reference_suffix(self.content[range.end..].chars().next());
-        let inserted = format!("{path}{trailing}");
+        let inserted = format!("{link}{trailing}");
         self.record_edit(&range, &inserted);
         self.edit_revision = self.edit_revision.wrapping_add(1);
         self.content =
@@ -2154,6 +2274,94 @@ impl ComposerInput {
     /// uses the same strict local Markdown transport and projected chip as an
     /// `@` mention selected from completion.
     fn insert_dropped_mention(&mut self, path: &str, is_dir: bool, cx: &mut Context<Self>) -> bool {
+        if !local_path_is_safe(path) {
+            return false;
+        }
+        self.insert_reference(&local_file_link(path, is_dir), cx)
+    }
+
+    /// Delete every chip that mentions attachment `index`, along with one separator
+    /// when the chip sat between spaces. Returns whether anything was removed.
+    pub(crate) fn remove_attachment_chips(&mut self, index: u32, cx: &mut Context<Self>) -> bool {
+        if self.read_only || self.marked_range.is_some() {
+            return false;
+        }
+        let ranges: Vec<Range<usize>> =
+            zeron_proto::attachment_mentions::attachment_mentions(&self.content)
+                .into_iter()
+                .filter(|mention| mention.index == index)
+                .map(|mention| mention.range)
+                .collect();
+        if ranges.is_empty() {
+            return false;
+        }
+        self.invalidate_mention_tooltip();
+        for mut range in ranges.into_iter().rev() {
+            let separated =
+                range.start == 0 || self.content[..range.start].ends_with(char::is_whitespace);
+            if separated && self.content[range.end..].starts_with(' ') {
+                range.end += 1;
+            }
+            self.record_edit(&range, "");
+            self.edit_revision = self.edit_revision.wrapping_add(1);
+            self.content.replace_range(range.clone(), "");
+            let shift = |offset: usize| {
+                if offset >= range.end {
+                    offset - range.len()
+                } else {
+                    offset.min(range.start)
+                }
+            };
+            self.selected_range = shift(self.selected_range.start)..shift(self.selected_range.end);
+        }
+        self.last_edit = None;
+        self.selection_reversed = false;
+        self.preferred_column = None;
+        self.refresh_projection();
+        self.reset_blink();
+        self.needs_measure = true;
+        cx.emit(ComposerInputEvent::Edited);
+        cx.notify();
+        true
+    }
+
+    /// Tell the editor which staged attachments its chips may reference (`None`
+    /// for one that is not an image). Chips for any other number show as plain
+    /// text.
+    pub(crate) fn set_attachment_chips(
+        &mut self,
+        scope: &str,
+        attachments: HashMap<u32, Option<std::sync::Arc<gpui::Image>>>,
+        cx: &mut Context<Self>,
+    ) {
+        let unchanged = self.attachment_scope == scope
+            && self.attachment_chips.as_ref().is_some_and(|current| {
+                current.len() == attachments.len()
+                    && attachments.iter().all(|(index, image)| {
+                        current.get(index).is_some_and(|known| {
+                            known.image.as_ref().map(std::sync::Arc::as_ptr)
+                                == image.as_ref().map(std::sync::Arc::as_ptr)
+                        })
+                    })
+            });
+        if unchanged {
+            return;
+        }
+        self.attachment_scope = scope.to_string();
+        self.attachment_chips = Some(
+            attachments
+                .into_iter()
+                .map(|(index, image)| (index, ChipAttachment { image }))
+                .collect(),
+        );
+        self.invalidate_mention_tooltip();
+        self.refresh_projection();
+        self.needs_measure = true;
+        cx.notify();
+    }
+
+    /// Insert a canonical reference link at the selection, as one undo step.
+    pub(crate) fn insert_reference(&mut self, link: &str, cx: &mut Context<Self>) -> bool {
         // The platform still owns the marked range during IME composition.
         // Inserting a chip into it would leave those offsets pointing inside
         // the new reference, and the next IME update could delete the chip.
@@ -2162,7 +2370,7 @@ impl ComposerInput {
         }
         let range = self.selected_range.clone();
         let Some((inserted, cursor_advance)) =
-            dropped_file_mention(&self.content, range.clone(), path, is_dir)
+            dropped_reference(&self.content, range.clone(), link)
         else {
             return false;
         };
@@ -2360,6 +2568,22 @@ impl ComposerInput {
         }));
     }
 
+    fn is_image_chip(&self, target: &MentionTooltipTarget) -> bool {
+        target
+            .attachment
+            .and_then(|index| self.attachment_chips.as_ref()?.get(&index))
+            .is_some_and(|chip| chip.image.is_some())
+    }
+
+    /// The number of the image chip under `position`, if any.
+    fn image_chip_at(&self, position: Point<Pixels>) -> Option<u32> {
+        self.mention_hits
+            .iter()
+            .find(|hit| hit.bounds.contains(&position))
+            .filter(|hit| self.is_image_chip(&hit.target))
+            .and_then(|hit| hit.target.attachment)
+    }
+
     fn on_mention_pointer_move(&mut self, position: Point<Pixels>, cx: &mut Context<Self>) {
         if self.is_selecting {
             self.invalidate_mention_tooltip();
@@ -2369,6 +2593,7 @@ impl ComposerInput {
             .mention_hits
             .iter()
             .find(|hit| hit.bounds.contains(&position))
+            .filter(|hit| !self.is_image_chip(&hit.target))
             .map(|hit| hit.target.clone());
         let in_popup = self
             .mention_tooltip_popup
@@ -3159,7 +3384,11 @@ impl ComposerInput {
         if let Some((raw, text)) = self.clipboard_selection() {
             cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
                 text.clone(),
-                serde_json::json!({ "zeronComposerV1": raw, "text": text }),
+                serde_json::json!({
+                    "zeronComposerV1": raw,
+                    "text": text,
+                    "zeronAttachmentScope": self.attachment_scope,
+                }),
             ));
         } else if self.copies_transcript_selection
             && let Some(text) = crate::markdown::selection::selected_text()
@@ -3175,7 +3404,11 @@ impl ComposerInput {
         if let Some((raw, text)) = self.clipboard_selection() {
             cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
                 text.clone(),
-                serde_json::json!({ "zeronComposerV1": raw, "text": text }),
+                serde_json::json!({
+                    "zeronComposerV1": raw,
+                    "text": text,
+                    "zeronAttachmentScope": self.attachment_scope,
+                }),
             ));
 
             self.last_edit = None;
@@ -3221,7 +3454,19 @@ impl ComposerInput {
                 {
                     if value.get("text").and_then(|v| v.as_str()) == Some(text.as_str()) {
                         if let Some(raw) = value.get("zeronComposerV1").and_then(|v| v.as_str()) {
-                            text = raw.to_owned();
+                            // Chip numbers belong to one draft: chips copied from
+                            // another chat would name the wrong attachment, so
+                            // they paste as their plain labels instead.
+                            let from_this_draft = value
+                                .get("zeronAttachmentScope")
+                                .and_then(|v| v.as_str())
+                                .is_some_and(|scope| scope == self.attachment_scope);
+                            if from_this_draft
+                                || zeron_proto::attachment_mentions::attachment_mentions(raw)
+                                    .is_empty()
+                            {
+                                text = raw.to_owned();
+                            }
                         }
                     }
                 }
@@ -3613,6 +3858,10 @@ impl ComposerInput {
         self.invalidate_mention_tooltip();
         window.focus(&self.focus_handle, cx);
         let intent = press_intent(event.click_count, event.modifiers.shift);
+        self.chip_press = (intent == PressIntent::PlaceCaret)
+            .then(|| self.image_chip_at(event.position))
+            .flatten()
+            .map(|index| (index, event.position));
         self.is_selecting = true;
         self.drag_position = Some(event.position);
         self.drag_unit = None;
@@ -3692,7 +3941,15 @@ impl ComposerInput {
         }
     }
 
-    fn on_mouse_up(&mut self, _: &MouseUpEvent, _: &mut Window, _: &mut Context<Self>) {
+    fn on_mouse_up(&mut self, event: &MouseUpEvent, _: &mut Window, cx: &mut Context<Self>) {
+        // A click that starts and ends on an image chip opens the picture, as
+        // the thumbnails did; a drag across it only selects.
+        if let Some((index, down)) = self.chip_press.take()
+            && self.image_chip_at(event.position) == Some(index)
+            && (event.position - down).magnitude() <= 4.0
+        {
+            cx.emit(ComposerInputEvent::OpenAttachment(index));
+        }
         self.is_selecting = false;
         self.drag_position = None;
         self.drag_generation = self.drag_generation.wrapping_add(1);
@@ -3910,20 +4167,20 @@ impl ComposerInput {
         let font_size = style.font_size.to_pixels(window.rem_size());
         self.line_height = px(self.configured_line_height);
 
-        // Chips read as inline code: the markdown renderer's recipe (mono font
-        // + the spectrum's `code_text`) over the rounded `code_wash` beneath.
+        // Inline code: the markdown renderer's recipe (mono font + the
+        // spectrum's `code_text`) over the rounded `code_wash` beneath.
         let (chip_font, chip_color) = {
             let theme = Theme::of(cx);
             (gpui::font(theme.font_mono.clone()), theme.code_text)
         };
-        let run_for = |len: usize, underline: bool, chip: bool| TextRun {
+        let run_for = |len: usize, underline: bool, code: bool| TextRun {
             len,
-            font: if chip {
+            font: if code {
                 chip_font.clone()
             } else {
                 style.font()
             },
-            color: if chip { chip_color } else { style.color },
+            color: if code { chip_color } else { style.color },
             // Rounded mention washes are painted explicitly beneath the text;
             // TextRun backgrounds are square and can disappear in wrapped runs.
             background_color: None,
@@ -4020,7 +4277,7 @@ impl ComposerInput {
                 let mut run = run_for(
                     r[1] - r[0],
                     marked.as_ref().is_some_and(|range| range.contains(&r[0])),
-                    chip || code,
+                    code,
                 );
                 if !chip {
                     if face_depth[composer_markdown::Face::Bold as usize] > 0 {
@@ -4457,22 +4714,23 @@ struct MentionPathTooltip {
 impl Render for MentionPathTooltip {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let theme = Theme::of(cx).for_popup();
+        let card = crate::popover::popover_card(&theme)
+            .max_w(px(480.0))
+            .h(px(MENTION_TOOLTIP_HEIGHT))
+            .flex()
+            .items_center()
+            .p_0()
+            .px(px(8.0))
+            .font_family(theme.font_mono.clone())
+            .text_size(px(11.0))
+            .text_color(theme.text_muted)
+            .child(div().min_w_0().truncate().child(self.path.clone()));
         motion::fade_quick(
             ("file-mention-path-tooltip", self.activation),
             div().child(crate::frost::frosted(
                 crate::popover::CARD_RADIUS,
                 crate::frost::MENU_BLUR,
-                crate::popover::popover_card(&theme)
-                    .h(px(MENTION_TOOLTIP_HEIGHT))
-                    .max_w(px(480.0))
-                    .flex()
-                    .items_center()
-                    .p_0()
-                    .px(px(8.0))
-                    .font_family(theme.font_mono.clone())
-                    .text_size(px(11.0))
-                    .text_color(theme.text_muted)
-                    .child(div().min_w_0().truncate().child(self.path.clone())),
+                card,
             )),
         )
     }
@@ -4480,8 +4738,11 @@ impl Render for MentionPathTooltip {
 
 struct ComposerTextPrepaint {
     cursor: Option<PaintQuad>,
-    mention_quads: Vec<PaintQuad>,
+    /// Each chip row's bounds; the first row of a chip also carries its icon.
+    mention_chips: Vec<(Bounds<Pixels>, Option<ChipIcon>)>,
     mention_hits: Vec<MentionHit>,
+    /// Image chips take the pointing hand: a click opens them.
+    image_chip_hitboxes: Vec<gpui::Hitbox>,
     selection_quads: Vec<PaintQuad>,
     /// Completion preview: window-space origin of the end-of-text caret plus
     /// the suffix to paint there (shaped at paint time — it never joins the
@@ -4564,37 +4825,43 @@ impl gpui::Element for ComposerTextElement {
         let origin = point(bounds.left() - px(input.scroll_left), bounds.top() - scroll);
         let selection_color = Theme::of(cx).selection;
         let caret_color = Theme::of(cx).caret;
-        // The inline-code recipe: chips use the spectrum wash like `code` spans.
-        let mention_color = Theme::of(cx).code_wash;
 
-        let mut mention_quads = Vec::new();
+        let mut mention_chips = Vec::new();
+        let appearance = Theme::of(cx).appearance;
         let mut mention_hits = Vec::new();
         for (mention, display) in &input.projection.mentions {
+            let mut first_row = true;
             let target = MentionTooltipTarget {
                 range: mention.range.clone(),
-                path: SharedString::from(format!(
-                    "{}{}",
-                    mention.path,
-                    if mention.is_dir { "/" } else { "" }
-                )),
+                path: if mention.attachment.is_some() {
+                    SharedString::from(mention.basename.clone())
+                } else {
+                    SharedString::from(format!(
+                        "{}{}",
+                        mention.path,
+                        if mention.is_dir() { "/" } else { "" }
+                    ))
+                },
+                attachment: mention.attachment,
             };
+            // The path tooltip stays flush so the pointer can move onto it.
+            let (tooltip_height, tooltip_gap) = (MENTION_TOOLTIP_HEIGHT, 1.0);
             for local_bounds in input.bounds_for_display_range(display.clone()) {
                 let chip_bounds = Bounds::new(
                     point(
                         origin.x + local_bounds.origin.x,
-                        origin.y + local_bounds.origin.y + px(2.0),
+                        // Centered on the row, which centers the label (see
+                        // `paint_chip`).
+                        origin.y + local_bounds.origin.y + px(1.5),
                     ),
-                    size(local_bounds.size.width, local_bounds.size.height - px(4.0)),
+                    size(local_bounds.size.width, local_bounds.size.height - px(3.0)),
                 );
-                mention_quads.push(quad(
+                mention_chips.push((
                     chip_bounds,
-                    px(5.0),
-                    mention_color,
-                    px(0.0),
-                    gpui::transparent_black(),
-                    BorderStyle::default(),
+                    first_row.then(|| chip_icon(mention.kind, &mention.path, appearance)),
                 ));
-                let above_anchor = chip_bounds.top() - px(MENTION_TOOLTIP_HEIGHT) - px(1.0);
+                first_row = false;
+                let above_anchor = chip_bounds.top() - px(tooltip_height) - px(tooltip_gap);
                 let anchor_y = if above_anchor >= px(0.0) {
                     above_anchor
                 } else {
@@ -4707,10 +4974,16 @@ impl gpui::Element for ComposerTextElement {
                     .point_for_index(input.content.len())
                     .map(|p| (point(origin.x + p.x, origin.y + p.y), g))
             });
+        let image_chip_hitboxes = mention_hits
+            .iter()
+            .filter(|hit| input.is_image_chip(&hit.target))
+            .map(|hit| window.insert_hitbox(hit.bounds, gpui::HitboxBehavior::Normal))
+            .collect();
         ComposerTextPrepaint {
             cursor,
-            mention_quads,
+            mention_chips,
             mention_hits,
+            image_chip_hitboxes,
             selection_quads,
             ghost,
         }
@@ -4741,6 +5014,9 @@ impl gpui::Element for ComposerTextElement {
                 input.update(cx, |input, cx| input.on_mouse_move(event, cx));
             }
         });
+        for hitbox in &prepaint.image_chip_hitboxes {
+            window.set_cursor_style(CursorStyle::PointingHand, hitbox);
+        }
 
         // WrappedLine isn't Clone — temporarily take the shaped lines out of the
         // entity for painting, then put them back for mouse mapping.
@@ -4761,8 +5037,9 @@ impl gpui::Element for ComposerTextElement {
                 bounds: paint_bounds,
             }),
             |window| {
-                for quad in prepaint.mention_quads.drain(..) {
-                    window.paint_quad(quad);
+                let theme = Theme::of(cx).clone();
+                for (chip, icon) in prepaint.mention_chips.drain(..) {
+                    paint_chip(window, chip, icon.as_ref(), &theme, cx);
                 }
                 for quad in prepaint.selection_quads.drain(..) {
                     window.paint_quad(quad);
@@ -5624,6 +5901,10 @@ pub struct Composer {
     pub(crate) input: Entity<ComposerInput>,
     /// Draft displaced while a queued message occupies the composer.
     pub(crate) queue_edit_draft: Option<(String, Vec<StagedAttachment>, Vec<CapturedAppshot>)>,
+    /// The displaced draft's chip numbering and undo stash. The queued
+    /// message gets its own while it is edited, so its chips can never name
+    /// the draft's attachments.
+    queue_edit_attachment_draft: Option<AttachmentDraft>,
     /// Composer actions row plus the new-session floating target tab
     /// ([`Pickers::render_new_thread_target_selectors`]).
     pickers: Entity<Pickers>,
@@ -5632,6 +5913,7 @@ pub struct Composer {
     /// Staged-but-unsent attachments per chat key (use-attachments.ts `stash`):
     /// navigating away and back restores them; memory-only, like the original.
     pub(crate) attachments: HashMap<String, Vec<StagedAttachment>>,
+    attachment_drafts: HashMap<String, AttachmentDraft>,
     /// Rich window captures keyed exactly like drafts and ordinary staged
     /// attachments. Each owns one screenshot that joins the existing upload
     /// path only at send time.
@@ -5904,6 +6186,7 @@ impl Composer {
                     this.dismiss_mention(cx)
                 }
             }
+            ComposerInputEvent::OpenAttachment(index) => this.open_attachment(*index, cx),
             ComposerInputEvent::PastedImages(images) => {
                 let images = images.clone();
                 this.stage_in_background(
@@ -5950,9 +6233,11 @@ impl Composer {
             state,
             input,
             queue_edit_draft: None,
+            queue_edit_attachment_draft: None,
             pickers,
             drafts: HashMap::new(),
             attachments: HashMap::new(),
+            attachment_drafts: HashMap::new(),
             appshots: HashMap::new(),
             appshot_entrances: HashMap::new(),
             preview: None,
@@ -6055,18 +6340,14 @@ impl Composer {
             if std::env::var("ZERON_ATTACH_PREVIEW").is_ok_and(|v| v == "1")
                 && let Some(first) = staged.first()
             {
-                composer.preview = Some(attachments::PreviewImage::new(
-                    first.name.clone(),
-                    first.image.clone(),
-                ));
+                composer.preview = first
+                    .image()
+                    .map(|image| attachments::PreviewImage::new(first.name.clone(), image.clone()));
                 composer.preview_focus_pending = true;
             }
             if !staged.is_empty() {
-                composer
-                    .attachments
-                    .entry(composer.current_key.clone())
-                    .or_default()
-                    .extend(staged);
+                let key = composer.current_key.clone();
+                composer.adopt_staged_attachments(key, staged, cx);
             }
         }
         composer
@@ -6097,6 +6378,24 @@ impl Composer {
             .unwrap_or(&[])
     }
 
+    /// Staged attachments that get a tile above the input. One the draft
+    /// mentions as a chip is already on screen there (hover previews it,
+    /// deleting it unstages it), so only attachments without a chip are tiled.
+    fn tiled_attachments<'a>(&'a self, cx: &App) -> Vec<&'a StagedAttachment> {
+        let chipped: Vec<u32> = self
+            .input
+            .read(cx)
+            .projection
+            .mentions
+            .iter()
+            .filter_map(|(link, _)| link.attachment)
+            .collect();
+        self.staged()
+            .iter()
+            .filter(|att| att.mention.is_none_or(|index| !chipped.contains(&index)))
+            .collect()
+    }
+
     pub(crate) fn queue_preview_limit(&self) -> usize {
         if self.last_available_width.unwrap_or(COMPOSER_MAX_WIDTH) < 520.0 {
             1
@@ -6105,6 +6404,23 @@ impl Composer {
         }
     }
 
+    /// Open a staged image full size, from its chip (the tiles' click).
+    fn open_attachment(&mut self, index: u32, cx: &mut Context<Self>) {
+        let Some((name, image)) = self
+            .staged()
+            .iter()
+            .filter(|att| att.mention == Some(index))
+            .find_map(|att| Some((att.name.clone(), att.image()?.clone())))
+        else {
+            return;
+        };
+        let preview = attachments::PreviewImage::new(name, image);
+        preview.viewer.reset();
+        self.preview = Some(preview);
+        self.preview_focus_pending = true;
+        cx.notify();
+    }
+
     pub(crate) fn show_queue_image(
         &mut self,
         preview: attachments::PreviewImage,
@@ -6211,6 +6527,16 @@ impl Composer {
         self.failure.as_ref()
     }
 
+    /// The failure notice this draft renders. Chat-scoped failures render
+    /// only under their own chat; a global failure (no key) renders everywhere.
+    pub(crate) fn visible_failure(&self) -> Option<SharedString> {
+        self.failure.clone().filter(|_| {
+            self.failure_key
+                .as_ref()
+                .is_none_or(|key| *key == self.current_key)
+        })
+    }
+
     /// Show a dismissable failure chip for the current draft's session.
     pub(crate) fn show_error(&mut self, message: impl Into<SharedString>, cx: &mut Context<Self>) {
         self.failure = Some(message.into());
@@ -6221,7 +6547,8 @@ impl Composer {
     /// Run `stage` on the background executor — reading a file and converting
     /// a BMP are too slow for the UI thread — and add what it staged to the
     /// draft that is current now, even if the user has navigated away by the
-    /// time it finishes. Failures surface in that draft's failure notice.
+    /// time it finishes. Failures surface in that draft's failure notice, all
+    /// of them together so one refused file does not hide another.
     fn stage_in_background(
         &mut self,
         stage: impl FnOnce() -> Vec<Result<StagedAttachment, String>> + Send + 'static,
@@ -6232,17 +6559,19 @@ impl Composer {
             let results = cx.background_executor().spawn(async move { stage() }).await;
             this.update(cx, |this, cx| {
                 let mut staged = Vec::new();
+                let mut refused = Vec::new();
                 for result in results {
                     match result {
                         Ok(att) => staged.push(att),
-                        Err(message) => {
-                            this.failure = Some(message.into());
-                            this.failure_key = Some(key.clone());
-                        }
+                        Err(message) => refused.push(message),
                     }
                 }
+                if !refused.is_empty() {
+                    this.failure = Some(refused.join(" ").into());
+                    this.failure_key = Some(key.clone());
+                }
                 if !staged.is_empty() && !this.queue_edit_finishing {
-                    this.attachments.entry(key).or_default().extend(staged);
+                    this.adopt_staged_attachments(key, staged, cx);
                     this.focus_pending = true;
                 }
                 cx.notify();
@@ -6252,15 +6581,14 @@ impl Composer {
         .detach();
     }
 
-    /// Stage image files (picker / drop / pasted paths). Non-images are
-    /// skipped silently (matching the original's `image/*` filter); read
-    /// failures and oversize files surface in the failure notice.
+    /// Stage files (picker / drop / pasted paths): images with thumbnails, any
+    /// other file as opaque bytes. Folders, read failures and oversize files
+    /// surface in the failure notice.
     pub(crate) fn add_paths(&mut self, paths: Vec<PathBuf>, cx: &mut Context<Self>) {
         self.stage_in_background(
             move || {
                 paths
                     .iter()
-                    .filter(|path| attachments::format_by_extension(path).is_some())
                     .map(|path| attachments::stage_file(path))
                     .collect()
             },
@@ -6290,16 +6618,173 @@ impl Composer {
         }
     }
 
+    /// The next chip number for a draft: above everything it holds or
+    /// mentions, so a number is never reused.
+    fn next_attachment_index(&mut self, key: &str, text: &str) -> u32 {
+        let held = self
+            .attachments
+            .get(key)
+            .into_iter()
+            .flatten()
+            .filter_map(|att| att.mention)
+            .max();
+        let mentioned = zeron_proto::attachment_mentions::attachment_mention_indices(text)
+            .into_iter()
+            .max();
+        let draft = self.attachment_drafts.entry(key.to_string()).or_default();
+        draft.next = draft
+            .next
+            .max(held.unwrap_or(0))
+            .max(mentioned.unwrap_or(0))
+            + 1;
+        draft.next
+    }
+
+    /// Add newly staged files to a draft. Each is numbered and mentioned at the
+    /// caret as one edit: images read "Image 1", "Image 2", ...; other files
+    /// keep their name. A file the editor cannot take a chip for, or that was
+    /// staged for a draft the user has since left, stays a plain attachment.
+    fn adopt_staged_attachments(
+        &mut self,
+        key: String,
+        mut staged: Vec<StagedAttachment>,
+        cx: &mut Context<Self>,
+    ) {
+        if key != self.current_key {
+            self.attachments.entry(key).or_default().extend(staged);
+            return;
+        }
+        let text = self.input.read(cx).text().to_string();
+        let mut links = Vec::with_capacity(staged.len());
+        let mut indices = Vec::with_capacity(staged.len());
+        for att in &mut staged {
+            let index = self.next_attachment_index(&key, &text);
+            let file_name = match att.image() {
+                Some(image) => {
+                    att.name = attachments::ensure_extension(
+                        &zeron_proto::attachment_mentions::image_label(index),
+                        image.format,
+                    );
+                    None
+                }
+                None => Some(att.name.as_str()),
+            };
+            links.push(zeron_proto::attachment_mentions::attachment_mention_link(
+                index, file_name,
+            ));
+            indices.push(index);
+        }
+        // Chips are inserted before the attachments join the draft, so a
+        // draft that cannot take them (read-only, composing) keeps the files
+        // and their original names.
+        let mentioned = self
+            .input
+            .update(cx, |input, cx| input.insert_reference(&links.join(" "), cx));
+        if mentioned {
+            for (att, index) in staged.iter_mut().zip(indices) {
+                att.mention = Some(index);
+            }
+        }
+        self.attachments.entry(key).or_default().extend(staged);
+        self.sync_attachment_chips(cx);
+        cx.notify();
+    }
+
+    /// Hand the editor the attachments its chips may reference.
+    fn sync_attachment_chips(&mut self, cx: &mut Context<Self>) {
+        let attachments: HashMap<u32, Option<std::sync::Arc<gpui::Image>>> = self
+            .staged()
+            .iter()
+            .filter_map(|att| att.mention.map(|index| (index, att.image().cloned())))
+            .collect();
+        let scope = self.current_key.clone();
+        self.input.update(cx, |input, cx| {
+            input.set_attachment_chips(&scope, attachments, cx)
+        });
+    }
+
+    /// Keep staged attachments and their chips in step: one whose last chip is
+    /// gone leaves the draft (kept for undo), and one whose chip came back
+    /// returns. Attachments the prompt never mentions are left alone.
+    fn reconcile_attachment_mentions(&mut self, cx: &mut Context<Self>) {
+        if self.wizard.is_none() && !self.queue_edit_finishing {
+            let mentioned = zeron_proto::attachment_mentions::attachment_mention_indices(
+                self.input.read(cx).text(),
+            );
+            let is_mentioned =
+                |att: &StagedAttachment| att.mention.is_none_or(|index| mentioned.contains(&index));
+            let key = self.current_key.clone();
+            let draft = self.attachment_drafts.entry(key.clone()).or_default();
+            let (restored, mut stash): (Vec<_>, Vec<_>) = std::mem::take(&mut draft.unstaged)
+                .into_iter()
+                .partition(is_mentioned);
+            let (mut kept, dropped): (Vec<_>, Vec<_>) = self
+                .attachments
+                .remove(&key)
+                .unwrap_or_default()
+                .into_iter()
+                .partition(is_mentioned);
+            let changed = !restored.is_empty() || !dropped.is_empty();
+            kept.extend(restored);
+            kept.sort_by_key(|att| att.mention.unwrap_or(0));
+            stash.extend(dropped);
+            draft.unstaged = stash;
+            if !kept.is_empty() {
+                self.attachments.insert(key, kept);
+            }
+            if changed {
+                cx.notify();
+            }
+        }
+        self.sync_attachment_chips(cx);
+    }
+
+    /// Set the draft's chip numbering and undo stash aside while a queued
+    /// message occupies the composer.
+    pub(crate) fn displace_attachment_draft(&mut self) {
+        self.queue_edit_attachment_draft = Some(
+            self.attachment_drafts
+                .remove(&self.current_key)
+                .unwrap_or_default(),
+        );
+    }
+
+    /// Bring back what [`Self::displace_attachment_draft`] set aside; the
+    /// edit's own numbering and stash are dropped with it.
+    pub(crate) fn restore_attachment_draft(&mut self) {
+        if let Some(draft) = self.queue_edit_attachment_draft.take() {
+            self.attachment_drafts
+                .insert(self.current_key.clone(), draft);
+        }
+    }
+
     fn remove_attachment(&mut self, id: &str, cx: &mut Context<Self>) {
         if self.queue_edit_finishing {
             return;
         }
+        let mut mention = None;
         if let Some(list) = self.attachments.get_mut(&self.current_key) {
-            list.retain(|a| a.id != id);
+            if let Some(at) = list.iter().position(|a| a.id == id) {
+                let removed = list.remove(at);
+                if let Some(index) = removed.mention {
+                    mention = Some(index);
+                    // Undo of the chip removal below restages this image.
+                    self.attachment_drafts
+                        .entry(self.current_key.clone())
+                        .or_default()
+                        .unstaged
+                        .push(removed);
+                }
+            }
             if list.is_empty() {
                 self.attachments.remove(&self.current_key);
             }
         }
+        if let Some(index) = mention {
+            self.input
+                .update(cx, |input, cx| input.remove_attachment_chips(index, cx));
+        }
+        self.sync_attachment_chips(cx);
         cx.notify();
     }
 
@@ -6340,6 +6825,7 @@ impl Composer {
     /// raw image bytes, and a deleted chat's stage could never be sent again.
     pub fn purge_chat(&mut self, chat_id: &str, cx: &mut Context<Self>) {
         self.attachments.remove(chat_id);
+        self.attachment_drafts.remove(chat_id);
         self.appshots.remove(chat_id);
         self.state.update(cx, |state, _| {
             state.purge_review_comments(chat_id);
@@ -6381,9 +6867,10 @@ impl Composer {
 
     /// The staged-thumbnail strip (attachment-ui.tsx AttachmentStrip):
     /// `flex flex-wrap gap-2 px-4 pt-3`, 56px rounded thumbs, a remove button
-    /// revealed on hover, click opens the full-size preview.
+    /// revealed on hover, click opens the full-size preview. Attachments with
+    /// a chip in the draft are left out.
     fn render_attachment_strip(&self, theme: &Theme, cx: &mut Context<Self>) -> Option<gpui::Div> {
-        let staged = self.staged();
+        let staged = self.tiled_attachments(cx);
         if staged.is_empty() {
             return None;
         }
@@ -6398,7 +6885,6 @@ impl Composer {
             .pt(px(STRIP_PAD_TOP));
         for (ix, att) in staged.iter().enumerate() {
             let group: SharedString = format!("composer-att-{}", att.id).into();
-            let preview = attachments::PreviewImage::new(att.name.clone(), att.image.clone());
             let remove_id = att.id.clone();
             let remove_label: SharedString = format!("Remove {}", att.name).into();
             strip = strip.child(
@@ -6406,39 +6892,7 @@ impl Composer {
                     .group(group.clone())
                     .flex_none()
                     .relative()
-                    .child(
-                        div()
-                            .id(("composer-att-thumb", ix))
-                            .size(px(STRIP_THUMB))
-                            .rounded(px(8.0))
-                            .overflow_hidden()
-                            .border_1()
-                            .border_color(crate::theme::hairline(0.10))
-                            .cursor_pointer()
-                            .on_click(cx.listener(move |this, _, _, cx| {
-                                preview.viewer.reset();
-                                this.preview = Some(preview.clone());
-                                this.preview_focus_pending = true;
-                                cx.notify();
-                            }))
-                            .child(
-                                img(att.image.clone())
-                                    // EXPLICIT dims, not size_full: img layout
-                                    // honors the image's intrinsic aspect
-                                    // ratio over a percent height (gpui
-                                    // f8d8a90 repoint), so size_full let a
-                                    // tall photo grow past the frame — the
-                                    // rectangular overflow clip then squared
-                                    // the bottom corners (2026-08-19 report).
-                                    // 56−2 = frame minus its 1px borders.
-                                    .w(px(STRIP_THUMB - 2.0))
-                                    .h(px(STRIP_THUMB - 2.0))
-                                    // Own radii — the frame's rounding only
-                                    // clips rectangularly (7 = 8 - border).
-                                    .rounded(px(7.0))
-                                    .object_fit(ObjectFit::Cover),
-                            ),
-                    )
+                    .child(self.attachment_tile(att, ix, cx))
                     // Own layer: inside the frosted pill everything shares one
                     // draw order and images render last, so without it the
                     // thumbnail paints OVER this button (user report).
@@ -6480,6 +6934,75 @@ impl Composer {
         Some(strip)
     }
 
+    /// One staged attachment's tile: an image's thumbnail (a click opens the
+    /// full-size preview) or a file's icon and name.
+    fn attachment_tile(
+        &self,
+        att: &StagedAttachment,
+        ix: usize,
+        cx: &mut Context<Self>,
+    ) -> gpui::AnyElement {
+        let frame = div()
+            .id(("composer-att-thumb", ix))
+            .size(px(STRIP_THUMB))
+            .rounded(px(8.0))
+            .overflow_hidden()
+            .border_1()
+            .border_color(crate::theme::hairline(0.10));
+        let Some(image) = att.image() else {
+            let theme = Theme::of(cx);
+            return frame
+                .flex()
+                .flex_col()
+                .items_center()
+                .justify_center()
+                .gap(px(3.0))
+                .px(px(4.0))
+                .child(
+                    crate::file_icons::icon(
+                        crate::file_icons::FileIconIdentity::file(&att.name),
+                        theme.appearance,
+                    )
+                    .size(px(24.0)),
+                )
+                .child(
+                    div()
+                        .w_full()
+                        .truncate()
+                        .text_center()
+                        .text_size(px(10.0))
+                        .text_color(theme.text_muted)
+                        .child(SharedString::from(att.name.clone())),
+                )
+                .into_any_element();
+        };
+        let preview = attachments::PreviewImage::new(att.name.clone(), image.clone());
+        frame
+            .cursor_pointer()
+            .on_click(cx.listener(move |this, _, _, cx| {
+                preview.viewer.reset();
+                this.preview = Some(preview.clone());
+                this.preview_focus_pending = true;
+                cx.notify();
+            }))
+            .child(
+                img(image.clone())
+                    // EXPLICIT dims, not size_full: img layout honors the
+                    // image's intrinsic aspect ratio over a percent height
+                    // (gpui f8d8a90 repoint), so size_full let a tall photo
+                    // grow past the frame — the rectangular overflow clip
+                    // then squared the bottom corners (2026-08-19 report).
+                    // 56−2 = frame minus its 1px borders.
+                    .w(px(STRIP_THUMB - 2.0))
+                    .h(px(STRIP_THUMB - 2.0))
+                    // Own radii — the frame's rounding only clips
+                    // rectangularly (7 = 8 - border).
+                    .rounded(px(7.0))
+                    .object_fit(ObjectFit::Cover),
+            )
+            .into_any_element()
+    }
+
     fn render_appshot_strip(
         &self,
         theme: &Theme,
@@ -6504,10 +7027,13 @@ impl Composer {
             - 2.0 * STRIP_PAD_X
             - 2.0 * APPSHOT_IMAGE_INSET;
         for (ix, appshot) in appshots.iter().enumerate() {
+            let Some(screenshot) = appshot.screenshot.image().cloned() else {
+                continue;
+            };
             let group: SharedString = format!("composer-appshot-{}", appshot.id).into();
             let preview = crate::attachments::PreviewImage::new(
                 appshot.screenshot.name.clone(),
-                appshot.screenshot.image.clone(),
+                screenshot.clone(),
             );
             let preview_on_key = preview.clone();
             let preview_on_a11y = preview.clone();
@@ -6606,7 +7132,7 @@ impl Composer {
                                     44.0,
                                     false,
                                     true,
-                                    img(appshot.screenshot.image.clone())
+                                    img(screenshot)
                                         .w(px(image_width))
                                         .h(px(image_height))
                                         .object_fit(ObjectFit::Contain),
@@ -6970,6 +7496,7 @@ impl Composer {
     }
 
     fn on_input_edited(&mut self, cx: &mut Context<Self>) {
+        self.reconcile_attachment_mentions(cx);
         if self.wizard.is_some() {
             if self.mention.token.is_some() || self.mention_task.is_some() {
                 self.reset_mention(None, cx);
@@ -7030,7 +7557,7 @@ impl Composer {
         self.mention.token = token.clone();
         if !refining {
             self.mention.results.clear();
-            self.mention.active = None;
+            self.mention.active = (!self.mention_attachment_matches().is_empty()).then_some(0);
             // Fresh open: the row stack restarts at the top.
             crate::popover::reset_menu_scroll(&self.mention_scroll, &mut self.popup_bar);
         }
@@ -7084,7 +7611,9 @@ impl Composer {
                             // that the canonical reference format cannot encode.
                             results.retain(|result| local_path_is_safe(&result.path));
                             composer.mention.error = None;
-                            composer.mention.active = (!results.is_empty()).then_some(0);
+                            composer.mention.active = (!results.is_empty()
+                                || !composer.mention_attachment_matches().is_empty())
+                            .then_some(0);
                             composer.mention.results = results;
                             // New result set: the row stack restarts at the top.
                             crate::popover::reset_menu_scroll(
@@ -7097,7 +7626,8 @@ impl Composer {
                     Err(err) => {
                         tracing::warn!(%err, "file mention search failed");
                         composer.mention.results.clear();
-                        composer.mention.active = None;
+                        composer.mention.active =
+                            (!composer.mention_attachment_matches().is_empty()).then_some(0);
                         composer.mention.error = Some(mention_error_message(&err));
                     }
                 }
@@ -7110,8 +7640,8 @@ impl Composer {
     }
 
     fn move_mention(&mut self, delta: isize, cx: &mut Context<Self>) {
-        self.mention.active =
-            crate::popover::menu_step(self.mention.active, self.mention.results.len(), delta);
+        let rows = self.mention_attachment_matches().len() + self.mention.results.len();
+        self.mention.active = crate::popover::menu_step(self.mention.active, rows, delta);
         if let Some(active) = self.mention.active {
             // Keep the keyboard cursor visible in the scrolled row stack.
             self.mention_scroll.scroll_to_item(active);
@@ -7132,21 +7662,65 @@ impl Composer {
         cx.notify();
     }
 
+    /// Staged attachments that match the typed `@` query, pinned above file
+    /// results. Matching ignores case and spaces, so `@im`, `@image2` and
+    /// `@2` all find "Image 2", and `@note` finds "notes.md".
+    fn mention_attachment_matches(&self) -> Vec<AttachmentRow> {
+        let Some(token) = self.mention.token.as_ref() else {
+            return Vec::new();
+        };
+        let normalize = |text: &str| -> String {
+            text.chars()
+                .filter(|c| !c.is_whitespace())
+                .flat_map(char::to_lowercase)
+                .collect()
+        };
+        let wanted = normalize(&token.query);
+        let mut rows: Vec<_> = self
+            .staged()
+            .iter()
+            .filter_map(|att| {
+                let index = att.mention?;
+                let label = if att.image().is_some() {
+                    zeron_proto::attachment_mentions::image_label(index)
+                } else {
+                    att.name.clone()
+                };
+                normalize(&label).contains(&wanted).then(|| AttachmentRow {
+                    index,
+                    label,
+                    image: att.image().cloned(),
+                })
+            })
+            .collect();
+        rows.sort_by_key(|row| row.index);
+        rows
+    }
+
     fn accept_mention(&mut self, cx: &mut Context<Self>) {
         let Some(token) = self.mention.token.clone() else {
             return;
         };
-        let Some((path, is_dir)) = self
-            .mention
-            .active
-            .and_then(|active| self.mention.results.get(active))
-            .map(|result| (result.path.clone(), result.is_dir))
-        else {
+        let rows = self.mention_attachment_matches();
+        let Some(active) = self.mention.active else {
             return;
         };
-        self.input.update(cx, |input, cx| {
-            input.replace_mention(token.range, &path, is_dir, cx)
-        });
+        if let Some(row) = rows.get(active) {
+            let link = zeron_proto::attachment_mentions::attachment_mention_link(
+                row.index,
+                row.image.is_none().then_some(row.label.as_str()),
+            );
+            self.input.update(cx, |input, cx| {
+                input.replace_mention_link(token.range, &link, cx)
+            });
+        } else if let Some(result) = self.mention.results.get(active - rows.len()) {
+            let (path, is_dir) = (result.path.clone(), result.is_dir);
+            self.input.update(cx, |input, cx| {
+                input.replace_mention(token.range, &path, is_dir, cx)
+            });
+        } else {
+            return;
+        }
         self.reset_mention(None, cx);
         cx.notify();
     }
@@ -7168,7 +7742,8 @@ impl Composer {
                 }),
             )
             .on_mouse_down_out(cx.listener(|this, _, _, cx| this.dismiss_mention(cx)));
-        if self.mention.loading && self.mention.results.is_empty() {
+        let attachment_rows = self.mention_attachment_matches();
+        if self.mention.loading && self.mention.results.is_empty() && attachment_rows.is_empty() {
             card = card.child(crate::popover::skeleton_rows(
                 "file-mention-loading",
                 theme,
@@ -7176,7 +7751,12 @@ impl Composer {
                 cx.entity_id(),
                 cx,
             ));
-        } else if let Some(error) = self.mention.error.clone() {
+        } else if let Some(error) = self
+            .mention
+            .error
+            .clone()
+            .filter(|_| attachment_rows.is_empty())
+        {
             card = card.child(
                 div()
                     .px(px(12.0))
@@ -7185,7 +7765,7 @@ impl Composer {
                     .text_color(theme.danger_muted)
                     .child(error),
             );
-        } else if self.mention.results.is_empty() {
+        } else if self.mention.results.is_empty() && attachment_rows.is_empty() {
             card = card.child(
                 div()
                     .px(px(12.0))
@@ -7199,8 +7779,53 @@ impl Composer {
                     }),
             );
         } else {
-            let mut rows: Vec<gpui::AnyElement> = Vec::with_capacity(self.mention.results.len());
-            for (ix, result) in self.mention.results.iter().enumerate() {
+            let mut rows: Vec<gpui::AnyElement> =
+                Vec::with_capacity(attachment_rows.len() + self.mention.results.len());
+            // Staged attachments stay pinned above every file result.
+            for (ix, row) in attachment_rows.iter().enumerate() {
+                let selected = self.mention.active == Some(ix);
+                let (icon, detail) = match &row.image {
+                    Some(image) => (
+                        img(image.clone())
+                            .size(px(16.0))
+                            .rounded(px(3.0))
+                            .object_fit(ObjectFit::Cover)
+                            .into_any_element(),
+                        "Attached image",
+                    ),
+                    None => (
+                        crate::file_icons::icon(
+                            crate::file_icons::FileIconIdentity::file(&row.label),
+                            theme.appearance,
+                        )
+                        .size(px(16.0))
+                        .into_any_element(),
+                        "Attached file",
+                    ),
+                };
+                rows.push(
+                    crate::popover::menu_row(
+                        theme,
+                        selected,
+                        format!("attachment-mention-result-{ix}"),
+                    )
+                    .id(("attachment-mention-result", ix))
+                    .on_click(cx.listener(move |this, _, _, cx| {
+                        this.mention.active = Some(ix);
+                        this.accept_mention(cx);
+                    }))
+                    .child(crate::popover::completion_row_content(
+                        theme,
+                        icon,
+                        row.label.clone().into(),
+                        detail.into(),
+                    ))
+                    .into_any_element(),
+                );
+            }
+            let attachment_count = attachment_rows.len();
+            for (file_ix, result) in self.mention.results.iter().enumerate() {
+                let ix = attachment_count + file_ix;
                 let selected = self.mention.active == Some(ix);
                 let (directory, name) = match result.path.rsplit_once('/') {
                     Some((directory, name)) => (directory.to_string(), name.to_string()),
@@ -7726,7 +8351,11 @@ impl Composer {
             if let Some((draft, mut attachments, mut appshots)) = self.queue_edit_draft.take() {
                 appshots.extend(self.appshots.remove(&self.current_key).unwrap_or_default());
                 self.appshots.insert(self.current_key.clone(), appshots);
-                let edited = self.input.read(cx).text().to_string();
+                // The edit's chip numbers would collide with the draft's: its
+                // chips become their labels and its attachments plain tiles.
+                let edited = zeron_proto::attachment_mentions::attachment_mention_prompt(
+                    self.input.read(cx).text(),
+                );
                 let text = [draft, edited]
                     .into_iter()
                     .filter(|text| !text.is_empty())
@@ -7736,7 +8365,12 @@ impl Composer {
                 attachments.extend(
                     self.attachments
                         .remove(&self.current_key)
-                        .unwrap_or_default(),
+                        .unwrap_or_default()
+                        .into_iter()
+                        .map(|att| StagedAttachment {
+                            mention: None,
+                            ..att
+                        }),
                 );
                 self.attachments
                     .insert(self.current_key.clone(), attachments);
@@ -8139,6 +8773,7 @@ impl Composer {
             .attachments
             .remove(&self.current_key)
             .unwrap_or_default();
+        self.attachment_drafts.remove(&self.current_key);
         let staged_appshots = self.appshots.remove(&self.current_key).unwrap_or_default();
         let mut staged = ordinary_staged.clone();
         staged.extend(
@@ -8158,6 +8793,12 @@ impl Composer {
             taken
         });
         let typed = text.clone();
+        // A chip for an attachment that is no longer staged must not leave as a link.
+        let attached: Vec<u32> = ordinary_staged
+            .iter()
+            .filter_map(|att| att.mention)
+            .collect();
+        let text = zeron_proto::attachment_mentions::demote_unattached_mentions(&text, &attached);
         let text = crate::comments::with_comments(&text, &comments);
         self.preview = None;
         let message_id = uuid::Uuid::new_v4().to_string();
@@ -8244,30 +8885,20 @@ impl Composer {
         // rewrite instead of blanking into a reload skeleton.
         if queued_flow {
             for (upload_id, att) in upload_ids.iter().zip(&staged) {
-                attachments::seed_attachment_alias(
-                    &device_id,
-                    upload_id,
-                    &att.name,
-                    att.image.clone(),
-                );
+                attachments::seed_staged_alias(&device_id, upload_id, att);
                 if let Some(local) = local_device_id.as_deref()
                     && local != device_id
                 {
-                    attachments::seed_attachment_alias(
-                        local,
-                        upload_id,
-                        &att.name,
-                        att.image.clone(),
-                    );
+                    attachments::seed_staged_alias(local, upload_id, att);
                 }
             }
         }
         for (path, att) in echo_paths.iter().zip(&staged) {
-            attachments::seed_attachment(&device_id, path, &att.name, att.image.clone());
+            attachments::seed_staged(&device_id, path, att);
             if let Some(local) = local_device_id.as_deref()
                 && local != device_id
             {
-                attachments::seed_attachment(local, path, &att.name, att.image.clone());
+                attachments::seed_staged(local, path, att);
             }
         }
 
@@ -8420,9 +9051,9 @@ impl Composer {
                     // Attachment in the original send path).
                     let seed_device = host_device_id.clone().unwrap_or_else(|| device_id.clone());
                     for (path, att) in attachment_paths.iter().zip(&staged) {
-                        attachments::seed_attachment(&seed_device, path, &att.name, att.image.clone());
+                        attachments::seed_staged(&seed_device, path, att);
                         if seed_device != device_id {
-                            attachments::seed_attachment(&device_id, path, &att.name, att.image.clone());
+                            attachments::seed_staged(&device_id, path, att);
                         }
                     }
                     let appshot_paths: HashMap<String, String> = staged
@@ -8620,7 +9251,7 @@ impl Composer {
                     let queue_text = if !clean_queue_attachment_text {
                         content.as_str()
                     } else if queue_body.trim().is_empty() && !attachment_paths.is_empty() {
-                        attachments::ATTACHMENT_ONLY_TEXT
+                        attachments::attachment_only_text(&attachment_paths)
                     } else {
                         queue_body.as_str()
                     };
@@ -10038,13 +10669,7 @@ impl Render for Composer {
         };
         let expanded = self.expanded_mode;
 
-        // Chat-scoped failures render only under their own chat; a global
-        // failure (no key) renders everywhere.
-        let failure = self.failure.clone().filter(|_| {
-            self.failure_key
-                .as_ref()
-                .is_none_or(|key| *key == self.current_key)
-        });
+        let failure = self.visible_failure();
         // Composer honesty: when the target's delivery path is degraded, say
         // UP FRONT that a send will queue (a durable local write delivered on
         // reconnect) instead of letting the button imply instant delivery.
@@ -10212,7 +10837,7 @@ impl Render for Composer {
         // `morph_t`) animates. Steady state renders exactly the target.
         // Staged attachments add the wrap strip's height to the pill in BOTH
         // modes (attachment-ui.tsx AttachmentStrip sits above the input row).
-        let staged_count = self.staged().len();
+        let staged_count = self.tiled_attachments(cx).len();
         // The input width excludes the inline controls in compact mode.
         // Wrap against the pill's content width in both modes, accounting
         // for the outer container padding and the pill's 1px borders.
@@ -10908,6 +11533,9 @@ impl Render for Composer {
 #[cfg(test)]
 mod modal_selection_tests;
 
+#[cfg(test)]
+mod attachment_chip_tests;
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -11387,7 +12015,15 @@ mod tests {
             cx.update_window(handle.into(), |_, window, cx| {
                 window.draw(cx).clear();
                 assert!(input.read(cx).focus_handle.is_focused(window));
-                assert_eq!(input.read(cx).text(), "Keep this draft");
+                // An attached image is mentioned at the caret.
+                assert_eq!(
+                    input.read(cx).text(),
+                    if accepted {
+                        "Keep this draft [Image 1](zeron-image:1) "
+                    } else {
+                        "Keep this draft"
+                    }
+                );
             })
             .unwrap();
             assert_eq!(
@@ -11884,8 +12520,9 @@ mod tests {
             assert_eq!(input.projection.mentions.len(), 3);
             for (mention, display) in &input.projection.mentions {
                 let label = &input.projection.display[display.clone()];
-                assert!(label.starts_with(&format!("{MENTION_SIDE_PAD}{}", mention.prefix)));
-                assert!(label.ends_with(MENTION_SIDE_PAD));
+                let _ = mention;
+                assert!(label.starts_with(&format!("{MENTION_SIDE_PAD}{CHIP_ICON_SLOT}")));
+                assert!(label.ends_with(CHIP_TRAILING_PAD));
                 let shell = input.bounds_for_display_range(display.clone());
                 assert_eq!(shell.len(), 1);
                 assert!(shell[0].size.width > px(0.0));
@@ -12141,7 +12778,7 @@ mod tests {
     #[test]
     fn hidden_markdown_hit_testing_targets_visible_text() {
         let raw = "***café***\nactive";
-        let projection = TextProjection::rich(raw, Some(12..raw.len()));
+        let projection = TextProjection::rich(raw, Some(12..raw.len()), None);
         assert_eq!(projection.display_to_raw(0), 3);
         assert_eq!(
             &raw[projection.display_to_raw(0)..projection.display_to_raw(1)],
@@ -12159,7 +12796,7 @@ mod tests {
         assert_eq!(shown.graphemes(true).count(), 31);
         assert!(shown.ends_with(".rs"));
         let raw = local_file_link(&format!("src/{label}"), false);
-        let projected = TextProjection::rich(&raw, Some(0..raw.len()));
+        let projected = TextProjection::rich(&raw, Some(0..raw.len()), None);
         assert_eq!(projected.mentions[0].0.range, 0..raw.len());
         assert!(projected.mentions[0].0.path.ends_with(&label));
         assert!(projected.display.contains('…'));
@@ -12754,6 +13391,9 @@ mod tests {
             }
             input.set_text("**selected**", cx);
             input.selected_range = 2..10;
+            for outside in ["/tmp/file.rs", "../file.rs"] {
+                assert!(!input.insert_dropped_mention(outside, false, cx));
+            }
             assert!(input.insert_dropped_mention("src/main.rs", false, cx));
             assert_eq!(
                 input.text(),
@@ -12874,9 +13514,10 @@ mod tests {
         };
         let raw = format!("**café** {} end\nactive", invocation.link());
         let active = raw.rfind('\n').unwrap() + 1..raw.len();
-        let projection = TextProjection::rich(&raw, Some(active));
+        let projection = TextProjection::rich(&raw, Some(active), None);
         assert!(projection.display.starts_with("café"));
-        assert!(projection.display.contains("$Bla\u{00A0}Bla"));
+        assert!(projection.display.contains("Bla\u{00A0}Bla"));
+        assert!(!projection.display.contains('$'));
         assert_eq!(projection.mentions.len(), 1);
         let (link, display) = &projection.mentions[0];
         assert_eq!(projection.raw_to_display(link.range.start), display.start);
@@ -12890,7 +13531,8 @@ mod tests {
             Some(link.range.start)
         );
         let (sent, _) = sent_mention_display(&raw).unwrap();
-        assert!(sent.contains("$bla-bla:bla-bla"));
+        assert!(sent.contains("bla-bla:bla-bla"));
+        assert!(!sent.contains('$'));
         assert!(sent.starts_with("**café**"));
     }
 
@@ -13068,6 +13710,7 @@ mod tests {
         MentionTooltipTarget {
             range,
             path: path.into(),
+            attachment: None,
         }
     }
 
@@ -14074,34 +14717,30 @@ mod tests {
         assert_eq!(links.len(), 1);
         assert_eq!(links[0].path, "src/a file#[x].rs");
         assert_eq!(links[0].basename, "a file#[x].rs");
-        assert!(!links[0].is_dir);
+        assert!(!links[0].is_dir());
 
         let folder = local_file_link("src/components", true);
         assert_eq!(folder, "[components](zeron-file:src/components/)");
         let links = file_mention_links(&folder);
         assert_eq!(links[0].path, "src/components");
-        assert!(links[0].is_dir);
+        assert!(links[0].is_dir());
     }
 
     #[test]
     fn dropped_mentions_are_separated_from_surrounding_text() {
+        let link = local_file_link("src/lib.rs", false);
         let (inserted, cursor_advance) =
-            dropped_file_mention("fixnow", 3..3, "src/lib.rs", false).expect("valid drop");
+            dropped_reference("fixnow", 3..3, &link).expect("valid drop");
         assert_eq!(inserted, " [lib.rs](zeron-file:src/lib.rs) ");
         assert_eq!(cursor_advance, inserted.len());
 
+        let link = local_file_link("src/components", true);
         let (inserted, cursor_advance) =
-            dropped_file_mention("fix now", 3..3, "src/components", true).expect("valid drop");
+            dropped_reference("fix now", 3..3, &link).expect("valid drop");
         assert_eq!(inserted, " [components](zeron-file:src/components/)");
         assert_eq!(cursor_advance, inserted.len() + 1);
     }
 
-    #[test]
-    fn dropped_mentions_reject_paths_outside_the_workspace() {
-        assert!(dropped_file_mention("", 0..0, "/tmp/file.rs", false).is_none());
-        assert!(dropped_file_mention("", 0..0, "../file.rs", false).is_none());
-    }
-
     #[test]
     fn file_mentions_reject_external_or_noncanonical_markdown() {
         assert!(file_mention_links("[site](https://example.com/a)").is_empty());
@@ -14132,15 +14771,15 @@ mod tests {
                 range: 0..0,
                 basename: "mod.rs".into(),
                 path: "foo/mod.rs".into(),
-                is_dir: false,
-                prefix: '@',
+                kind: ChipKind::File,
+                attachment: None,
             },
             FileMentionLink {
                 range: 0..0,
                 basename: "oomod.rs".into(),
                 path: "bar/oomod.rs".into(),
-                is_dir: false,
-                prefix: '@',
+                kind: ChipKind::File,
+                attachment: None,
             },
         ];
         assert_eq!(
@@ -14156,7 +14795,7 @@ mod tests {
         let (link, chip) = &projection.mentions[0];
         assert_eq!(
             &projection.display[chip.clone()],
-            "\u{00A0}@composer.rs\u{00A0}"
+            format!("{MENTION_SIDE_PAD}{CHIP_ICON_SLOT}composer.rs{CHIP_TRAILING_PAD}")
         );
         assert_eq!(projection.display_to_raw(chip.start + 1), link.range.start);
         assert_eq!(projection.display_to_raw(chip.end - 1), link.range.end);
@@ -14188,11 +14827,11 @@ mod tests {
         assert_eq!(spans.len(), 2);
         assert_eq!(
             &display[spans[0].range.clone()],
-            "\u{00A0}@composer.rs\u{00A0}"
+            format!("{MENTION_SIDE_PAD}{CHIP_ICON_SLOT}composer.rs{CHIP_TRAILING_PAD}")
         );
-        assert!(!spans[0].is_dir);
+        assert_eq!(spans[0].kind, ChipKind::File);
+        assert_eq!(spans[1].kind, ChipKind::Directory);
         assert_eq!(spans[0].path.as_ref(), "src/composer.rs");
-        assert!(spans[1].is_dir);
         assert_eq!(spans[1].path.as_ref(), "src/components/");
     }
 
diff --git a/crates/ui/src/composer/attachment_chip_tests.rs b/crates/ui/src/composer/attachment_chip_tests.rs
new file mode 100644
index 0000000000..b0d8afb18c
--- /dev/null
+++ b/crates/ui/src/composer/attachment_chip_tests.rs
@@ -0,0 +1,792 @@
+use super::tests::composer_focus_window;
+use super::*;
+use zeron_proto::attachment_mentions::{attachment_mention_indices, attachment_mention_link};
+
+fn png() -> gpui::Image {
+    let mut bytes = std::io::Cursor::new(Vec::new());
+    image::RgbImage::new(1, 1)
+        .write_to(&mut bytes, image::ImageFormat::Png)
+        .unwrap();
+    gpui::Image::from_bytes(gpui::ImageFormat::Png, bytes.into_inner())
+}
+
+fn paste_images(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+    count: usize,
+) {
+    handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |_, cx| {
+                cx.emit(ComposerInputEvent::PastedImages(
+                    (0..count).map(|_| png()).collect(),
+                ))
+            });
+        })
+        .unwrap();
+    cx.run_until_parked();
+}
+
+/// Replace a range of the draft the way typing would, so each edit reaches the
+/// composer as an ordinary input edit.
+fn edit(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+    range_and_text: impl FnOnce(&ComposerInput) -> (Range<usize>, String),
+) {
+    handle
+        .update(cx, |composer, window, cx| {
+            composer.input.update(cx, |input, cx| {
+                let (range, new_text) = range_and_text(input);
+                let range = input.range_to_utf16(&range);
+                input.replace_text_in_range(Some(range), &new_text, window, cx);
+            });
+        })
+        .unwrap();
+    cx.run_until_parked();
+}
+
+fn append(handle: &gpui::WindowHandle<Composer>, cx: &mut gpui::TestAppContext, new_text: &str) {
+    let new_text = new_text.to_string();
+    edit(handle, cx, move |input| {
+        let end = input.text().len();
+        (end..end, new_text)
+    });
+}
+
+fn text(handle: &gpui::WindowHandle<Composer>, cx: &mut gpui::TestAppContext) -> String {
+    handle
+        .read_with(cx, |composer, cx| {
+            composer.input.read(cx).text().to_string()
+        })
+        .unwrap()
+}
+
+fn staged_names(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+) -> Vec<String> {
+    handle
+        .read_with(cx, |composer, _| {
+            composer
+                .staged()
+                .iter()
+                .map(|att| att.name.clone())
+                .collect()
+        })
+        .unwrap()
+}
+
+#[gpui::test]
+fn pasting_images_numbers_them_and_mentions_each_at_the_caret(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.set_text("compare ", cx));
+        })
+        .unwrap();
+    paste_images(&handle, cx, 2);
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png", "Image 2.png"]);
+    assert_eq!(
+        text(&handle, cx),
+        format!(
+            "compare {} {} ",
+            attachment_mention_link(1, None),
+            attachment_mention_link(2, None)
+        )
+    );
+    handle
+        .read_with(cx, |composer, cx| {
+            let display = &composer.input.read(cx).projection.display;
+            assert!(
+                display.contains(&format!("{CHIP_ICON_SLOT}Image\u{a0}1")),
+                "{display:?}"
+            );
+            assert_eq!(composer.input.read(cx).projection.mentions.len(), 2);
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn one_undo_removes_a_paste_and_redo_restores_it(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 2);
+    handle
+        .update(cx, |composer, window, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.undo(&Undo, window, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(text(&handle, cx), "");
+    assert!(staged_names(&handle, cx).is_empty());
+    handle
+        .update(cx, |composer, window, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.redo(&Redo, window, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(attachment_mention_indices(&text(&handle, cx)), vec![1, 2]);
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png", "Image 2.png"]);
+}
+
+#[gpui::test]
+fn deleting_the_last_chip_unstages_and_undo_restores_the_image(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 2);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.remove_attachment_chips(1, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(staged_names(&handle, cx), ["Image 2.png"]);
+    handle
+        .update(cx, |composer, window, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.undo(&Undo, window, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png", "Image 2.png"]);
+}
+
+#[gpui::test]
+fn numbers_are_never_reused_after_a_removal(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 2);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.remove_attachment_chips(2, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    paste_images(&handle, cx, 1);
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png", "Image 3.png"]);
+}
+
+#[gpui::test]
+fn removing_a_thumbnail_removes_every_chip_for_it(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    append(
+        &handle,
+        cx,
+        &format!(" and {}", attachment_mention_link(1, None)),
+    );
+    assert_eq!(attachment_mention_indices(&text(&handle, cx)), vec![1]);
+    assert_eq!(staged_names(&handle, cx).len(), 1);
+    handle
+        .update(cx, |composer, _, cx| {
+            let id = composer.staged()[0].id.clone();
+            composer.remove_attachment(&id, cx);
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert!(attachment_mention_indices(&text(&handle, cx)).is_empty());
+    assert!(!text(&handle, cx).contains("zeron-image"));
+    assert!(staged_names(&handle, cx).is_empty());
+}
+
+#[gpui::test]
+fn a_chip_may_repeat_and_the_image_stays_until_the_last_is_removed(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    append(
+        &handle,
+        cx,
+        &format!(" again {}", attachment_mention_link(1, None)),
+    );
+    for expected_left in [1usize, 0] {
+        edit(&handle, cx, |input| {
+            let first = zeron_proto::attachment_mentions::attachment_mentions(input.text())[0]
+                .range
+                .clone();
+            (first, String::new())
+        });
+        assert_eq!(staged_names(&handle, cx).len(), expected_left);
+    }
+}
+
+#[gpui::test]
+fn attachments_without_chips_are_left_alone(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    handle
+        .update(cx, |composer, _, cx| {
+            let key = composer.current_key.clone();
+            composer
+                .attachments
+                .entry(key)
+                .or_default()
+                .push(crate::attachments::stage_clipboard_image(png()));
+            composer
+                .input
+                .update(cx, |input, cx| input.set_text("hello", cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(staged_names(&handle, cx), ["image.png"]);
+}
+
+fn tiled_names(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+) -> Vec<String> {
+    handle
+        .read_with(cx, |composer, cx| {
+            composer
+                .tiled_attachments(cx)
+                .iter()
+                .map(|att| att.name.clone())
+                .collect()
+        })
+        .unwrap()
+}
+
+#[gpui::test]
+fn only_attachments_without_a_chip_get_a_tile(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 2);
+    // The chips stand in for the staged images: no tile repeats them.
+    assert_eq!(staged_names(&handle, cx).len(), 2);
+    assert!(tiled_names(&handle, cx).is_empty());
+    handle
+        .update(cx, |composer, _, _| {
+            let key = composer.current_key.clone();
+            composer
+                .attachments
+                .entry(key)
+                .or_default()
+                .push(crate::attachments::stage_clipboard_image(png()));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    // One with no chip keeps its tile, the only handle it has.
+    assert_eq!(tiled_names(&handle, cx), ["image.png"]);
+}
+
+#[gpui::test]
+fn undoing_a_thumbnail_removal_restores_image_and_chip(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    handle
+        .update(cx, |composer, _, cx| {
+            let id = composer.staged()[0].id.clone();
+            composer.remove_attachment(&id, cx);
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert!(staged_names(&handle, cx).is_empty());
+    handle
+        .update(cx, |composer, window, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.undo(&Undo, window, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png"]);
+    assert_eq!(attachment_mention_indices(&text(&handle, cx)), vec![1]);
+}
+
+fn add_file(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+    path: std::path::PathBuf,
+) {
+    handle
+        .update(cx, |composer, _, cx| composer.add_paths(vec![path], cx))
+        .unwrap();
+    cx.run_until_parked();
+}
+
+fn write_file(dir: &tempfile::TempDir, name: &str) -> std::path::PathBuf {
+    let path = dir.path().join(name);
+    std::fs::write(&path, b"# notes").unwrap();
+    path
+}
+
+#[gpui::test]
+fn a_file_attachment_is_staged_with_a_chip_named_after_it(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    add_file(&handle, cx, write_file(&dir, "notes.md"));
+    assert_eq!(staged_names(&handle, cx), ["notes.md"]);
+    assert_eq!(
+        text(&handle, cx),
+        format!("{} ", attachment_mention_link(1, Some("notes.md")))
+    );
+    handle
+        .read_with(cx, |composer, cx| {
+            let input = composer.input.read(cx);
+            assert_eq!(input.projection.mentions.len(), 1);
+            assert_eq!(input.projection.mentions[0].0.kind, ChipKind::File);
+            assert!(input.projection.display.contains("notes.md"));
+            assert_eq!(composer.staged()[0].bytes(), b"# notes");
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn images_and_files_share_one_numbering(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    add_file(&handle, cx, write_file(&dir, "notes.md"));
+    paste_images(&handle, cx, 1);
+    assert_eq!(
+        staged_names(&handle, cx),
+        ["Image 1.png", "notes.md", "Image 3.png"]
+    );
+    assert_eq!(
+        attachment_mention_indices(&text(&handle, cx)),
+        vec![1, 2, 3]
+    );
+}
+
+#[gpui::test]
+fn deleting_a_file_chip_removes_the_file_and_undo_restores_it(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    add_file(&handle, cx, write_file(&dir, "notes.md"));
+    handle
+        .update(cx, |composer, _, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.remove_attachment_chips(1, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert!(staged_names(&handle, cx).is_empty());
+    handle
+        .update(cx, |composer, window, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.undo(&Undo, window, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(staged_names(&handle, cx), ["notes.md"]);
+}
+
+#[gpui::test]
+fn at_completion_offers_staged_files_by_name(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    add_file(&handle, cx, write_file(&dir, "notes.md"));
+    append(&handle, cx, " @note");
+    handle
+        .update(cx, |composer, _, cx| {
+            let rows = composer.mention_attachment_matches();
+            assert_eq!(
+                rows.iter()
+                    .map(|row| row.label.as_str())
+                    .collect::<Vec<_>>(),
+                ["notes.md"]
+            );
+            assert!(rows[0].image.is_none());
+            composer.accept_mention(cx);
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(
+        attachment_mention_indices(&text(&handle, cx)),
+        vec![1, 2],
+        "the file chip is mentioned a second time"
+    );
+    assert!(
+        text(&handle, cx)
+            .trim_end()
+            .ends_with(&attachment_mention_link(2, Some("notes.md")))
+    );
+}
+
+#[gpui::test]
+fn a_folder_is_refused_without_staging(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    add_file(&handle, cx, dir.path().to_path_buf());
+    assert!(staged_names(&handle, cx).is_empty());
+    assert_eq!(text(&handle, cx), "");
+    handle
+        .read_with(cx, |composer, _| assert!(composer.failure().is_some()))
+        .unwrap();
+}
+
+#[gpui::test]
+fn a_chip_without_a_staged_image_shows_as_plain_text(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                input.set_text(format!("see {}", attachment_mention_link(4, None)), cx)
+            });
+        })
+        .unwrap();
+    cx.run_until_parked();
+    handle
+        .read_with(cx, |composer, cx| {
+            let input = composer.input.read(cx);
+            assert!(input.projection.mentions.is_empty());
+            assert!(input.projection.display.contains("Image 4"));
+            assert!(!input.projection.display.contains('@'));
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn images_without_chips_still_count_as_content_and_send_state(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    handle
+        .read_with(cx, |composer, cx| {
+            assert!(composer.has_draft(cx));
+            assert!(composer_has_content(
+                composer.input.read(cx).text(),
+                composer.staged().len(),
+                0
+            ));
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn at_completion_pins_staged_images_above_files_and_filters_them(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 2);
+    append(&handle, cx, " @");
+    handle
+        .read_with(cx, |composer, _| {
+            let matches = composer.mention_attachment_matches();
+            assert_eq!(
+                matches.iter().map(|row| row.index).collect::<Vec<_>>(),
+                vec![1, 2]
+            );
+            assert_eq!(composer.mention.active, Some(0));
+        })
+        .unwrap();
+    append(&handle, cx, "image2");
+    handle
+        .update(cx, |composer, _, cx| {
+            let matches = composer.mention_attachment_matches();
+            assert_eq!(
+                matches.iter().map(|row| row.index).collect::<Vec<_>>(),
+                vec![2]
+            );
+            composer.accept_mention(cx);
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(
+        text(&handle, cx),
+        format!(
+            "{} {}  {} ",
+            attachment_mention_link(1, None),
+            attachment_mention_link(2, None),
+            attachment_mention_link(2, None)
+        )
+    );
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png", "Image 2.png"]);
+}
+
+#[gpui::test]
+fn at_completion_has_no_image_rows_when_nothing_is_staged(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.set_text("@", cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    handle
+        .read_with(cx, |composer, _| {
+            assert!(composer.mention_attachment_matches().is_empty());
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn chips_copied_from_another_draft_paste_as_plain_labels(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    handle
+        .update(cx, |composer, window, cx| {
+            let link = attachment_mention_link(1, None);
+            composer.input.update(cx, |input, cx| {
+                input.attachment_scope = "chat-a".into();
+                cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
+                    "Image 1".into(),
+                    serde_json::json!({
+                        "zeronComposerV1": link,
+                        "text": "Image 1",
+                        "zeronAttachmentScope": "chat-a",
+                    }),
+                ));
+                input.attachment_scope = "chat-b".into();
+                input.paste(&Paste, window, cx);
+            });
+        })
+        .unwrap();
+    assert_eq!(text(&handle, cx), "Image 1");
+    handle
+        .update(cx, |composer, window, cx| {
+            composer.input.update(cx, |input, cx| {
+                input.set_text("", cx);
+                input.attachment_scope = "chat-a".into();
+                input.paste(&Paste, window, cx);
+            });
+        })
+        .unwrap();
+    assert_eq!(text(&handle, cx), attachment_mention_link(1, None));
+}
+
+#[test]
+fn sent_messages_project_image_chips_for_the_transcript() {
+    let raw = format!("look at {} please", attachment_mention_link(2, None));
+    let (display, spans) = sent_mention_display(&raw).expect("image chips project");
+    assert_eq!(spans.len(), 1);
+    assert_eq!(spans[0].kind, ChipKind::Image);
+    assert_eq!(
+        &display[spans[0].range.clone()],
+        format!("{MENTION_SIDE_PAD}{CHIP_ICON_SLOT}Image\u{a0}2{CHIP_TRAILING_PAD}")
+    );
+    assert!(sent_mention_display("Image 2 without a link").is_none());
+    assert!(sent_mention_display("[Image 2](zeron-image:9)").is_none());
+}
+
+#[test]
+fn file_chips_use_the_file_theme_to_tell_formats_apart() {
+    use crate::theme::Appearance::Dark;
+    let themed = |kind, name| match chip_icon(kind, name, Dark) {
+        ChipIcon::FileTheme(path) => path,
+        ChipIcon::Glyph(_) => panic!("{name} should use the file theme"),
+    };
+    assert_ne!(
+        themed(ChipKind::File, "README.md"),
+        themed(ChipKind::File, "src/main.rs")
+    );
+    assert_ne!(
+        themed(ChipKind::File, "logo.png"),
+        themed(ChipKind::File, "src/lib.rs")
+    );
+    assert_ne!(
+        themed(ChipKind::File, "src/lib.rs"),
+        themed(ChipKind::Directory, "src/")
+    );
+    assert!(matches!(
+        chip_icon(ChipKind::Image, "", Dark),
+        ChipIcon::Glyph(_)
+    ));
+}
+
+/// Put a queued message carrying `Image 1` and `notes.md` into the composer,
+/// as an acquired edit does.
+fn begin_queued_edit(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+    dir: &tempfile::TempDir,
+) {
+    let notes = crate::attachments::stage_file(&write_file(dir, "notes.md")).unwrap();
+    let image = crate::attachments::stage_png_bytes("ab12cd34-Image_1.png".into(), Vec::new());
+    let text = format!(
+        "summarize {} and {}",
+        attachment_mention_link(1, None),
+        attachment_mention_link(2, Some("notes.md"))
+    );
+    handle
+        .update(cx, |composer, _, cx| {
+            composer.editing_queued = Some("row".into());
+            composer.swap_in_queued_draft(text, vec![image, notes], Vec::new(), cx);
+        })
+        .unwrap();
+    cx.run_until_parked();
+}
+
+fn remove_chip(handle: &gpui::WindowHandle<Composer>, cx: &mut gpui::TestAppContext, index: u32) {
+    edit(handle, cx, move |input| {
+        let chip = zeron_proto::attachment_mentions::attachment_mentions(input.text())
+            .into_iter()
+            .find(|chip| chip.index == index)
+            .unwrap();
+        (chip.range, String::new())
+    });
+}
+
+#[gpui::test]
+fn a_queued_edit_keeps_its_chips_live_and_deleting_one_unstages_it(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    begin_queued_edit(&handle, cx, &dir);
+    // The restored attachments (named as uploaded) take the numbers of the
+    // chips naming them.
+    assert_eq!(
+        staged_names(&handle, cx),
+        ["ab12cd34-Image_1.png", "notes.md"]
+    );
+    handle
+        .read_with(cx, |composer, cx| {
+            assert_eq!(composer.input.read(cx).projection.mentions.len(), 2);
+        })
+        .unwrap();
+
+    // A file attached during the edit is numbered after the message's chips.
+    add_file(&handle, cx, write_file(&dir, "logs.zip"));
+    assert_eq!(
+        staged_names(&handle, cx),
+        ["ab12cd34-Image_1.png", "notes.md", "logs.zip"]
+    );
+    assert_eq!(
+        attachment_mention_indices(&text(&handle, cx)),
+        vec![1, 2, 3]
+    );
+
+    // Deleting its chip unstages it, so saving would not upload it...
+    remove_chip(&handle, cx, 3);
+    assert_eq!(
+        staged_names(&handle, cx),
+        ["ab12cd34-Image_1.png", "notes.md"]
+    );
+    // ...and undo brings it back.
+    handle
+        .update(cx, |composer, window, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.undo(&Undo, window, cx));
+        })
+        .unwrap();
+    cx.run_until_parked();
+    assert_eq!(
+        staged_names(&handle, cx),
+        ["ab12cd34-Image_1.png", "notes.md", "logs.zip"]
+    );
+
+    // A restored file's chip deletes the same way, and the saved text never
+    // carries a chip for an attachment that is not saved with it.
+    remove_chip(&handle, cx, 2);
+    append(
+        &handle,
+        cx,
+        &format!(" {}", attachment_mention_link(9, None)),
+    );
+    assert_eq!(
+        staged_names(&handle, cx),
+        ["ab12cd34-Image_1.png", "logs.zip"]
+    );
+    handle
+        .read_with(cx, |composer, cx| {
+            let saved = composer.queue_edit_text(cx);
+            assert_eq!(attachment_mention_indices(&saved), vec![1, 3]);
+            assert!(saved.ends_with(" Image 9"), "{saved:?}");
+        })
+        .unwrap();
+}
+
+#[gpui::test]
+fn leaving_a_queued_edit_restores_the_draft_and_its_numbering(cx: &mut gpui::TestAppContext) {
+    let (dir, handle) = composer_focus_window(cx);
+    handle
+        .update(cx, |composer, _, cx| {
+            composer
+                .input
+                .update(cx, |input, cx| input.set_text("draft ", cx));
+        })
+        .unwrap();
+    paste_images(&handle, cx, 1);
+    let draft = text(&handle, cx);
+
+    begin_queued_edit(&handle, cx, &dir);
+    add_file(&handle, cx, write_file(&dir, "logs.zip"));
+    remove_chip(&handle, cx, 3);
+    handle
+        .update(cx, |composer, _, cx| composer.clear_queue_edit_local(cx))
+        .unwrap();
+    cx.run_until_parked();
+
+    // The draft comes back with its own image and live chip...
+    assert_eq!(text(&handle, cx), draft);
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png"]);
+    handle
+        .read_with(cx, |composer, cx| {
+            assert_eq!(composer.input.read(cx).projection.mentions.len(), 1);
+        })
+        .unwrap();
+    // ...and its own numbering: the edit's numbers never leak into it.
+    paste_images(&handle, cx, 1);
+    assert_eq!(staged_names(&handle, cx), ["Image 1.png", "Image 2.png"]);
+}
+
+/// Press on the first chip and release `drag` away from where it went down.
+fn click_first_chip(
+    handle: &gpui::WindowHandle<Composer>,
+    cx: &mut gpui::TestAppContext,
+    drag: Point<Pixels>,
+) {
+    cx.update_window((*handle).into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    handle
+        .update(cx, |composer, window, cx| {
+            composer.input.update(cx, |input, cx| {
+                let at = input.mention_hits[0].bounds.center();
+                input.on_mouse_down(
+                    &MouseDownEvent {
+                        button: MouseButton::Left,
+                        position: at,
+                        click_count: 1,
+                        ..Default::default()
+                    },
+                    window,
+                    cx,
+                );
+                input.on_mouse_up(
+                    &MouseUpEvent {
+                        button: MouseButton::Left,
+                        position: at + drag,
+                        click_count: 1,
+                        ..Default::default()
+                    },
+                    window,
+                    cx,
+                );
+            });
+        })
+        .unwrap();
+    cx.run_until_parked();
+}
+
+#[gpui::test]
+fn clicking_an_image_chip_opens_the_picture_full_size(cx: &mut gpui::TestAppContext) {
+    let (_dir, handle) = composer_focus_window(cx);
+    paste_images(&handle, cx, 1);
+    // Hovering shows no card: the click is how the picture is seen.
+    cx.update_window(handle.into(), |_, window, cx| window.draw(cx).clear())
+        .unwrap();
+    handle
+        .update(cx, |composer, _, cx| {
+            composer.input.update(cx, |input, cx| {
+                let at = input.mention_hits[0].bounds.center();
+                input.on_mention_pointer_move(at, cx);
+                assert_eq!(input.mention_tooltip, MentionTooltipPhase::Hidden);
+            });
+        })
+        .unwrap();
+
+    // A drag across the chip only selects.
+    click_first_chip(&handle, cx, point(px(40.0), px(0.0)));
+    handle
+        .read_with(cx, |composer, _| assert!(composer.preview.is_none()))
+        .unwrap();
+
+    click_first_chip(&handle, cx, point(px(0.0), px(0.0)));
+    handle
+        .read_with(cx, |composer, _| {
+            let preview = composer.preview.as_ref().expect("the chip opens its image");
+            assert_eq!(preview.name.as_ref(), "Image 1.png");
+        })
+        .unwrap();
+}
diff --git a/crates/ui/src/composer/chip.rs b/crates/ui/src/composer/chip.rs
new file mode 100644
index 0000000000..5d2d9557dc
--- /dev/null
+++ b/crates/ui/src/composer/chip.rs
@@ -0,0 +1,153 @@
+//! What a chip looks like: its pill, icon and hover preview.
+use super::*;
+
+/// A staged attachment an attachment chip can refer to; an image chip opens
+/// its picture on click.
+pub(super) struct ChipAttachment {
+    pub(super) image: Option<std::sync::Arc<gpui::Image>>,
+}
+
+/// Spaces reserve room at the start of every chip for its icon well, which is
+/// painted over them, so the text, caret and wrapping all treat the chip as
+/// plain text. Non-breaking spaces, because the bundled Geist has no wider or
+/// thinner ones.
+pub(super) const CHIP_ICON_SLOT: &str = "\u{00A0}\u{00A0}\u{00A0}\u{00A0}\u{00A0}";
+/// Breathing room after a chip's label.
+pub(super) const CHIP_TRAILING_PAD: &str = "\u{00A0}\u{00A0}";
+/// The icon sits at this size in its well.
+const CHIP_ICON_SIZE: f32 = 14.0;
+
+/// What a chip refers to; it picks the chip's icon.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ChipKind {
+    Image,
+    Skill,
+    Command,
+    File,
+    Directory,
+}
+
+/// What a chip's icon is painted from: a monochrome glyph tinted like the
+/// chip, or the file theme's own polychrome artwork, which tells formats and
+/// languages apart.
+pub(crate) enum ChipIcon {
+    Glyph(&'static str),
+    FileTheme(SharedString),
+}
+
+/// The icon of a chip. `path` names the file or folder for the file kinds.
+pub(crate) fn chip_icon(
+    kind: ChipKind,
+    path: &str,
+    appearance: crate::theme::Appearance,
+) -> ChipIcon {
+    use crate::file_icons::{FileIconIdentity, asset_path};
+    match kind {
+        ChipKind::Image => ChipIcon::Glyph(crate::icons::GALLERY),
+        ChipKind::Skill => ChipIcon::Glyph(crate::icons::MAGIC_STICK_3),
+        ChipKind::Command => ChipIcon::Glyph(crate::icons::COMMAND),
+        ChipKind::File => ChipIcon::FileTheme(asset_path(FileIconIdentity::file(path), appearance)),
+        ChipKind::Directory => ChipIcon::FileTheme(asset_path(
+            FileIconIdentity::directory(path.trim_end_matches('/'), false),
+            appearance,
+        )),
+    }
+}
+
+/// Paint a chip like the transcript's file badges: a soft rounded pill whose
+/// first row starts with the icon on a small well. Callers center `chip` on
+/// the line box: Geist's cap height sits exactly on its middle (ascent 1005,
+/// descent 295, cap 710 per 1000 units), so a centered pill centers the label.
+pub(crate) fn paint_chip(
+    window: &mut Window,
+    chip: Bounds<Pixels>,
+    icon: Option<&ChipIcon>,
+    theme: &Theme,
+    cx: &App,
+) {
+    window.paint_quad(quad(
+        chip,
+        px(5.0),
+        theme.ink(0.09),
+        px(0.0),
+        gpui::transparent_black(),
+        BorderStyle::default(),
+    ));
+    let Some(icon) = icon else {
+        return;
+    };
+    let well = chip.size.height - px(2.0);
+    let well_bounds = Bounds::new(chip.origin + point(px(1.0), px(1.0)), size(well, well));
+    window.paint_quad(quad(
+        well_bounds,
+        px(4.0),
+        crate::file_icons::well_bg(theme),
+        px(0.0),
+        gpui::transparent_black(),
+        BorderStyle::default(),
+    ));
+    // The icon follows the chip's size, so chips on a small line stay tidy.
+    let side = px(CHIP_ICON_SIZE).min(well - px(4.0));
+    let bounds = Bounds::new(
+        well_bounds.origin + point((well - side) / 2.0, (well - side) / 2.0),
+        size(side, side),
+    );
+    match icon {
+        ChipIcon::Glyph(path) => {
+            let _ = window.paint_svg(
+                bounds,
+                (*path).into(),
+                None,
+                gpui::TransformationMatrix::default(),
+                theme.text_muted,
+                cx,
+            );
+        }
+        ChipIcon::FileTheme(path) => {
+            if let Some(image) = crate::file_icons::raster(path, cx) {
+                let _ = window.paint_image(bounds, Default::default(), image, 0, false);
+            }
+        }
+    }
+}
+
+/// A sent message's text with its chips painted over their spans, for rows
+/// that show one line of it (the queue). `text` is the projected display text
+/// and `spans` its chips, as [`sent_mention_display`] returns them.
+pub(crate) fn chip_text(
+    text: SharedString,
+    spans: Vec<SentMentionSpan>,
+    theme: &Theme,
+) -> gpui::AnyElement {
+    if spans.is_empty() {
+        return text.into_any_element();
+    }
+    let styled = gpui::StyledText::new(text);
+    let layout = styled.layout().clone();
+    let icons: Vec<ChipIcon> = spans
+        .iter()
+        .map(|span| chip_icon(span.kind, &span.path, theme.appearance))
+        .collect();
+    let theme = theme.clone();
+    let underlay = gpui::canvas(
+        |_, _, _| (),
+        move |_, _, window, cx| {
+            for (span, icon) in spans.iter().zip(&icons) {
+                for (row, rect) in
+                    crate::markdown::render::range_rects(&layout, &span.range, 0.0, 2.0)
+                        .into_iter()
+                        .enumerate()
+                {
+                    paint_chip(window, rect, (row == 0).then_some(icon), &theme, cx);
+                }
+            }
+        },
+    )
+    .absolute()
+    .size_full();
+    div()
+        .relative()
+        .child(underlay)
+        .child(styled)
+        .into_any_element()
+}
diff --git a/crates/ui/src/file_icons.rs b/crates/ui/src/file_icons.rs
index 2609c01147..a7d43d8828 100644
--- a/crates/ui/src/file_icons.rs
+++ b/crates/ui/src/file_icons.rs
@@ -6,9 +6,13 @@
 //! authored SVG colors are preserved in light mode; dark mode lifts the
 //! palette's darker accents without replacing polychrome artwork with a tint.
 
-use std::{borrow::Cow, collections::HashMap, sync::LazyLock};
+use std::{
+    borrow::Cow,
+    collections::HashMap,
+    sync::{Arc, LazyLock, Mutex},
+};
 
-use gpui::{AssetSource, Img, Result, SharedString, Styled as _, img};
+use gpui::{App, AssetSource, Img, RenderImage, Result, SharedString, Styled as _, img};
 use rust_embed::RustEmbed;
 use serde::Deserialize;
 use zeron_syntax::LanguageId;
@@ -204,6 +208,21 @@ pub fn icon(identity: FileIconIdentity<'_>, appearance: Appearance) -> Img {
     img(asset_path(identity, appearance)).flex_none()
 }
 
+/// A file-theme icon rasterized for painting straight into a text layout,
+/// where no [`Img`] element can sit. Rasterized once per asset path.
+pub(crate) fn raster(path: &SharedString, cx: &App) -> Option<Arc<RenderImage>> {
+    static CACHE: LazyLock<Mutex<HashMap<SharedString, Arc<RenderImage>>>> =
+        LazyLock::new(Default::default);
+    let mut cache = CACHE.lock().unwrap();
+    if let Some(image) = cache.get(path) {
+        return Some(image.clone());
+    }
+    let svg = Assets.load(path).ok()??;
+    let image = cx.svg_renderer().render_single_frame(&svg, 2.0).ok()?;
+    cache.insert(path.clone(), image.clone());
+    Some(image)
+}
+
 /// Whether a filename resolves to a themed identity rather than the generic
 /// document fallback. This is intentionally stricter than [`asset_path`]: it
 /// lets prose renderers decorate a standalone filename without treating every
diff --git a/crates/ui/src/files/mod.rs b/crates/ui/src/files/mod.rs
index 174436d597..cb25f4b684 100644
--- a/crates/ui/src/files/mod.rs
+++ b/crates/ui/src/files/mod.rs
@@ -608,6 +608,7 @@ impl FilesSurface {
             ComposerInputEvent::PastedImages(_)
             | ComposerInputEvent::PastedPaths(_)
             | ComposerInputEvent::PastedText { .. }
+            | ComposerInputEvent::OpenAttachment(_)
             | ComposerInputEvent::CursorMoved
             | ComposerInputEvent::ViewportChanged => {}
         });
diff --git a/crates/ui/src/icons.rs b/crates/ui/src/icons.rs
index 832c7b27c6..3cd5d51d6e 100644
--- a/crates/ui/src/icons.rs
+++ b/crates/ui/src/icons.rs
@@ -161,6 +161,8 @@ icon_assets![
     (FILE_DATA, "file-data"),
     (FILE_MARKDOWN, "file-markdown"),
     (FILE_IMAGE, "file-image"),
+    // A framed picture: the icon of `Image N` chips.
+    (GALLERY, "gallery"),
     (GLOBAL, "global"),
     (CHECKLIST, "checklist"),
     (WIDGET, "widget"),
diff --git a/crates/ui/src/loaders.rs b/crates/ui/src/loaders.rs
index 9718a4ded0..882da4ad71 100644
--- a/crates/ui/src/loaders.rs
+++ b/crates/ui/src/loaders.rs
@@ -283,8 +283,54 @@ const RING_SEGMENTS: f32 = 64.0;
 /// polylines. Fixed white-on-wash palette: the caller dims the image behind
 /// it, which reads in both themes.
 pub fn upload_progress_ring(percent: u8, diameter: f32) -> AnyElement {
+    let ring = progress_arc(
+        percent,
+        diameter,
+        gpui::hsla(0.0, 0.0, 1.0, 0.22),
+        gpui::hsla(0.0, 0.0, 1.0, 0.95),
+    );
+    div()
+        .relative()
+        .size(px(diameter))
+        .flex()
+        .items_center()
+        .justify_center()
+        .child(ring)
+        .child(
+            div()
+                .text_size(px(9.0))
+                .font_weight(gpui::FontWeight::SEMIBOLD)
+                .text_color(gpui::hsla(0.0, 0.0, 1.0, 0.95))
+                .child(SharedString::from(format!("{percent}%"))),
+        )
+        .into_any_element()
+}
+
+/// [`upload_progress_ring`] without the percent, in the caller's colors: for
+/// a spot too small to label, such as a sent chip's icon well.
+pub fn upload_progress_arc(
+    percent: u8,
+    diameter: f32,
+    track: gpui::Hsla,
+    arc: gpui::Hsla,
+) -> AnyElement {
+    div()
+        .relative()
+        .size(px(diameter))
+        .child(progress_arc(percent, diameter, track, arc))
+        .into_any_element()
+}
+
+/// A faint full track plus an arc growing clockwise from 12 o'clock, filling
+/// its parent.
+fn progress_arc(
+    percent: u8,
+    diameter: f32,
+    track: gpui::Hsla,
+    arc: gpui::Hsla,
+) -> gpui::Canvas<()> {
     let frac = f32::from(percent.min(100)) / 100.0;
-    let ring = canvas(
+    canvas(
         |_, _, _| (),
         move |bounds, _, window, _| {
             let center = bounds.center();
@@ -312,27 +358,12 @@ pub fn upload_progress_ring(percent: u8, diameter: f32) -> AnyElement {
                     window.paint_path(path, color);
                 }
             };
-            paint_arc(1.0, gpui::hsla(0.0, 0.0, 1.0, 0.22));
-            paint_arc(frac, gpui::hsla(0.0, 0.0, 1.0, 0.95));
+            paint_arc(1.0, track);
+            paint_arc(frac, arc);
         },
     )
     .absolute()
-    .inset_0();
-    div()
-        .relative()
-        .size(px(diameter))
-        .flex()
-        .items_center()
-        .justify_center()
-        .child(ring)
-        .child(
-            div()
-                .text_size(px(9.0))
-                .font_weight(gpui::FontWeight::SEMIBOLD)
-                .text_color(gpui::hsla(0.0, 0.0, 1.0, 0.95))
-                .child(SharedString::from(format!("{percent}%"))),
-        )
-        .into_any_element()
+    .inset_0()
 }
 
 /// Full-window boot splash: the app's dot loader (the same [`gradient_spinner`]
diff --git a/crates/ui/src/pickers.rs b/crates/ui/src/pickers.rs
index 989936c9ad..58ab0cbb71 100644
--- a/crates/ui/src/pickers.rs
+++ b/crates/ui/src/pickers.rs
@@ -777,6 +777,7 @@ impl Pickers {
             ComposerInputEvent::PastedImages(_)
             | ComposerInputEvent::PastedPaths(_)
             | ComposerInputEvent::PastedText { .. }
+            | ComposerInputEvent::OpenAttachment(_)
             | ComposerInputEvent::CursorMoved
             | ComposerInputEvent::ViewportChanged
             | ComposerInputEvent::MentionNavigate(_)
diff --git a/crates/ui/src/queue.rs b/crates/ui/src/queue.rs
index b8d11e19fd..76d4f525b8 100644
--- a/crates/ui/src/queue.rs
+++ b/crates/ui/src/queue.rs
@@ -196,7 +196,7 @@ fn one_line(text: &str) -> SharedString {
 fn queue_visible_text(text: &str, attachments: &[String]) -> String {
     let text = crate::appshots::strip_context_for_display(text);
     if text.trim().is_empty() && !attachments.is_empty() {
-        return crate::attachments::ATTACHMENT_ONLY_TEXT.to_string();
+        return crate::attachments::attachment_only_text(attachments).to_string();
     }
     if attachments.is_empty() {
         return text.to_string();
@@ -212,21 +212,26 @@ fn queue_visible_text(text: &str, attachments: &[String]) -> String {
         return text.to_string();
     }
     if parsed.text.trim().is_empty() {
-        crate::attachments::ATTACHMENT_ONLY_TEXT.to_string()
+        crate::attachments::attachment_only_text(attachments).to_string()
     } else {
         parsed.text
     }
 }
 
-/// The row's one-line label. Commands, skills and file mentions show the same
-/// labels as the transcript; editing and delivery still read the stored text,
-/// which keeps their canonical links.
-fn queue_row_text(text: &str, attachments: &[String]) -> SharedString {
+/// The row's one-line label and the chips to paint over it. Commands, skills,
+/// files and attachments show the same chips as the transcript; editing and
+/// delivery still read the stored text, which keeps their canonical links.
+fn queue_row_text(
+    text: &str,
+    attachments: &[String],
+) -> (SharedString, Vec<crate::composer::SentMentionSpan>) {
     let visible = queue_visible_text(text, attachments);
-    let display = crate::composer::sent_mention_display(&visible)
-        .map(|(display, _)| display)
-        .unwrap_or(visible);
-    one_line(&display)
+    match crate::composer::sent_mention_display(&visible) {
+        // Line breaks become spaces of the same size, so the chips' spans
+        // still line up with the text.
+        Some((display, spans)) => (display.replace(['\r', '\n'], " ").into(), spans),
+        None => (one_line(&visible), Vec::new()),
+    }
 }
 
 /// Presentation-only metadata. Never expose the observed accessibility payload.
@@ -437,12 +442,15 @@ impl Composer {
         let being_removed = self.queue_removing.contains(&item.id);
         let delivery_blocked = item.delivery_gate.is_some();
         let interaction_blocked = delivery_blocked || being_removed;
-        let text = match &item.delivery_gate {
+        let (text, chips) = match &item.delivery_gate {
             Some(QueueDeliveryGate::Editing {
                 owner_device_id, ..
-            }) if !being_edited => SharedString::from(format!("Editing on {owner_device_id}")),
+            }) if !being_edited => (
+                SharedString::from(format!("Editing on {owner_device_id}")),
+                Vec::new(),
+            ),
             Some(QueueDeliveryGate::ReviewRequired { .. }) if !being_edited => {
-                SharedString::from("Needs review")
+                (SharedString::from("Needs review"), Vec::new())
             }
             _ => queue_row_text(&item.text, &item.attachments),
         };
@@ -581,29 +589,32 @@ impl Composer {
             // from the editing state.
             .when(being_edited, |el| el.child(div().w(px(14.0)).flex_none()))
             .when(!being_edited, |el| {
+                // A line with chips is taller, so their pills have room.
+                let line_height = if chips.is_empty() { 16.0 } else { 20.0 };
                 let content = div()
                     .flex_1()
                     .min_w_0()
                     .truncate()
                     .text_size(px(QUEUE_TEXT_SIZE))
-                    .line_height(px(16.0))
+                    .line_height(px(line_height))
                     .text_color(theme.text.opacity(0.9))
-                    .child(text);
-                let labels = queue_attachment_labels(&item.text, &item.attachments);
+                    .child(crate::composer::chip_text(text, chips, theme));
+                // Attachments the row's chips already show get no tile.
+                let tiled: Vec<String> =
+                    crate::attachments::unchipped_attachments(&item.text, &item.attachments)
+                        .into_iter()
+                        .cloned()
+                        .collect();
+                let labels = queue_attachment_labels(&item.text, &tiled);
                 let limit = self.queue_preview_limit();
                 let hidden = queue_hidden_attachments_label(&labels, limit);
-                el.children(
-                    item.attachments
-                        .iter()
-                        .zip(&labels)
-                        .take(limit)
-                        .enumerate()
-                        .map(|(index, (path, label))| {
-                            self.queue_thumbnail(&key, index, path, label.into(), cx)
-                        }),
-                )
+                el.children(tiled.iter().zip(&labels).take(limit).enumerate().map(
+                    |(index, (path, label))| {
+                        self.queue_thumbnail(&key, index, path, label.into(), cx)
+                    },
+                ))
                 .when_some(hidden, |el, hidden| {
-                    let remaining = item.attachments.len() - limit;
+                    let remaining = tiled.len() - limit;
                     let hidden: SharedString = hidden.into();
                     el.child(
                         div()
@@ -722,7 +733,12 @@ impl Composer {
         );
         let keys: std::collections::HashSet<_> = items[visible]
             .iter()
-            .flat_map(|item| item.attachments.iter().take(self.queue_preview_limit()))
+            .flat_map(|item| {
+                attachments::unchipped_attachments(&item.text, &item.attachments)
+                    .into_iter()
+                    .take(self.queue_preview_limit())
+            })
+            .filter(|path| attachments::is_image_path(path))
             .map(|path| (device.clone(), path.clone()))
             .take(64)
             .collect();
@@ -889,6 +905,23 @@ impl Composer {
                 }
             })
             .tooltip_show_delay(std::time::Duration::from_millis(350));
+        // A file that is not an image has no thumbnail to load: its icon stands in.
+        if !attachments::is_image_path(path) {
+            return frame
+                .flex()
+                .items_center()
+                .justify_center()
+                .child(
+                    crate::file_icons::icon(
+                        crate::file_icons::FileIconIdentity::file(
+                            attachments::attachment_display_name(&label),
+                        ),
+                        Theme::of(cx).appearance,
+                    )
+                    .size(px(16.0)),
+                )
+                .into_any_element();
+        }
         match snapshot {
             Some(image) => {
                 let path = path.to_owned();
@@ -1361,14 +1394,23 @@ impl Composer {
                     .and_then(|v| serde_json::from_value::<Vec<String>>(v.clone()).ok());
                 let mut load_failed = paths.is_none();
                 for path in paths.unwrap_or_default() {
-                    let loaded = crate::attachments::read_attachment_image(
-                        &engine, cx.background_executor(), Some(&host_device_id), &path,
-                        None,
-                    ).await;
+                    let loaded = if crate::attachments::is_image_path(&path) {
+                        crate::attachments::read_attachment_image(
+                            &engine, cx.background_executor(), Some(&host_device_id), &path,
+                            None,
+                        ).await.map(|loaded| crate::attachments::StagedAttachment {
+                            id: uuid::Uuid::new_v4().to_string(),
+                            mention: None,
+                            name: loaded.name,
+                            content: crate::attachments::AttachmentContent::Image(loaded.image),
+                        })
+                    } else {
+                        crate::attachments::read_attachment_file(
+                            &engine, cx.background_executor(), Some(&host_device_id), &path,
+                        ).await
+                    };
                     match loaded {
-                        Some(loaded) => loaded_attachments.push(crate::attachments::StagedAttachment {
-                            id: uuid::Uuid::new_v4().to_string(), name: loaded.name, image: loaded.image,
-                        }),
+                        Some(staged) => loaded_attachments.push(staged),
                         None => { load_failed = true; break; }
                     }
                 }
@@ -1422,7 +1464,7 @@ impl Composer {
                             .to_string();
                         let attachments: Vec<String> = serde_json::from_value(reply["attachments"].clone()).unwrap_or_default();
                         let text = queue_visible_text(&raw_text, &attachments);
-                        let text = if !attachments.is_empty() && text == crate::attachments::ATTACHMENT_ONLY_TEXT {
+                        let text = if !attachments.is_empty() && crate::attachments::is_attachment_only_text(&text) {
                             String::new()
                         } else { text };
                         let selected_matches = composer.state.read(cx).selected_chat.as_deref()
@@ -1452,15 +1494,12 @@ impl Composer {
                         composer.queue_edit_base_text_hash = Some(base_text_hash.to_string());
                         composer.queue_edit_chat_id = Some(chat_id.clone());
                         composer.queue_edit_host_device_id = Some(host_device_id.clone());
-                        composer.queue_edit_draft = Some((
-                            composer.input.read(cx).text().to_string(),
-                            composer.attachments.remove(&composer.current_key).unwrap_or_default(),
-                            composer.appshots.remove(&composer.current_key).unwrap_or_default(),
-                        ));
-                        composer.attachments.insert(composer.current_key.clone(), loaded_attachments);
-                        composer.appshots.insert(composer.current_key.clone(), loaded_appshots);
-                        composer.focus_pending = true;
-                        composer.input.update(cx, |input, cx| input.set_text(text, cx));
+                        composer.swap_in_queued_draft(
+                            text,
+                            std::mem::take(&mut loaded_attachments),
+                            std::mem::take(&mut loaded_appshots),
+                            cx,
+                        );
                         composer.start_queue_edit_renewal(engine.clone(), cx);
                     }
                     Ok(reply)
@@ -1486,6 +1525,42 @@ impl Composer {
         self.queue_edit_task = Some(task);
     }
 
+    /// Set the draft aside and fill the composer with a queued message.
+    /// Restored attachments take the numbers of the chips that name them, so
+    /// those chips stay live; the draft's own numbering waits with the draft.
+    pub(crate) fn swap_in_queued_draft(
+        &mut self,
+        text: String,
+        mut attachments: Vec<crate::attachments::StagedAttachment>,
+        appshots: Vec<crate::appshots::CapturedAppshot>,
+        cx: &mut Context<Self>,
+    ) {
+        self.queue_edit_draft = Some((
+            self.input.read(cx).text().to_string(),
+            self.attachments
+                .remove(&self.current_key)
+                .unwrap_or_default(),
+            self.appshots.remove(&self.current_key).unwrap_or_default(),
+        ));
+        self.displace_attachment_draft();
+        crate::attachments::pair_with_chips(&text, &mut attachments);
+        self.attachments
+            .insert(self.current_key.clone(), attachments);
+        self.appshots.insert(self.current_key.clone(), appshots);
+        self.focus_pending = true;
+        self.input.update(cx, |input, cx| input.set_text(text, cx));
+    }
+
+    /// The text a queue edit saves: a chip whose attachment was removed is
+    /// saved as its plain label.
+    pub(crate) fn queue_edit_text(&self, cx: &gpui::App) -> String {
+        let attached: Vec<u32> = self.staged().iter().filter_map(|att| att.mention).collect();
+        zeron_proto::attachment_mentions::demote_unattached_mentions(
+            self.input.read(cx).text(),
+            &attached,
+        )
+    }
+
     /// Save the composer into the existing row, including its attachments.
     /// An entirely empty composer removes the row.
     pub(crate) fn commit_queue_edit(&mut self, cx: &mut Context<Self>) -> bool {
@@ -1498,7 +1573,7 @@ impl Composer {
         {
             return true;
         }
-        let text = self.input.read(cx).text().to_string();
+        let text = self.queue_edit_text(cx);
         if !self.check_reference_delivery(&text, cx) {
             return true;
         }
@@ -1525,7 +1600,7 @@ impl Composer {
         self.clear_queue_edit_local(cx);
     }
 
-    fn clear_queue_edit_local(&mut self, cx: &mut Context<Self>) {
+    pub(crate) fn clear_queue_edit_local(&mut self, cx: &mut Context<Self>) {
         self.editing_queued = None;
         self.queue_edit_lease_id = None;
         self.queue_edit_base_text_hash = None;
@@ -1540,6 +1615,7 @@ impl Composer {
         });
         self.queue_edit_task = None;
         self.queue_edit_renew_task = None;
+        self.restore_attachment_draft();
         if let Some((text, attachments, appshots)) = self.queue_edit_draft.take() {
             self.appshots.insert(self.current_key.clone(), appshots);
             self.input.update(cx, |input, cx| input.set_text(text, cx));
@@ -1607,7 +1683,7 @@ impl Composer {
                         params["text"].as_str().unwrap_or_default(), &staged_appshots, &appshot_paths,
                     ).into();
                     if params["text"].as_str().is_some_and(|text| text.trim().is_empty()) && !paths.is_empty() {
-                        params["text"] = crate::attachments::ATTACHMENT_ONLY_TEXT.into();
+                        params["text"] = crate::attachments::attachment_only_text(&paths).into();
                     }
                     params["attachments"] = serde_json::json!(paths);
                 }
@@ -2062,10 +2138,24 @@ mod tests {
         assert_eq!(super::queue_hidden_attachments_label(&[], 2), None);
     }
 
+    /// A row's text without the room reserved for chip icons and padding.
+    fn plain(display: &gpui::SharedString) -> String {
+        display
+            .replace('\u{a0}', " ")
+            .split_whitespace()
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
+
+    fn kinds(spans: &[crate::composer::SentMentionSpan]) -> Vec<crate::composer::ChipKind> {
+        spans.iter().map(|span| span.kind).collect()
+    }
+
     /// Rows label references the way the transcript does, never as raw
     /// `zeron-invoke:`/`zeron-file:` links, and still hide attachment trailers.
     #[test]
     fn queue_rows_label_commands_skills_and_files() {
+        use crate::composer::ChipKind;
         use zeron_proto::invocation::Invocation;
         let command = Invocation::Command {
             name: "compact".into(),
@@ -2079,17 +2169,68 @@ mod tests {
         .link();
         let file = zeron_proto::file_mentions::local_file_link("src/queue.rs", false);
         let text = format!("{command} then {skill}\non {file}");
+        let (display, spans) = super::queue_row_text(&text, &[]);
+        assert_eq!(plain(&display), "compact then review-pr on queue.rs");
         assert_eq!(
-            super::queue_row_text(&text, &[]).as_ref(),
-            "/compact then $review-pr on @queue.rs"
+            kinds(&spans),
+            [ChipKind::Command, ChipKind::Skill, ChipKind::File]
         );
+        // Every chip span lies inside the row's text, line breaks included.
+        assert!(spans.iter().all(|span| span.range.end <= display.len()));
+        assert!(!display.contains('\n'));
 
         let paths = vec!["/tmp/image.png".to_string()];
         let legacy = crate::attachments::with_attachments(&command, &paths);
-        assert_eq!(super::queue_row_text(&legacy, &paths).as_ref(), "/compact");
+        assert_eq!(plain(&super::queue_row_text(&legacy, &paths).0), "compact");
+        let (display, spans) = super::queue_row_text("plain  text", &[]);
+        assert_eq!(display.as_ref(), "plain text");
+        assert!(spans.is_empty());
+    }
+
+    /// A queued message with attachment chips shows them as chips in its row,
+    /// and an attachments-only message names what it holds.
+    #[test]
+    fn queue_rows_label_attachment_chips_and_file_only_sends() {
+        use zeron_proto::attachment_mentions::attachment_mention_link;
+        let paths = vec![
+            "/uploads/ab12cd34-Image_1.png".to_string(),
+            "/uploads/ef56ab78-notes.md".to_string(),
+        ];
+        let text = format!(
+            "compare {} and {}",
+            attachment_mention_link(1, None),
+            attachment_mention_link(2, Some("notes.md"))
+        );
+        let (display, spans) = super::queue_row_text(&text, &paths);
+        assert_eq!(plain(&display), "compare Image 1 and notes.md");
+        assert_eq!(
+            kinds(&spans),
+            [
+                crate::composer::ChipKind::Image,
+                crate::composer::ChipKind::File
+            ]
+        );
+
+        let files = vec!["/uploads/ef56ab78-notes.md".to_string()];
+        assert_eq!(
+            queue_visible_text("", &files),
+            crate::attachments::FILE_ATTACHMENT_ONLY_TEXT
+        );
+        let mixed = vec!["/a/cat.png".to_string(), "/a/notes.md".to_string()];
+        assert_eq!(
+            queue_visible_text("", &mixed),
+            crate::attachments::FILE_ATTACHMENT_ONLY_TEXT
+        );
+        let images = vec!["/a/cat.png".to_string()];
+        assert_eq!(
+            queue_visible_text("", &images),
+            crate::attachments::ATTACHMENT_ONLY_TEXT
+        );
+        // A legacy trailer on a files-only row is hidden like an image one.
+        let legacy = crate::attachments::with_attachments("", &files);
         assert_eq!(
-            super::queue_row_text("plain  text", &[]).as_ref(),
-            "plain text"
+            queue_visible_text(&legacy, &files),
+            crate::attachments::FILE_ATTACHMENT_ONLY_TEXT
         );
     }
 
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index fd1431a3b1..a30ddf15de 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -2626,12 +2626,7 @@ impl Shell {
                         .collect()
                 };
                 for device_id in &device_ids {
-                    crate::attachments::seed_attachment(
-                        device_id,
-                        &pending_path,
-                        &att.name,
-                        att.image.clone(),
-                    );
+                    crate::attachments::seed_staged(device_id, &pending_path, &att);
                 }
                 let text = crate::attachments::with_attachments(
                     "Here is the screenshot of the bug.",
diff --git a/crates/ui/src/shell/chat_dropzone_tests.rs b/crates/ui/src/shell/chat_dropzone_tests.rs
index 4240bc7977..1987b05343 100644
--- a/crates/ui/src/shell/chat_dropzone_tests.rs
+++ b/crates/ui/src/shell/chat_dropzone_tests.rs
@@ -322,3 +322,124 @@ fn file_tab_drops_attach_to_side_chat_transcript_and_main_without_reordering(
         assert_eq!(shell.right_tabs[&shell.panel_key(cx)], original_tabs);
     });
 }
+
+/// Real files of each kind a user might drag in from the desktop: an archive,
+/// an image, a folder and a file over the size limit.
+fn external_files() -> (tempfile::TempDir, gpui::ExternalPaths) {
+    let dir = tempfile::tempdir().unwrap();
+    std::fs::write(
+        dir.path().join("notes.zip"),
+        b"PK\x03\x04 not really zipped",
+    )
+    .unwrap();
+    let mut png = std::io::Cursor::new(Vec::new());
+    image::RgbImage::new(1, 1)
+        .write_to(&mut png, image::ImageFormat::Png)
+        .unwrap();
+    std::fs::write(dir.path().join("shot.png"), png.into_inner()).unwrap();
+    std::fs::create_dir(dir.path().join("folder")).unwrap();
+    // Sparse, so the test never writes 24 MB to disk.
+    std::fs::File::create(dir.path().join("huge.bin"))
+        .unwrap()
+        .set_len(crate::attachments::MAX_ATTACHMENT_BYTES + 1)
+        .unwrap();
+    let paths = ["notes.zip", "shot.png", "folder", "huge.bin"]
+        .into_iter()
+        .map(|name| dir.path().join(name))
+        .collect();
+    (dir, gpui::ExternalPaths(paths))
+}
+
+/// Drag files in from outside the app and release them at `to` the way the
+/// platform reports it: enter, hover, then drop.
+fn drop_external(cx: &mut VisualTestContext, paths: gpui::ExternalPaths, to: Point<Pixels>) {
+    cx.simulate_event(gpui::FileDropEvent::Entered {
+        position: to,
+        paths,
+    });
+    cx.update(|window, cx| {
+        assert!(cx.has_active_drag());
+        window.draw(cx).clear();
+    });
+    cx.simulate_event(gpui::FileDropEvent::Pending { position: to });
+    cx.update(|window, cx| window.draw(cx).clear());
+    cx.simulate_event(gpui::FileDropEvent::Submit { position: to });
+    cx.run_until_parked();
+    cx.update(|window, cx| {
+        assert!(!cx.has_active_drag());
+        window.draw(cx).clear();
+    });
+}
+
+fn staged_names(composer: &Entity<Composer>, cx: &App) -> Vec<String> {
+    composer
+        .read(cx)
+        .staged()
+        .iter()
+        .map(|att| att.name.clone())
+        .collect()
+}
+
+/// A mixed drop from outside the app lands in the conversation it is released
+/// over, main or side chat: the archive and the image are staged with chips in
+/// that draft, and the folder and the oversize file are both named in that
+/// composer's error notice. Composers not yet dropped on stay untouched.
+#[gpui::test]
+fn external_file_drops_stage_files_and_refuse_folders_and_oversize_files(cx: &mut TestAppContext) {
+    use zeron_proto::attachment_mentions::attachment_mention_link;
+    let (shell, cx) = setup_with_shell(cx, true);
+    let (_files, paths) = external_files();
+    let targets = [None, Some(2), Some(1)];
+    let composer = |shell: &Shell, target: Option<u64>| match target {
+        None => shell.composer.clone(),
+        Some(id) => shell.side_chats[&id].composer.clone(),
+    };
+    for (n, target) in targets.into_iter().enumerate() {
+        let to = match target {
+            None => cx.debug_bounds("chat-dropzone").unwrap().center(),
+            Some(id) => cx.update(|window, cx| {
+                shell.update(cx, |shell, cx| {
+                    shell.activate_right_surface(RightSurface::SideChat(id), window, cx);
+                    shell.right_tween = None;
+                });
+                window.draw(cx).clear();
+                let bounds = shell.read(cx).side_chats[&id]
+                    .composer
+                    .read(cx)
+                    .surface_bounds()
+                    .get()
+                    .unwrap();
+                // Over the side chat's transcript, not its input.
+                gpui::point(bounds.center().x, px(180.))
+            }),
+        };
+        drop_external(cx, paths.clone(), to);
+        shell.read_with(cx, |shell, cx| {
+            let dropped = composer(shell, target);
+            assert_eq!(
+                staged_names(&dropped, cx),
+                ["notes.zip", "Image 2.png"],
+                "target={target:?}"
+            );
+            assert_eq!(
+                text(&dropped, cx),
+                format!(
+                    "{} {} ",
+                    attachment_mention_link(1, Some("notes.zip")),
+                    attachment_mention_link(2, None)
+                ),
+                "target={target:?}"
+            );
+            assert_eq!(
+                dropped.read(cx).visible_failure().as_deref(),
+                Some("folder is not a file. huge.bin is too large (24 MB max)."),
+                "target={target:?}"
+            );
+            for other in targets[n + 1..].iter().map(|other| composer(shell, *other)) {
+                assert!(staged_names(&other, cx).is_empty(), "target={target:?}");
+                assert!(text(&other, cx).is_empty(), "target={target:?}");
+                assert!(other.read(cx).failure().is_none(), "target={target:?}");
+            }
+        });
+    }
+}
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index 619c6b249b..cc4c9f9f48 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -33,10 +33,10 @@ use std::sync::{Arc, Weak};
 use std::time::{Duration, Instant};
 
 use gpui::{
-    AnyElement, BorderStyle, Bounds, ClipboardItem, ContentMask, Context, Entity, ListAlignment,
-    ListOffset, ListScrollEvent, ListState, MouseButton, MouseMoveEvent, MouseUpEvent, ObjectFit,
-    PathBuilder, Pixels, Point, SharedString, StyledImage as _, StyledText, Subscription, Task,
-    TextAlign, TextRun, Window, canvas, div, img, list, point, prelude::*, px, quad, size,
+    AnyElement, Bounds, ClipboardItem, ContentMask, Context, Entity, ListAlignment, ListOffset,
+    ListScrollEvent, ListState, MouseButton, MouseMoveEvent, MouseUpEvent, ObjectFit, PathBuilder,
+    Pixels, Point, SharedString, StyledImage as _, StyledText, Subscription, Task, TextAlign,
+    TextRun, Window, canvas, div, img, list, point, prelude::*, px, size,
 };
 
 use zeron_doc::{MessagePart, MessageRole, MessageStatus, SessionMessageEntry, SubagentStatus};
@@ -1324,10 +1324,33 @@ pub fn rows_for_entry(
         // Markdown never lands in the bubble.
         let (body, badges) = crate::badges::split(&parsed.text);
         let body = agent_message_display(&body);
-        let (text, mentions) = match crate::composer::sent_mention_display(&body) {
+        // Chips stand in for their attachments: those leave the strip, and a
+        // chip carries its upload's path for its progress and, for an image,
+        // a click opening it.
+        let chips = zeron_proto::attachment_mentions::attachment_mentions(&body);
+        let mut attachments = parsed.attachments;
+        let (text, mut mentions) = match crate::composer::sent_mention_display(&body) {
             Some((display, spans)) => (display, spans),
             None => (body, Vec::new()),
         };
+        for span in &mut mentions {
+            let Some(chip) = chips
+                .iter()
+                .find(|chip| Some(chip.index) == span.attachment)
+            else {
+                continue;
+            };
+            span.upload = attachments
+                .iter()
+                .find(|att| crate::attachments::chip_names_attachment(chip, &att.path))
+                .map(|att| att.path.clone().into());
+        }
+        attachments.retain(|att| {
+            att.appshot.is_some()
+                || !chips
+                    .iter()
+                    .any(|chip| crate::attachments::chip_names_attachment(chip, &att.path))
+        });
         let copy_text = (!text.trim().is_empty()).then(|| SharedString::from(text.clone()));
         return vec![Row {
             id: entry.id.clone().into(),
@@ -1336,7 +1359,7 @@ pub fn rows_for_entry(
             kind: RowKind::User {
                 text: text.into(),
                 mentions: Arc::new(mentions),
-                attachments: Arc::new(parsed.attachments),
+                attachments: Arc::new(attachments),
                 badges: Arc::new(badges),
                 pending,
             },
@@ -5468,10 +5491,23 @@ impl Transcript {
         let mut keys = std::collections::HashSet::new();
         for row in &self.rows {
             // Generated images use bounded LRU retention, not history-wide protection.
-            if let RowKind::User { attachments, .. } = &row.kind {
-                for att in attachments.iter() {
+            if let RowKind::User {
+                attachments,
+                mentions,
+                ..
+            } = &row.kind
+            {
+                let chipped = mentions
+                    .iter()
+                    .filter(|span| span.kind == crate::composer::ChipKind::Image)
+                    .filter_map(|span| span.upload.as_ref().map(|path| path.to_string()));
+                for path in attachments
+                    .iter()
+                    .map(|att| att.path.clone())
+                    .chain(chipped)
+                {
                     for dev in &devices {
-                        keys.insert((dev.clone(), att.path.clone()));
+                        keys.insert((dev.clone(), path.clone()));
                     }
                 }
             }
@@ -5642,6 +5678,120 @@ impl Transcript {
         self.attachment_retries.insert(key, task);
     }
 
+    /// Open a sent image chip's upload full size, as its thumbnail did. An
+    /// image still loading opens on a later click.
+    fn open_chip_image(
+        &mut self,
+        path: &SharedString,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let device_ids = self.attachment_device_ids(cx);
+        if let crate::attachments::AttachmentSnapshot::Loaded(image) =
+            self.attachment_state(&device_ids, path, None, cx)
+        {
+            let preview = crate::attachments::PreviewImage::new(image.name, image.image.clone());
+            self.attachment_preview_return_focus = window.focused(cx);
+            preview.viewer.reset();
+            self.attachment_preview = Some(preview);
+            window.focus(&self.attachment_preview_focus, cx);
+            cx.notify();
+        }
+    }
+
+    /// Whether an attachment ref is still crossing to the chat's host, and
+    /// how far along it is. Two ref shapes mean "still crossing": the queued
+    /// flow's `pending://` (bytes ship engine-side after the send; the host
+    /// rewrites the ref to an absolute path once they land and the run
+    /// starts) and the legacy echo's synthetic `pending/`. Percent sources, in
+    /// order: this attachment's own relay transfer (`WatchTransfers`, by the
+    /// uploadId its ref names — the leg that actually takes time), else the
+    /// send-wide staging/legacy upload percent. Neither → no number, so a
+    /// ring never shows one that isn't a real transfer position (2026-08-20
+    /// report: the staging-only percent blinked out in ~100ms and lied about
+    /// the slow part).
+    fn upload_status(&self, path: &str, cx: &Context<Self>) -> (bool, Option<u8>) {
+        let sending = path.starts_with("pending://") || path.starts_with("pending/");
+        let upload_id = path
+            .strip_prefix("pending://")
+            .and_then(|rest| rest.split_once('/'))
+            .map(|(id, _)| id);
+        let percent = upload_id
+            .and_then(|id| self.state.read(cx).transfer_percent(id))
+            .or_else(|| {
+                sending
+                    .then(|| self.state.read(cx).upload_progress_percent())
+                    .flatten()
+            });
+        (sending, percent)
+    }
+
+    /// What a sent bubble's attachment chips show beyond their label: the
+    /// progress of an upload still crossing to the host in place of the icon
+    /// (the strip's thumbnails used to carry it), a warning for an image that
+    /// can't be read back, and a click target opening a loaded image.
+    fn chip_overlays(
+        &mut self,
+        row_id: &SharedString,
+        mentions: &[crate::composer::SentMentionSpan],
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> Vec<ChipOverlay> {
+        use crate::attachments::AttachmentSnapshot;
+        if mentions.iter().all(|span| span.upload.is_none()) {
+            return Vec::new();
+        }
+        let device_ids = self.attachment_device_ids(cx);
+        let mut overlays = Vec::new();
+        for (ix, span) in mentions.iter().enumerate() {
+            let Some(upload) = &span.upload else {
+                continue;
+            };
+            let (sending, percent) = self.upload_status(upload, cx);
+            let mut status = sending.then(|| match percent {
+                Some(pct) => crate::loaders::upload_progress_arc(
+                    pct,
+                    CHIP_STATUS_SIZE,
+                    theme.text_muted.opacity(0.35),
+                    theme.text,
+                ),
+                None => crate::loaders::mini_glyph_spinner(
+                    format!("chip-sending-{row_id}-{ix}"),
+                    2.0,
+                    theme.glyph,
+                    cx.entity_id(),
+                    cx,
+                )
+                .into_any_element(),
+            });
+            let mut open = None;
+            if span.kind == crate::composer::ChipKind::Image {
+                // Loading here keeps the image ready for a click, as the
+                // strip's thumbnail did.
+                match self.attachment_state(&device_ids, upload, None, cx) {
+                    AttachmentSnapshot::Loaded(_) => open = Some(upload.clone()),
+                    AttachmentSnapshot::Error { .. } if !sending => {
+                        status = Some(
+                            crate::icons::icon(crate::icons::DANGER_TRIANGLE)
+                                .size(px(CHIP_STATUS_SIZE - 2.0))
+                                .text_color(theme.text_muted)
+                                .into_any_element(),
+                        );
+                    }
+                    _ => {}
+                }
+            }
+            if open.is_some() || status.is_some() {
+                overlays.push(ChipOverlay {
+                    range: span.range.clone(),
+                    open,
+                    status,
+                });
+            }
+        }
+        overlays
+    }
+
     /// The inside of a user bubble: the prompt text, clipped to
     /// [`USER_COLLAPSED_LINES`] until expanded, plus the expander chevron for
     /// prompts past the cap. Returns the bubble's children in order.
@@ -5662,6 +5812,7 @@ impl Transcript {
         window: &Window,
         cx: &mut Context<Self>,
     ) -> AnyElement {
+        let chip_overlays = self.chip_overlays(row_id, &mentions, theme, cx);
         let fold = self.user_folds.get(row_id).copied().unwrap_or_default();
         let expanded = fold.open.unwrap_or(false);
         let line_height =
@@ -5733,6 +5884,10 @@ impl Transcript {
                 theme,
                 measured_h.clone(),
                 cx.entity_id(),
+                chip_overlays,
+                Rc::new(cx.listener(|this, path: &SharedString, window, cx| {
+                    this.open_chip_image(path, window, cx);
+                })),
             ));
         // Height motion uses the same ease-out curve as sidebars, tool folds,
         // and pane transitions, with duration scaled to travel distance. The
@@ -6116,34 +6271,16 @@ impl Transcript {
             .pt(px(4.0))
             .pb(px(6.0));
         for (aix, att) in atts.iter().enumerate() {
+            if !crate::attachments::is_image_path(&att.path) {
+                strip = strip.child(user_file_pill(&att.name, Theme::of(cx)));
+                continue;
+            }
             let state = self.attachment_state(&device_ids, &att.path, None, cx);
             // The in-flight send's progress belongs ON the thumbnail
-            // (2026-08-18 user request). Two ref shapes mean "still
-            // crossing": the queued flow's `pending://` (bytes ship
-            // engine-side after the send; the host rewrites the ref to an
-            // absolute path once they land and the run starts) and the
-            // legacy echo's synthetic `pending/`. Percent sources, in order:
-            // this attachment's own relay transfer (`WatchTransfers`, by the
-            // uploadId its ref names — the leg that actually takes time),
-            // else the send-wide staging/legacy upload percent. Neither → the
-            // indeterminate spinner (staged-but-waiting, retry backoff, or
-            // committed-awaiting-rewrite), so the ring never shows a number
-            // that isn't a real transfer position (2026-08-20 report: the
-            // staging-only percent blinked out in ~100ms and lied about the
-            // slow part).
-            let sending = att.path.starts_with("pending://") || att.path.starts_with("pending/");
-            let upload_id = att
-                .path
-                .strip_prefix("pending://")
-                .and_then(|rest| rest.split_once('/'))
-                .map(|(id, _)| id);
-            let uploading = upload_id
-                .and_then(|id| self.state.read(cx).transfer_percent(id))
-                .or_else(|| {
-                    sending
-                        .then(|| self.state.read(cx).upload_progress_percent())
-                        .flatten()
-                });
+            // (2026-08-18 user request). No percent → the indeterminate
+            // spinner (staged-but-waiting, retry backoff, or
+            // committed-awaiting-rewrite); see `upload_status`.
+            let (sending, uploading) = self.upload_status(&att.path, cx);
             if let Some(appshot) = &att.appshot {
                 let has_image = matches!(&state, AttachmentSnapshot::Loaded(_));
                 let theme = Theme::of(cx).clone();
@@ -7947,6 +8084,8 @@ fn user_bubble_text(
     theme: &Theme,
     measured_h: Rc<Cell<f32>>,
     entity_id: gpui::EntityId,
+    overlays: Vec<ChipOverlay>,
+    open_image: Rc<dyn Fn(&SharedString, &mut Window, &mut gpui::App)>,
 ) -> AnyElement {
     // Split runs at chip boundaries (spans are in order): body text keeps the
     // sans font, chips read as inline code. Size/line-height flow from the
@@ -7959,21 +8098,14 @@ fn user_bubble_text(
         underline: None,
         strikethrough: None,
     };
-    let chip_run = |len: usize| TextRun {
-        len,
-        font: gpui::font(theme.font_mono.clone()),
-        color: theme.code_text,
-        background_color: None,
-        underline: None,
-        strikethrough: None,
-    };
     let mut runs = Vec::with_capacity(mentions.len() * 2 + 1);
     let mut at = 0;
     for span in mentions.iter() {
         if at < span.range.start {
             runs.push(body_run(span.range.start - at));
         }
-        runs.push(chip_run(span.range.len()));
+        // Chips are labels in the body font, like the composer's.
+        runs.push(body_run(span.range.len()));
         at = span.range.end;
     }
     if at < text.len() {
@@ -8014,22 +8146,30 @@ fn user_bubble_text(
     }
     let styled = StyledText::new(text.clone()).with_runs(runs);
     let layout = styled.layout().clone();
-    let wash = theme.code_wash;
+    let chip_layout = layout.clone();
+    // A chip showing a status paints it over its icon well instead.
+    let chip_icons: Vec<Option<crate::composer::ChipIcon>> = mentions
+        .iter()
+        .map(|span| {
+            (!overlays
+                .iter()
+                .any(|overlay| overlay.status.is_some() && overlay.range == span.range))
+            .then(|| crate::composer::chip_icon(span.kind, &span.path, theme.appearance))
+        })
+        .collect();
     let sel_key: std::sync::Arc<str> = format!("{row_id}:u").into();
     let sel_theme = theme.clone();
     let underlay = canvas(
         |bounds, window, _| window.insert_hitbox(bounds, gpui::HitboxBehavior::Normal),
         move |_, hitbox, window, cx| {
-            for span in mentions.iter() {
-                for rect in render::range_rects(&layout, &span.range, 0.0, 2.0) {
-                    window.paint_quad(quad(
-                        rect,
-                        px(5.0),
-                        wash,
-                        px(0.0),
-                        gpui::transparent_black(),
-                        BorderStyle::default(),
-                    ));
+            for (span, icon) in mentions.iter().zip(&chip_icons) {
+                // Centered on the line box like the composer's chips.
+                for (row, rect) in render::range_rects(&layout, &span.range, 0.0, 2.0)
+                    .into_iter()
+                    .enumerate()
+                {
+                    let icon = icon.as_ref().filter(|_| row == 0);
+                    crate::composer::paint_chip(window, rect, icon, &sel_theme, cx);
                 }
             }
             render::paint_text_selection(window, hitbox, &sel_key, &text, &layout, &sel_theme);
@@ -8058,9 +8198,206 @@ fn user_bubble_text(
     .size_full();
     // Same wrapper as the assistant markdown: user-bubble text is
     // selectable (paint_text_selection above), so it gets the I-beam too.
-    render::selectable_text_wrap()
+    let text = render::selectable_text_wrap()
         .child(underlay)
         .child(styled)
+        .into_any_element();
+    if overlays.is_empty() {
+        return text;
+    }
+    ChipOverlays {
+        id: format!("{row_id}-chip-overlays").into(),
+        child: text,
+        layout: chip_layout,
+        overlays,
+        open: open_image,
+        well: crate::file_icons::well_bg(theme),
+    }
+    .into_any_element()
+}
+
+/// The upload status painted in a sent chip's icon well.
+const CHIP_STATUS_SIZE: f32 = 14.0;
+
+/// One sent chip's extras, laid over its pill: a status in place of its icon
+/// and, for a loaded image, a click target opening it full size.
+struct ChipOverlay {
+    range: Range<usize>,
+    open: Option<SharedString>,
+    status: Option<AnyElement>,
+}
+
+/// Wraps a sent bubble's text with its chips' overlays. They follow the
+/// shaped text, so a chip that wraps gets a click target per row; its status
+/// sits on the first row, where the icon would be.
+struct ChipOverlays {
+    id: SharedString,
+    child: AnyElement,
+    layout: gpui::TextLayout,
+    overlays: Vec<ChipOverlay>,
+    open: Rc<dyn Fn(&SharedString, &mut Window, &mut gpui::App)>,
+    well: gpui::Hsla,
+}
+
+impl IntoElement for ChipOverlays {
+    type Element = Self;
+    fn into_element(self) -> Self {
+        self
+    }
+}
+
+impl gpui::Element for ChipOverlays {
+    type RequestLayoutState = ();
+    type PrepaintState = Vec<AnyElement>;
+
+    fn id(&self) -> Option<gpui::ElementId> {
+        Some(self.id.clone().into())
+    }
+
+    fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
+        None
+    }
+
+    fn request_layout(
+        &mut self,
+        _: Option<&gpui::GlobalElementId>,
+        _: Option<&gpui::InspectorElementId>,
+        window: &mut Window,
+        cx: &mut gpui::App,
+    ) -> (gpui::LayoutId, ()) {
+        (self.child.request_layout(window, cx), ())
+    }
+
+    fn prepaint(
+        &mut self,
+        _: Option<&gpui::GlobalElementId>,
+        _: Option<&gpui::InspectorElementId>,
+        _: Bounds<Pixels>,
+        _: &mut (),
+        window: &mut Window,
+        cx: &mut gpui::App,
+    ) -> Vec<AnyElement> {
+        self.child.prepaint(window, cx);
+        let mut targets = Vec::new();
+        for (index, overlay) in self.overlays.iter_mut().enumerate() {
+            let rects = render::range_rects(&self.layout, &overlay.range, 0.0, 2.0);
+            if let (Some(status), Some(first)) = (overlay.status.take(), rects.first()) {
+                // Matches `paint_chip`'s icon well.
+                let side = first.size.height - px(2.0);
+                let mut well = div()
+                    .size(side)
+                    .rounded(px(4.0))
+                    .bg(self.well)
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .child(status)
+                    .into_any_element();
+                well.prepaint_as_root(
+                    first.origin + point(px(1.0), px(1.0)),
+                    size(side, side).map(gpui::AvailableSpace::Definite),
+                    window,
+                    cx,
+                );
+                targets.push(well);
+            }
+            let Some(path) = overlay.open.clone() else {
+                continue;
+            };
+            for (part, rect) in rects.into_iter().enumerate() {
+                let open = self.open.clone();
+                let path = path.clone();
+                let mut target = div()
+                    .id(SharedString::from(format!("{}-{index}-{part}", self.id)))
+                    .w(rect.size.width)
+                    .h(rect.size.height)
+                    .cursor_pointer()
+                    .role(gpui::Role::Button)
+                    .aria_label(format!(
+                        "Preview {}",
+                        crate::attachments::attachment_display_name(
+                            path.rsplit(['/', '\\']).next().unwrap_or(&path),
+                        )
+                    ))
+                    .on_click(move |event, window, cx| {
+                        // A drag that selects text across the chip is not a click.
+                        if event.click_count() == 1
+                            && crate::markdown::selection::selected_text().is_none()
+                        {
+                            open(&path, window, cx);
+                        }
+                    })
+                    .into_any_element();
+                target.prepaint_as_root(
+                    rect.origin,
+                    rect.size.map(gpui::AvailableSpace::Definite),
+                    window,
+                    cx,
+                );
+                targets.push(target);
+            }
+        }
+        targets
+    }
+
+    fn paint(
+        &mut self,
+        _: Option<&gpui::GlobalElementId>,
+        _: Option<&gpui::InspectorElementId>,
+        _: Bounds<Pixels>,
+        _: &mut (),
+        targets: &mut Vec<AnyElement>,
+        window: &mut Window,
+        cx: &mut gpui::App,
+    ) {
+        self.child.paint(window, cx);
+        for target in targets {
+            target.paint(window, cx);
+        }
+    }
+}
+
+/// A sent message's non-image attachment: the file's icon and name on the
+/// same soft pill the transcript uses for file badges. Its bytes are never
+/// read back to the transcript, so there is no thumbnail to wait for.
+fn user_file_pill(name: &str, theme: &Theme) -> AnyElement {
+    let name = crate::attachments::attachment_display_name(name);
+    div()
+        .h(px(28.0))
+        .max_w(px(260.0))
+        .min_w_0()
+        .flex()
+        .items_center()
+        .gap(px(6.0))
+        .rounded(px(7.0))
+        .bg(theme.ink(0.06))
+        .pl(px(2.0))
+        .pr(px(10.0))
+        .text_size(px(13.0))
+        .text_color(theme.text.opacity(0.85))
+        .child(
+            div()
+                .size(px(24.0))
+                .flex_none()
+                .flex()
+                .items_center()
+                .justify_center()
+                .rounded(px(5.0))
+                .bg(crate::file_icons::well_bg(theme))
+                .child(
+                    crate::file_icons::icon(
+                        crate::file_icons::FileIconIdentity::file(name),
+                        theme.appearance,
+                    )
+                    .size(px(16.0)),
+                ),
+        )
+        .child(
+            div()
+                .min_w_0()
+                .truncate()
+                .child(SharedString::from(name.to_owned())),
+        )
         .into_any_element()
 }
 
@@ -14017,6 +14354,166 @@ mod tests {
     /// row carries the projected display text plus spans, while ordinary
     /// prompts keep the empty-spans fast path. The row version derives from
     /// the RAW text either way, so projection never perturbs the diff key.
+    /// A chip whose upload is still crossing to the host shows its progress
+    /// in place of its icon, as the strip's thumbnail did; once the bytes
+    /// land (the ref is rewritten to a local path) the icon comes back.
+    #[gpui::test]
+    fn sent_chips_show_upload_progress_until_their_bytes_land(cx: &mut gpui::TestAppContext) {
+        use zeron_proto::attachment_mentions::attachment_mention_link;
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+            crate::settings::init(crate::settings::UiSettings::default(), dir.path(), cx);
+        });
+        let state = cx.new(|_| AppState::new());
+        state.update(cx, |state, _| {
+            state.apply_transfers(vec![zeron_proto::TransferProgress {
+                upload_id: "att-1".into(),
+                file_name: "Image 1.png".into(),
+                done: 430,
+                total: 1_000,
+            }])
+        });
+        let transcript = cx.new(|cx| Transcript::new(state, cx));
+        let body = format!(
+            "compare {} with {} and {}",
+            attachment_mention_link(1, None),
+            attachment_mention_link(2, Some("notes.md")),
+            attachment_mention_link(3, Some("done.md")),
+        );
+        let raw = crate::attachments::with_attachments(
+            &body,
+            &[
+                "pending://att-1/Image 1.png".to_string(),
+                "pending://att-2/notes.md".to_string(),
+                "/uploads/ef56ab78-done.md".to_string(),
+            ],
+        );
+        let mut entry = assistant("u5", MessageStatus::Complete, vec![]);
+        entry.role = MessageRole::User;
+        entry.status = None;
+        entry.parts = vec![text_part("t0", &raw)];
+        let rows = rows_for_entry(&entry, true, false, &mut parse);
+        let RowKind::User {
+            mentions,
+            attachments,
+            ..
+        } = &rows[0].kind
+        else {
+            panic!("expected a user row");
+        };
+        assert!(attachments.is_empty());
+        let mentions = mentions.clone();
+        transcript.update(cx, |transcript, cx| {
+            let overlays = transcript.chip_overlays(&"u5".into(), &mentions, &Theme::dark(), cx);
+            // The image (43% across) and the file still crossing show a
+            // status; the landed file shows its icon.
+            assert_eq!(
+                overlays
+                    .iter()
+                    .map(|overlay| (overlay.range.clone(), overlay.status.is_some()))
+                    .collect::<Vec<_>>(),
+                [
+                    (mentions[0].range.clone(), true),
+                    (mentions[1].range.clone(), true)
+                ]
+            );
+            assert_eq!(
+                transcript.upload_status("pending://att-1/Image 1.png", cx),
+                (true, Some(43))
+            );
+            assert_eq!(
+                transcript.upload_status("/uploads/ef56ab78-done.md", cx),
+                (false, None)
+            );
+        });
+    }
+
+    /// A sent message with image, file-attachment and workspace-file chips
+    /// reads as chips in the bubble; only attachments without a chip stay in
+    /// the strip above.
+    #[test]
+    fn user_bubbles_project_attachment_chips_in_place_of_the_strip() {
+        use crate::composer::ChipKind;
+        use zeron_proto::attachment_mentions::attachment_mention_link;
+        let body = format!(
+            "compare {} with {} and {}",
+            attachment_mention_link(1, None),
+            attachment_mention_link(2, Some("notes.md")),
+            "[composer.rs](zeron-file:crates/ui/src/composer.rs)",
+        );
+        let raw = crate::attachments::with_attachments(
+            &body,
+            &[
+                "/uploads/ab12cd34-Image_1.png".to_string(),
+                "/uploads/ef56ab78-notes.md".to_string(),
+                "/uploads/0a1b2c3d-Image_3.png".to_string(),
+            ],
+        );
+        let mut entry = assistant("u4", MessageStatus::Complete, vec![]);
+        entry.role = MessageRole::User;
+        entry.status = None;
+        entry.parts = vec![text_part("t0", &raw)];
+        let rows = rows_for_entry(&entry, false, false, &mut parse);
+        let RowKind::User {
+            text,
+            mentions,
+            attachments,
+            ..
+        } = &rows[0].kind
+        else {
+            panic!("expected a user row");
+        };
+        assert!(!text.contains("zeron-") && !text.contains("Attached images"));
+        assert_eq!(
+            mentions.iter().map(|m| m.kind).collect::<Vec<_>>(),
+            [ChipKind::Image, ChipKind::File, ChipKind::File]
+        );
+        let labels: Vec<String> = mentions
+            .iter()
+            .map(|m| {
+                text[m.range.clone()]
+                    .trim_matches(|c: char| !c.is_alphanumeric())
+                    .replace('\u{a0}', " ")
+            })
+            .collect();
+        assert_eq!(labels, ["Image 1", "notes.md", "composer.rs"]);
+        // Chips stand in for their attachments: only the unchipped image is
+        // left in the strip, and each attachment chip carries its upload.
+        assert_eq!(
+            attachments
+                .iter()
+                .map(|a| a.path.as_str())
+                .collect::<Vec<_>>(),
+            ["/uploads/0a1b2c3d-Image_3.png"]
+        );
+        assert_eq!(
+            mentions
+                .iter()
+                .map(|m| m.upload.as_deref())
+                .collect::<Vec<_>>(),
+            [
+                Some("/uploads/ab12cd34-Image_1.png"),
+                Some("/uploads/ef56ab78-notes.md"),
+                None
+            ]
+        );
+
+        // A files-only send hides the placeholder body.
+        let raw = crate::attachments::with_attachments("", &["/uploads/ef56ab78-notes.md".into()]);
+        entry.parts = vec![text_part("t0", &raw)];
+        let rows = rows_for_entry(&entry, false, false, &mut parse);
+        let RowKind::User {
+            text, attachments, ..
+        } = &rows[0].kind
+        else {
+            panic!("expected a user row");
+        };
+        assert!(text.is_empty());
+        assert_eq!(attachments.len(), 1);
+    }
+
     #[test]
     fn user_rows_project_file_mentions_into_chips() {
         let raw = "look at [composer.rs](zeron-file:crates/ui/src/composer.rs) please";
@@ -14034,12 +14531,10 @@ mod tests {
         );
         assert!(text.contains("composer.rs"));
         assert_eq!(mentions.len(), 1);
-        assert!(!mentions[0].is_dir);
+        assert_eq!(mentions[0].kind, crate::composer::ChipKind::File);
         assert_eq!(mentions[0].path.as_ref(), "crates/ui/src/composer.rs");
-        assert_eq!(&text[mentions[0].range.clone()], {
-            let projected: &str = "\u{00A0}@composer.rs\u{00A0}";
-            projected
-        });
+        let chip = &text[mentions[0].range.clone()];
+        assert!(chip.starts_with('\u{00A0}') && chip.contains("composer.rs"));
         assert_eq!(rows[0].version, (raw.len() as u64) << 1);
 
         entry.parts = vec![text_part("t0", "no mentions here")];

From 3ef98ec2a3bd0b8b7e2ddb544072790a85f20a56 Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Mon, 5 Oct 2026 11:34:03 -0700
Subject: [PATCH 49/74] Bump version to v0.2.104

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 36 ++++++++++++++++++------------------
 Cargo.toml |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b45634a9cf..f6a3905224 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12797,7 +12797,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "clap",
@@ -12819,7 +12819,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "async-trait",
  "chrono",
@@ -12843,7 +12843,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "chrono",
  "loro",
@@ -12857,7 +12857,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12898,7 +12898,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12925,14 +12925,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12950,7 +12950,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "serde",
  "serde_json",
@@ -12967,7 +12967,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -12995,7 +12995,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -13006,7 +13006,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13025,7 +13025,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -13048,7 +13048,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -13082,7 +13082,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -13099,7 +13099,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "clap",
@@ -13114,7 +13114,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -13182,7 +13182,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "futures",
@@ -13198,7 +13198,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "cpal",
diff --git a/Cargo.toml b/Cargo.toml
index 5b2f4f37b5..47682c6295 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.103"
+version = "0.2.104"
 edition = "2024"
 license = "MIT"
 publish = false

From 16d42a6352ee82de838cd65e294dd8d4be79d96d Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Mon, 5 Oct 2026 18:46:21 +0000
Subject: [PATCH 50/74] Simplify README and refresh its screenshot

Lead with the desktop downloads per platform and present the curl
installer as the headless (Linux server) option.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                            |  56 +++++++++------------------
 README.zh-CN.md                      |  46 ++++++++++------------
 docs/media/readme/app-screenshot.jpg | Bin 0 -> 575140 bytes
 3 files changed, 39 insertions(+), 63 deletions(-)
 create mode 100644 docs/media/readme/app-screenshot.jpg

diff --git a/README.md b/README.md
index 8ff826fcfd..00ff866aa4 100644
--- a/README.md
+++ b/README.md
@@ -4,22 +4,28 @@ Control your coding agents (Claude Code, Codex, Cursor, Devin, Grok, Hermes, Pi,
 
 *English | [简体中文](README.zh-CN.md)*
 
-![Zeron driving a Claude Code session with a live branch diff sidebar](apps/landing/public/assets/app-screenshot.jpg)
+![Zeron desktop app](docs/media/readme/app-screenshot.jpg)
 
-Every device runs a small engine that stores sessions on that device. A new installation starts in local-only mode without an account or a network connection.
+## Desktop app
 
-## Install and run locally (Linux)
+Download the latest release for your platform from [GitHub Releases](https://github.com/zeronsh/zeron/releases/latest):
+
+- **macOS** — `zeron-<version>-macos-arm64.dmg`
+- **Windows** — `zeron-<version>-windows-x86_64-setup.exe`
+- **Linux** — `zeron-<version>-linux-<arch>.tar.gz`, then run its `install.sh`
+
+No account or network connection is needed; sessions stay on your device. The app updates itself.
+
+## Headless (CLI)
+
+For servers and other machines without a display, such as a VPS that keeps agents running after you close your laptop. Linux only:
 
 ```bash
 curl -fsSL https://zeron.sh/install.sh | sh
 zeron status
 ```
 
-The installer starts the daemon immediately and keeps it running across reboots. No sign-in or sync configuration is required. It also adds Zeron to your application launcher: a per-user `zeron.desktop` and icon under `~/.local/share` (or `$XDG_DATA_HOME`), rewritten each time the installer runs. Linux requires the system ALSA runtime (`libasound.so.2`), including for headless mode because it shares the desktop executable. The installer checks that the binary starts before activating it and reports missing runtime libraries.
-
-The desktop sidebar browser also needs the [Linux browser runtime](docs/reference/linux-browser.md).
-
-Day-to-day:
+The installer starts the engine as a background service that survives reboots.
 
 ```bash
 zeron status      # local/synced mode and engine status
@@ -27,45 +33,21 @@ zeron update      # update to the latest release
 zeron daemon start|stop|restart|status
 ```
 
-## Optional multi-device sync
-
-Sign in only when you want to open your account's synced workspace. Authentication changes the profile selected by the next engine start, so stop the daemon before changing it:
-
-```bash
-zeron daemon stop
-zeron login
-zeron daemon start
-```
-
-You can then start an agent on one synced device and follow or drive it from another. An always-on machine such as a VPS can keep those agents working after you close your laptop.
+## Multi-device sync (optional)
 
-Devices signed in to the same synced account are trusted with remote workspace access. A device controlling a workspace on another device can list, read, and write its files; enabling `Show ignored files` also makes gitignored files such as `.env` available remotely. `.git` is always excluded. Only sign in devices you trust with the full contents of your workspaces.
-
-Signing in does not upload, move, or import existing local sessions. Local sessions and their attachments remain under the local profile and reappear when you return to local-only mode:
+Sign in to start an agent on one device and follow or drive it from another:
 
 ```bash
 zeron daemon stop
-zeron logout
+zeron login        # or: zeron logout to return to local-only
 zeron daemon start
 ```
 
-`zeron login` and `zeron logout` refuse to modify credentials while an engine owns the data directory. The desktop app follows the same next-restart profile boundary.
-
-On macOS: use the desktop release, or build `zeron` from source and run `zeron daemon install` to install the launchd service.
-
-On Windows: run the `zeron-<version>-windows-x86_64-setup.exe` installer from the [latest release](https://github.com/zeronsh/zeron/releases/latest). It installs for your user without administrator rights, adds Zeron to the Start menu, and appears in Settings → Apps for uninstalling. A portable ZIP is also published; keep `zeron-update.json` beside `zeron.exe` for in-app updates. See the [development notes](docs/reference/windows-development.md) for source builds.
-
-## Updates
-
-The desktop app checks for a new release when it starts, every hour while it runs, and when you come back to it after the machine slept. A new version downloads in the background; the sidebar then offers **Update ready — restart to apply**, and if you don't restart, it installs the next time you quit Zeron. Check by hand with **Zeron → Check for Updates…** on macOS, or **Check for updates** in the account menu (bottom of the sidebar) on Windows and Linux. Set `ZERON_AUTO_UPDATE=0` to be notified without the background download.
-
-Linux desktop installs from the release tarball's `install.sh` use the same `~/.zeron/app` layout as the curl installer, so they update in place too. A daemon installed as a service restarts into a newer installed version once no agent run or terminal is active; `zeron update` updates headless installs on demand.
+Devices signed in to the same account can read and write each other's workspace files, so only sign in devices you trust. Existing local sessions are never uploaded.
 
 ## Sponsors
 
-Thank you to [The Context Company](https://www.thecontextcompany.com/) for sponsoring Zeron.
-
-You can help fund Zeron's development too. Individuals and companies are welcome to [become a sponsor on GitHub](https://github.com/sponsors/zeronsh).
+Thank you to [The Context Company](https://www.thecontextcompany.com/) for sponsoring Zeron. You can help fund Zeron's development too by [becoming a sponsor on GitHub](https://github.com/sponsors/zeronsh).
 
 ---
 
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 420b65373d..308a32bac9 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -1,23 +1,31 @@
 # Zeron
 
-在本地管理你的编码 agent（Claude Code、Codex、Cursor、Grok、Hermes、Pi、Antigravity），也可以打开多设备同步。
+在本地管理你的编码 agent（Claude Code、Codex、Cursor、Devin、Grok、Hermes、Pi、Antigravity），也可以打开多设备同步。
 
 *[English](README.md) | 简体中文*
 
-![Zeron 驱动一个 Claude Code 会话，侧边栏是实时的分支 diff](apps/landing/public/assets/app-screenshot.jpg)
+![Zeron 桌面应用](docs/media/readme/app-screenshot.jpg)
 
-每台设备各跑一个小引擎，会话就存在这台设备上。装完默认是纯本地模式，不用账号，也不用联网。
+## 桌面应用
 
-## 在本地安装运行（Linux）
+从 [GitHub Releases](https://github.com/zeronsh/zeron/releases/latest) 下载对应平台的最新版本：
+
+- **macOS** — `zeron-<version>-macos-arm64.dmg`
+- **Windows** — `zeron-<version>-windows-x86_64-setup.exe`
+- **Linux** — `zeron-<version>-linux-<arch>.tar.gz`，解压后运行里面的 `install.sh`
+
+不用账号，也不用联网，会话就存在这台设备上。应用会自动更新。
+
+## 无界面运行（CLI）
+
+适用于服务器等没有显示器的机器，比如在你合上笔记本之后继续跑 agent 的 VPS。仅支持 Linux：
 
 ```bash
 curl -fsSL https://zeron.sh/install.sh | sh
 zeron status
 ```
 
-安装脚本会马上把守护进程拉起来，重启之后也会自己回来。不需要登录，也不需要配置同步。它还会把 Zeron 加入应用启动器：在 `~/.local/share`（或 `$XDG_DATA_HOME`）下写入用户级的 `zeron.desktop` 和图标，每次运行安装脚本都会重写。
-
-日常命令：
+安装脚本会把引擎作为后台服务拉起来，重启之后也会自己回来。
 
 ```bash
 zeron status      # 查看本地/同步模式和引擎状态
@@ -25,35 +33,21 @@ zeron update      # 更新到最新版本
 zeron daemon start|stop|restart|status
 ```
 
-## 可选：多设备同步
-
-只有想打开账号下的同步工作区时才需要登录。登录会换掉引擎下次启动时用的 profile，所以改之前先停掉守护进程：
-
-```bash
-zeron daemon stop
-zeron login
-zeron daemon start
-```
-
-之后就可以在一台同步过的设备上起 agent，换另一台设备接着看、接着操作。一台常开的机器，比如 VPS，可以在你合上笔记本之后继续跑这些 agent。
+## 多设备同步（可选）
 
-登录不会上传、搬走或导入已有的本地会话。本地会话和它们的附件仍然留在本地 profile 下，切回纯本地模式时会照常出现：
+登录后，可以在一台设备上起 agent，换另一台设备接着看、接着操作：
 
 ```bash
 zeron daemon stop
-zeron logout
+zeron login        # 或者 zeron logout 切回纯本地模式
 zeron daemon start
 ```
 
-如果有引擎正占着数据目录，`zeron login` 和 `zeron logout` 会拒绝改动凭据。桌面应用同样遵守这条边界：profile 要等下次重启才切换。
-
-macOS 上用桌面版发行包，或者从源码构建 `zeron`，再运行 `zeron daemon install` 装上 launchd 服务。
+登录同一账号的设备可以读写彼此工作区里的文件，所以只登录你信任的设备。已有的本地会话不会被上传。
 
 ## 赞助
 
-感谢 [The Context Company](https://www.thecontextcompany.com/) 对 Zeron 的赞助。
-
-你也可以资助 Zeron 的开发。欢迎个人和公司[通过 GitHub 成为赞助者](https://github.com/sponsors/zeronsh)。
+感谢 [The Context Company](https://www.thecontextcompany.com/) 对 Zeron 的赞助。你也可以[通过 GitHub 成为赞助者](https://github.com/sponsors/zeronsh)，资助 Zeron 的开发。
 
 ---
 
diff --git a/docs/media/readme/app-screenshot.jpg b/docs/media/readme/app-screenshot.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ff87820e45d2ef3e689fdb116ba501f0fa265a02
GIT binary patch
literal 575140
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
SOwvPb1Po){uQR<xpa0qD&8(>a

literal 0
HcmV?d00001


From 9ac03a54b36eddc43941d355d5723adb8357b494 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Mon, 5 Oct 2026 18:49:26 +0000
Subject: [PATCH 51/74] Add Korean and Japanese READMEs

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.ja.md    | 56 +++++++++++++++++++++++++++++++++++++++++++++++++
 README.ko.md    | 56 +++++++++++++++++++++++++++++++++++++++++++++++++
 README.md       |  2 +-
 README.zh-CN.md |  2 +-
 4 files changed, 114 insertions(+), 2 deletions(-)
 create mode 100644 README.ja.md
 create mode 100644 README.ko.md

diff --git a/README.ja.md b/README.ja.md
new file mode 100644
index 0000000000..e2b7fa3acf
--- /dev/null
+++ b/README.ja.md
@@ -0,0 +1,56 @@
+# Zeron
+
+コーディングエージェント（Claude Code、Codex、Cursor、Devin、Grok、Hermes、Pi、Antigravity）をデフォルトではローカルで管理し、必要に応じて複数デバイス間で同期することもできます。
+
+*[English](README.md) | [简体中文](README.zh-CN.md) | [한국어](README.ko.md) | 日本語*
+
+![Zeron デスクトップアプリ](docs/media/readme/app-screenshot.jpg)
+
+## デスクトップアプリ
+
+[GitHub Releases](https://github.com/zeronsh/zeron/releases/latest) から、お使いのプラットフォーム向けの最新版をダウンロードしてください。
+
+- **macOS** — `zeron-<version>-macos-arm64.dmg`
+- **Windows** — `zeron-<version>-windows-x86_64-setup.exe`
+- **Linux** — `zeron-<version>-linux-<arch>.tar.gz` を展開し、中の `install.sh` を実行
+
+アカウントもネットワーク接続も不要で、セッションはお使いのデバイスに保存されます。アプリは自動でアップデートされます。
+
+## ヘッドレス実行（CLI）
+
+サーバーなど、ディスプレイのないマシン向けです。たとえば、ノートパソコンを閉じたあともエージェントを動かし続ける VPS に使えます。Linux のみ対応しています。
+
+```bash
+curl -fsSL https://zeron.sh/install.sh | sh
+zeron status
+```
+
+インストーラーはエンジンをバックグラウンドサービスとして起動し、再起動後も自動的に立ち上がります。
+
+```bash
+zeron status      # ローカル/同期モードとエンジンの状態を確認
+zeron update      # 最新版にアップデート
+zeron daemon start|stop|restart|status
+```
+
+## 複数デバイス間の同期（任意）
+
+サインインすると、あるデバイスで起動したエージェントを別のデバイスから確認したり操作したりできます。
+
+```bash
+zeron daemon stop
+zeron login        # ローカル専用モードに戻すには zeron logout
+zeron daemon start
+```
+
+同じアカウントにサインインしたデバイスは、互いのワークスペースのファイルを読み書きできます。信頼できるデバイスでのみサインインしてください。既存のローカルセッションがアップロードされることはありません。
+
+## スポンサー
+
+Zeron をスポンサーしてくださっている [The Context Company](https://www.thecontextcompany.com/) に感謝します。[GitHub でスポンサーになって](https://github.com/sponsors/zeronsh) Zeron の開発を支援することもできます。
+
+---
+
+開発に参加したい方や仕組みが気になる方は、[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zeronsh/zeron) または [ARCHITECTURE.md](ARCHITECTURE.md) をご覧ください。
+
+[MIT License](LICENSE) のもとで公開されています。
diff --git a/README.ko.md b/README.ko.md
new file mode 100644
index 0000000000..e4e611c2bf
--- /dev/null
+++ b/README.ko.md
@@ -0,0 +1,56 @@
+# Zeron
+
+코딩 에이전트(Claude Code, Codex, Cursor, Devin, Grok, Hermes, Pi, Antigravity)를 기본적으로 로컬에서 관리하고, 필요하면 여러 기기 간 동기화도 사용할 수 있습니다.
+
+*[English](README.md) | [简体中文](README.zh-CN.md) | 한국어 | [日本語](README.ja.md)*
+
+![Zeron 데스크톱 앱](docs/media/readme/app-screenshot.jpg)
+
+## 데스크톱 앱
+
+[GitHub Releases](https://github.com/zeronsh/zeron/releases/latest)에서 플랫폼에 맞는 최신 버전을 내려받으세요.
+
+- **macOS** — `zeron-<version>-macos-arm64.dmg`
+- **Windows** — `zeron-<version>-windows-x86_64-setup.exe`
+- **Linux** — `zeron-<version>-linux-<arch>.tar.gz`의 압축을 풀고 안에 있는 `install.sh` 실행
+
+계정이나 네트워크 연결이 필요 없으며, 세션은 사용 중인 기기에 저장됩니다. 앱은 자동으로 업데이트됩니다.
+
+## 헤드리스 실행 (CLI)
+
+서버처럼 디스플레이가 없는 머신용입니다. 예를 들어 노트북을 닫은 뒤에도 에이전트를 계속 돌려 두는 VPS에 쓰면 됩니다. Linux만 지원합니다.
+
+```bash
+curl -fsSL https://zeron.sh/install.sh | sh
+zeron status
+```
+
+설치 스크립트는 엔진을 백그라운드 서비스로 실행하며, 재부팅 후에도 자동으로 다시 시작됩니다.
+
+```bash
+zeron status      # 로컬/동기화 모드와 엔진 상태 확인
+zeron update      # 최신 버전으로 업데이트
+zeron daemon start|stop|restart|status
+```
+
+## 여러 기기 간 동기화 (선택)
+
+로그인하면 한 기기에서 에이전트를 시작하고 다른 기기에서 이어서 보거나 조작할 수 있습니다.
+
+```bash
+zeron daemon stop
+zeron login        # 로컬 전용 모드로 돌아가려면 zeron logout
+zeron daemon start
+```
+
+같은 계정에 로그인한 기기끼리는 서로의 워크스페이스 파일을 읽고 쓸 수 있으므로, 신뢰하는 기기에서만 로그인하세요. 기존 로컬 세션은 업로드되지 않습니다.
+
+## 후원
+
+Zeron을 후원해 주신 [The Context Company](https://www.thecontextcompany.com/)에 감사드립니다. [GitHub에서 후원자가 되어](https://github.com/sponsors/zeronsh) Zeron 개발을 지원하실 수도 있습니다.
+
+---
+
+개발에 참여하고 싶거나 동작 방식이 궁금하다면 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zeronsh/zeron) 또는 [ARCHITECTURE.md](ARCHITECTURE.md)를 확인하세요.
+
+[MIT License](LICENSE)로 배포됩니다.
diff --git a/README.md b/README.md
index 00ff866aa4..55c212653c 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 Control your coding agents (Claude Code, Codex, Cursor, Devin, Grok, Hermes, Pi, Antigravity) locally by default, with optional multi-device sync.
 
-*English | [简体中文](README.zh-CN.md)*
+*English | [简体中文](README.zh-CN.md) | [한국어](README.ko.md) | [日本語](README.ja.md)*
 
 ![Zeron desktop app](docs/media/readme/app-screenshot.jpg)
 
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 308a32bac9..2b16fc4daa 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -2,7 +2,7 @@
 
 在本地管理你的编码 agent（Claude Code、Codex、Cursor、Devin、Grok、Hermes、Pi、Antigravity），也可以打开多设备同步。
 
-*[English](README.md) | 简体中文*
+*[English](README.md) | 简体中文 | [한국어](README.ko.md) | [日本語](README.ja.md)*
 
 ![Zeron 桌面应用](docs/media/readme/app-screenshot.jpg)
 

From c8eb7524e06d8483c2c9054a8180b61e19256a74 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Mon, 5 Oct 2026 18:56:01 +0000
Subject: [PATCH 52/74] README: replace broken DeepWiki badge with a text link

deepwiki.com/badge.svg now sits behind a Vercel bot checkpoint, so
GitHub's image proxy gets an HTML challenge page and renders a broken
image.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.ja.md    | 2 +-
 README.ko.md    | 2 +-
 README.md       | 2 +-
 README.zh-CN.md | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.ja.md b/README.ja.md
index e2b7fa3acf..793e01cde5 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -51,6 +51,6 @@ Zeron をスポンサーしてくださっている [The Context Company](https:
 
 ---
 
-開発に参加したい方や仕組みが気になる方は、[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zeronsh/zeron) または [ARCHITECTURE.md](ARCHITECTURE.md) をご覧ください。
+開発に参加したい方や仕組みが気になる方は、[Ask DeepWiki](https://deepwiki.com/zeronsh/zeron) または [ARCHITECTURE.md](ARCHITECTURE.md) をご覧ください。
 
 [MIT License](LICENSE) のもとで公開されています。
diff --git a/README.ko.md b/README.ko.md
index e4e611c2bf..22077c0dee 100644
--- a/README.ko.md
+++ b/README.ko.md
@@ -51,6 +51,6 @@ Zeron을 후원해 주신 [The Context Company](https://www.thecontextcompany.co
 
 ---
 
-개발에 참여하고 싶거나 동작 방식이 궁금하다면 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zeronsh/zeron) 또는 [ARCHITECTURE.md](ARCHITECTURE.md)를 확인하세요.
+개발에 참여하고 싶거나 동작 방식이 궁금하다면 [Ask DeepWiki](https://deepwiki.com/zeronsh/zeron) 또는 [ARCHITECTURE.md](ARCHITECTURE.md)를 확인하세요.
 
 [MIT License](LICENSE)로 배포됩니다.
diff --git a/README.md b/README.md
index 55c212653c..257b15a696 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,6 @@ Thank you to [The Context Company](https://www.thecontextcompany.com/) for spons
 
 ---
 
-Developing or curious how it works? [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zeronsh/zeron) or check out [ARCHITECTURE.md](ARCHITECTURE.md).
+Developing or curious how it works? [Ask DeepWiki](https://deepwiki.com/zeronsh/zeron) or check out [ARCHITECTURE.md](ARCHITECTURE.md).
 
 Licensed under the [MIT License](LICENSE).
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 2b16fc4daa..8af544bd97 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -51,6 +51,6 @@ zeron daemon start
 
 ---
 
-想参与开发，或者好奇它怎么跑起来的？[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zeronsh/zeron)，也可以看 [ARCHITECTURE.md](ARCHITECTURE.md)。
+想参与开发，或者好奇它怎么跑起来的？[Ask DeepWiki](https://deepwiki.com/zeronsh/zeron)，也可以看 [ARCHITECTURE.md](ARCHITECTURE.md)。
 
 采用 [MIT License](LICENSE)。

From 3d4bfd11b042948beb628fe8d5587ebe43b46035 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Mon, 5 Oct 2026 13:44:32 -0700
Subject: [PATCH 53/74] Unify the sidebar project filter by repository identity
 (#811)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The sidebar's project filter still listed one row per checkout ("anara @
work-metal", "anara @ work-laptop"). It now lists one row per repository
across devices — named for its representative checkout, tagged with the
devices holding it ("@ work-metal · work-laptop", or "@ N devices") — and
filtering on it shows every checkout's sessions, in the list, the
Archived shelf and pin-drag validation alike.

The setting still stores one checkout's space id (this device's first),
so existing saved filters keep working and simply widen to their
repository; new sessions from the filter land on that local checkout.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ui/src/shell/spaces.rs | 119 ++++++++++++++++++-----------
 crates/ui/src/state.rs        | 139 +++++++++++++++++++++++++++++++++-
 2 files changed, 210 insertions(+), 48 deletions(-)

diff --git a/crates/ui/src/shell/spaces.rs b/crates/ui/src/shell/spaces.rs
index 3b437e1870..de9b56ad0e 100644
--- a/crates/ui/src/shell/spaces.rs
+++ b/crates/ui/src/shell/spaces.rs
@@ -3190,15 +3190,12 @@ impl Shell {
             return false;
         }
         let current_pins = self.sidebar_pins_for_profile(&drag.profile_key, cx);
-        let visible_ids: HashSet<String> = self
-            .state
-            .read(cx)
+        let state = self.state.read(cx);
+        let in_filter = state.project_filter(drag.filter.as_deref());
+        let visible_ids: HashSet<String> = state
             .overview_chats(Utc::now())
             .into_iter()
-            .filter(|(_, chat)| match &drag.filter {
-                Some(space_id) => chat.space_id.as_deref() == Some(space_id.as_str()),
-                None => true,
-            })
+            .filter(|(_, chat)| in_filter(chat))
             .map(|(_, chat)| chat.id.clone())
             .collect();
         let current_ids = current_pins
@@ -3217,10 +3214,12 @@ impl Shell {
         }
     }
 
-    /// The filter's scrollable rows: "All projects", then spaces matching
-    /// the search (ranked — `popover::filter_indices`). "All" only shows on
-    /// an empty query (searching means hunting a space). The "New project…"
-    /// action is not a row here — the card renders it as a pinned footer.
+    /// The filter's scrollable rows: "All projects", then projects matching
+    /// the search (ranked — `popover::filter_indices`) — one row per
+    /// repository across devices, carrying its local-first checkout's id. "All"
+    /// only shows on an empty query (searching means hunting a project). The
+    /// "New project…" action is not a row here — the card renders it as a
+    /// pinned footer.
     fn spaces_menu_rows(&self, cx: &App) -> Vec<SpacesMenuRow> {
         let query = self
             .spaces_menu
@@ -3228,10 +3227,10 @@ impl Shell {
             .map(|menu| menu.search.read(cx).text().to_string())
             .unwrap_or_default();
         let state = self.state.read(cx);
-        let spaces = state.spaces_sorted();
-        let names: Vec<String> = spaces
+        let projects = state.projects();
+        let names: Vec<String> = projects
             .iter()
-            .map(|s| s.display_name().to_string())
+            .map(|members| state.representative_space(members[0]).display_name().to_string())
             .collect();
         let mut rows: Vec<SpacesMenuRow> = Vec::new();
         if query.trim().is_empty() {
@@ -3240,11 +3239,31 @@ impl Shell {
         rows.extend(
             popover::filter_indices(&query, &names)
                 .into_iter()
-                .map(|ix| SpacesMenuRow::Space(spaces[ix].id.clone())),
+                .map(|ix| SpacesMenuRow::Space(projects[ix][0].id.clone())),
         );
         rows
     }
 
+    /// The repository the sidebar filter names, if any — any checkout's row
+    /// selects (and reads as) the whole project.
+    fn space_filter_key(&self, cx: &App) -> Option<String> {
+        let state = self.state.read(cx);
+        let id = self.settings.space_filter.as_deref()?;
+        Some(
+            state
+                .space_row(id)
+                .map_or_else(|| id.to_owned(), zeron_proto::view::project_key),
+        )
+    }
+
+    /// The project key of a menu row's space id.
+    fn space_row_key(&self, id: &str, cx: &App) -> String {
+        self.state
+            .read(cx)
+            .space_row(id)
+            .map_or_else(|| id.to_owned(), zeron_proto::view::project_key)
+    }
+
     fn open_spaces_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         self.close_sidebar_view_menu(cx);
         // "PaletteSearch" context: ↑↓/⏎ stay unbound in the input and bubble
@@ -3260,7 +3279,7 @@ impl Shell {
             }
         });
         // The highlight starts ON the current filter row.
-        let current = self.settings.space_filter.clone();
+        let current = self.space_filter_key(cx);
         let handle = search.read(cx).focus_handle(cx);
         self.spaces_menu.open(SpacesMenu {
             search,
@@ -3275,9 +3294,9 @@ impl Shell {
         let rows = self.spaces_menu_rows(cx);
         let start = match &current {
             None => 0,
-            Some(id) => rows
+            Some(key) => rows
                 .iter()
-                .position(|row| matches!(row, SpacesMenuRow::Space(s) if s == id))
+                .position(|row| matches!(row, SpacesMenuRow::Space(s) if self.space_row_key(s, cx) == *key))
                 .unwrap_or(0),
         };
         if let Some(menu) = self.spaces_menu.open_mut() {
@@ -3917,9 +3936,14 @@ impl Shell {
             let state = self.state.read(cx);
             match filter.as_deref().and_then(|id| state.space_row(id)) {
                 Some(space) => {
-                    let (tag, offline) = state.space_device_tag(space, Utc::now());
+                    let members = state.project_members(space);
+                    let (tag, offline) = state.project_device_tag(&members, Utc::now());
                     (
-                        space.display_name().to_string().into(),
+                        state
+                            .representative_space(space)
+                            .display_name()
+                            .to_string()
+                            .into(),
                         Some((tag.into(), offline)),
                     )
                 }
@@ -4126,9 +4150,10 @@ impl Shell {
         let rows = self.spaces_menu_rows(cx);
         let scrollbar = popover::rail(self, "spaces-menu-scrollbar", theme, cx);
         let filter = self.settings.space_filter.clone();
-        // Keep the host tag so projects with the same name on different
-        // devices remain distinguishable. Consume `rows` to avoid cloning
-        // the list children per frame.
+        let filter_key = self.space_filter_key(cx);
+        // Each row is a whole repository: its name, and the devices holding a
+        // checkout so same-named projects stay distinguishable. Consume `rows`
+        // to avoid cloning the list children per frame.
         let details: Vec<(
             SpacesMenuRow,
             SharedString,
@@ -4146,28 +4171,35 @@ impl Shell {
                         false,
                         filter.is_none(),
                     ),
-                    SpacesMenuRow::Space(id) => {
-                        let selected = filter.as_deref() == Some(id.as_str());
-                        match state.space_row(&id) {
-                            Some(space) => {
-                                let (tag, offline) = state.space_device_tag(space, Utc::now());
-                                (
-                                    SpacesMenuRow::Space(id),
-                                    space.display_name().to_string().into(),
-                                    Some(tag.into()),
-                                    offline,
-                                    selected,
-                                )
-                            }
-                            None => (
+                    SpacesMenuRow::Space(id) => match state.space_row(&id) {
+                        Some(space) => {
+                            let key = zeron_proto::view::project_key(space);
+                            let selected = filter_key.as_deref() == Some(key.as_str());
+                            let members = state.project_members(space);
+                            let (tag, offline) = state.project_device_tag(&members, Utc::now());
+                            (
+                                SpacesMenuRow::Space(id),
+                                state
+                                    .representative_space(space)
+                                    .display_name()
+                                    .to_string()
+                                    .into(),
+                                Some(tag.into()),
+                                offline,
+                                selected,
+                            )
+                        }
+                        None => {
+                            let selected = filter.as_deref() == Some(id.as_str());
+                            (
                                 SpacesMenuRow::Space(id),
                                 SharedString::from("?"),
                                 None,
                                 false,
                                 selected,
-                            ),
+                            )
                         }
-                    }
+                    },
                     // spaces_menu_rows never yields this variant — the
                     // footer is rendered by the card, not the list.
                     SpacesMenuRow::AddSpace => unreachable!(),
@@ -5287,16 +5319,15 @@ impl Shell {
 
     /// The Archived shelf's chats under the project filter, in sidebar order.
     fn archived_sidebar_chats(&self, cx: &App) -> Vec<zeron_proto::Chat> {
-        let filter = self.settings.space_filter.as_deref();
-        let mut rows: Vec<zeron_proto::Chat> = self
-            .state
-            .read(cx)
+        let state = self.state.read(cx);
+        let in_filter = state.project_filter(self.settings.space_filter.as_deref());
+        let mut rows: Vec<zeron_proto::Chat> = state
             .chats
             .iter()
             // Spawned children stay out of the Archived section too — the
             // same top-level rule as `visible_chats`.
             .filter(|c| c.archived && c.parent_chat_id.is_none())
-            .filter(|chat| filter.is_none_or(|space_id| chat.space_id.as_deref() == Some(space_id)))
+            .filter(|chat| in_filter(chat))
             .cloned()
             .collect();
         rows.sort_by(|left, right| compare_sidebar_chats(self.settings.sidebar_sort, left, right));
diff --git a/crates/ui/src/state.rs b/crates/ui/src/state.rs
index db5709b560..604c79ff53 100644
--- a/crates/ui/src/state.rs
+++ b/crates/ui/src/state.rs
@@ -2010,15 +2010,88 @@ impl AppState {
         now: DateTime<Utc>,
         space_filter: Option<&str>,
     ) -> Vec<(ChatIndicator, &Chat)> {
+        let in_filter = self.project_filter(space_filter);
         self.overview_chats(now)
             .into_iter()
-            .filter(|(_, chat)| match space_filter {
-                Some(space_id) => chat.space_id.as_deref() == Some(space_id),
-                None => true,
-            })
+            .filter(|(_, chat)| in_filter(chat))
             .collect()
     }
 
+    /// The sidebar's project filter matches by repository: it stores one
+    /// checkout's space id, and a chat in ANY checkout of that repository
+    /// (clones and worktrees on every device, [`zeron_proto::view::project_key`])
+    /// matches. A filter naming a space not synced here matches its own id.
+    pub fn project_filter<'a>(&'a self, filter: Option<&str>) -> impl Fn(&Chat) -> bool + 'a {
+        let filter = filter.map(|id| {
+            (
+                id.to_owned(),
+                self.space_row(id).map(zeron_proto::view::project_key),
+            )
+        });
+        move |chat| {
+            let Some((id, key)) = &filter else {
+                return true;
+            };
+            match chat.space_id.as_deref() {
+                Some(space_id) if space_id == id => true,
+                Some(space_id) => key.as_ref().is_some_and(|key| {
+                    self.space_row(space_id)
+                        .is_some_and(|space| zeron_proto::view::project_key(space) == *key)
+                }),
+                None => false,
+            }
+        }
+    }
+
+    /// Every project — one per repository across devices — as its checkouts
+    /// in [`Self::project_members`] order (this device's first), ordered by
+    /// the project's name.
+    pub fn projects(&self) -> Vec<Vec<&Space>> {
+        let mut seen = std::collections::HashSet::new();
+        let mut projects: Vec<Vec<&Space>> = self
+            .spaces
+            .iter()
+            .filter(|space| seen.insert(zeron_proto::view::project_key(space)))
+            .map(|space| self.project_members(space))
+            .collect();
+        projects.sort_by_key(|members| {
+            let representative = self.representative_space(members[0]);
+            (
+                representative.display_name().to_lowercase(),
+                representative.id.clone(),
+            )
+        });
+        projects
+    }
+
+    /// A project's host tag: its one device as in [`Self::space_device_tag`],
+    /// else the devices holding a checkout. Offline only when every one is.
+    pub fn project_device_tag(&self, members: &[&Space], now: DateTime<Utc>) -> (String, bool) {
+        let mut devices: Vec<&str> = Vec::new();
+        for member in members {
+            if !devices.contains(&member.device_id.as_str()) {
+                devices.push(member.device_id.as_str());
+            }
+        }
+        match devices.as_slice() {
+            [] => (String::new(), false),
+            [_] => self.space_device_tag(members[0], now),
+            _ => {
+                let offline = devices.iter().all(|d| !self.device_online(d, now));
+                let tag = if devices.len() == 2 {
+                    devices
+                        .iter()
+                        .map(|d| self.device_name(d).unwrap_or("Unknown device"))
+                        .collect::<Vec<_>>()
+                        .join(" · ")
+                } else {
+                    format!("{} devices", devices.len())
+                };
+                (format!("@ {tag}"), offline)
+            }
+        }
+    }
+
     pub fn session_for(&self, chat_id: &str) -> Option<&Session> {
         self.sessions.iter().find(|s| s.chat_id == chat_id)
     }
@@ -4651,6 +4724,64 @@ mod tests {
         assert_eq!(overview, ["old", "new", "dangling"]);
     }
 
+    #[test]
+    fn project_filter_and_projects_span_a_repository_across_devices() {
+        let mut state = AppState::new();
+        state.local_device_id = Some("laptop".into());
+        let mut remote = space("remote", "metal", "/w/anara", 1);
+        remote.repository_id = Some("commit:abc".into());
+        let mut local = space("local", "laptop", "/h/anara", 2);
+        local.repository_id = Some("commit:abc".into());
+        let other = space("other", "laptop", "/h/notes", 3);
+        state.apply_spaces(vec![remote, local, other]);
+        let in_space = |id: &str, space: &str| {
+            let mut chat = chat(id, 0, None);
+            chat.space_id = Some(space.into());
+            chat
+        };
+        state.apply_chats(vec![
+            in_space("on-remote", "remote"),
+            in_space("on-local", "local"),
+            in_space("on-other", "other"),
+        ]);
+
+        // One project per repository, its checkouts local-first.
+        let projects: Vec<Vec<&str>> = state
+            .projects()
+            .iter()
+            .map(|members| members.iter().map(|s| s.id.as_str()).collect())
+            .collect();
+        assert_eq!(projects, vec![vec!["local", "remote"], vec!["other"]]);
+
+        // Filtering on either checkout shows the whole repository's chats.
+        for filter in ["remote", "local"] {
+            let mut ids: Vec<&str> = state
+                .sidebar_chats(Utc::now(), Some(filter))
+                .iter()
+                .map(|(_, c)| c.id.as_str())
+                .collect();
+            ids.sort();
+            assert_eq!(ids, ["on-local", "on-remote"], "filter {filter}");
+        }
+        let other_only: Vec<&str> = state
+            .sidebar_chats(Utc::now(), Some("other"))
+            .iter()
+            .map(|(_, c)| c.id.as_str())
+            .collect();
+        assert_eq!(other_only, ["on-other"]);
+
+        // A two-device project tags both hosts; a one-device one keeps the
+        // plain host tag.
+        let anara = state.projects().into_iter().next().unwrap();
+        let (tag, _) = state.project_device_tag(&anara, Utc::now());
+        assert!(tag.starts_with("@ ") && tag.contains(" · "), "{tag}");
+        let notes = state.projects().into_iter().nth(1).unwrap();
+        assert_eq!(
+            state.project_device_tag(&notes, Utc::now()).0,
+            state.space_device_tag(notes[0], Utc::now()).0
+        );
+    }
+
     #[test]
     fn apply_chats_drops_vanished_selection() {
         let mut state = AppState::new();

From d5c1cdc124c8d403eb0a11e94a8dae4a381fc958 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Tue, 6 Oct 2026 04:27:22 -0300
Subject: [PATCH 54/74] Pin chip padding to Geist so insets don't follow the UI
 font (#816)

* Pin chip padding to Geist so insets don't follow the UI font

A chip reserves its icon slot and insets with non-breaking spaces shaped
in the interface font. The counts are tuned to Geist, whose space is
0.25em; with a monospaced UI font like Geist Mono (0.6em) every chip
grew ~2.4x wider padding, leaving a wide gap between the icon well and
the label.

The padding runs are now shaped in the bundled Geist in the composer,
sent user bubbles and queue rows, while the label keeps the interface
font. Geist and Geist Mono share vertical metrics, so line boxes don't
move.

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

* Center chips on their label's caps whatever the interface font

paint_chip assumed Geist's metrics put the label's cap height on the
row's middle. Other interface fonts move the baseline (the line takes the
tallest face's ascent and descent) and GPUI rounds it to a device pixel,
so chips could sit a pixel off their label (Noto Sans Mono: 1px low).
Each chip row now moves its pill to the label face's cap middle, from the
shaped line's metrics and the rounded baseline, in the composer, sent
bubbles and queue rows.

Also: tests that the padding, and only the padding, is shaped in Geist
in the composer, bubbles and queue overrides; the stale "narrow" side-pad
comment; the bubble's run building is its own function for the test.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: wing-anara <wing@anara.com>
---
 crates/ui/src/composer.rs      | 167 +++++++++++++++++++++++++++++++--
 crates/ui/src/composer/chip.rs | 146 +++++++++++++++++++++++++++-
 crates/ui/src/transcript.rs    |  97 ++++++++++++++++---
 3 files changed, 384 insertions(+), 26 deletions(-)

diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index d0e173aac0..16a5c3191d 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -44,7 +44,10 @@ use crate::theme::Theme;
 mod chip;
 pub use chip::ChipKind;
 use chip::*;
-pub(crate) use chip::{ChipIcon, chip_icon, chip_text, paint_chip};
+pub(crate) use chip::{
+    CHIP_PAD_FAMILY, ChipIcon, chip_icon, chip_pad_ranges, chip_text, paint_chip,
+    text_chip_label_offset,
+};
 
 // ---------------------------------------------------------------------------
 // Constants + pure decision logic
@@ -883,8 +886,9 @@ const UNDO_LIMIT: usize = 200;
 
 const MENTION_TOOLTIP_DELAY: Duration = Duration::from_millis(420);
 const MENTION_TOOLTIP_HEIGHT: f32 = 24.0;
-// Narrow nonbreaking spaces give UI-font chips compact insets and gaps,
-// while preserving the chip's atomic wrapping and source/caret projection.
+// Nonbreaking spaces give chips their side inset, shaped in Geist like the
+// rest of the padding, while preserving the chip's atomic wrapping and
+// source/caret projection.
 const MENTION_SIDE_PAD: &str = "\u{00A0}";
 /// A private URI scheme keeps file mentions distinguishable from ordinary
 /// Markdown links pasted into the composer.
@@ -1952,6 +1956,10 @@ pub struct ComposerInput {
     max_ascent: f32,
     #[cfg(test)]
     layout_rebuilds: usize,
+    /// The runs of the last rebuilt layout; the test text system shapes
+    /// every run alike, so tests check the requested fonts here.
+    #[cfg(test)]
+    last_runs: Vec<TextRun>,
     /// Normally keeps the caret visible through edits and rewraps. Manual
     /// wheel scrolling pauses it until the next caret move or edit.
     follow_cursor: bool,
@@ -2070,6 +2078,8 @@ impl ComposerInput {
             max_ascent: INPUT_TEXT_SIZE,
             #[cfg(test)]
             layout_rebuilds: 0,
+            #[cfg(test)]
+            last_runs: Vec::new(),
             follow_cursor: true,
             text_size: INPUT_TEXT_SIZE,
             configured_line_height: INPUT_LINE_HEIGHT,
@@ -3728,6 +3738,32 @@ impl ComposerInput {
         None
     }
 
+    /// [`chip_label_offset`] for the chip label starting at projected byte
+    /// `label`, from the shaped line holding it.
+    fn chip_label_offset(
+        &self,
+        label: usize,
+        row_top: Pixels,
+        room: Pixels,
+        window: &Window,
+    ) -> Pixels {
+        let line_ix = self
+            .line_starts
+            .partition_point(|start| *start <= label)
+            .saturating_sub(1);
+        match (self.last_lines.get(line_ix), self.line_starts.get(line_ix)) {
+            (Some(line), Some(start)) => chip_label_offset(
+                &line.unwrapped_layout,
+                label - start,
+                row_top,
+                self.line_height,
+                room,
+                window,
+            ),
+            _ => px(0.0),
+        }
+    }
+
     /// Content-local boxes occupied by a projected byte range, split at every
     /// soft wrap. A caret exactly at a wrap boundary belongs visually to both
     /// rows in GPUI; using the explicit wrap indices lets the range's first
@@ -4237,6 +4273,9 @@ impl ComposerInput {
         }
         for (_, range) in &self.projection.mentions {
             boundaries.extend([range.start, range.end]);
+            for pad in chip_pad_ranges(range) {
+                boundaries.extend([pad.start, pad.end]);
+            }
         }
         if let Some(range) = &marked {
             boundaries.extend([range.start, range.end]);
@@ -4268,17 +4307,24 @@ impl ComposerInput {
                     .projection
                     .mentions
                     .partition_point(|(_, range)| range.end <= r[0]);
-                let chip = self
+                let chip_range = self
                     .projection
                     .mentions
                     .get(mention_ix)
-                    .is_some_and(|(_, range)| range.contains(&r[0]));
+                    .map(|(_, range)| range)
+                    .filter(|range| range.contains(&r[0]));
+                let chip = chip_range.is_some();
                 let code = face_depth[composer_markdown::Face::Code as usize] > 0;
                 let mut run = run_for(
                     r[1] - r[0],
                     marked.as_ref().is_some_and(|range| range.contains(&r[0])),
                     code,
                 );
+                if chip_range.is_some_and(|range| {
+                    chip_pad_ranges(range).iter().any(|pad| pad.contains(&r[0]))
+                }) {
+                    run.font.family = CHIP_PAD_FAMILY.into();
+                }
                 if !chip {
                     if face_depth[composer_markdown::Face::Bold as usize] > 0 {
                         run.font.weight = gpui::FontWeight::BOLD;
@@ -4308,6 +4354,10 @@ impl ComposerInput {
                 run
             })
             .collect();
+        #[cfg(test)]
+        {
+            self.last_runs = runs.clone();
+        }
 
         // Each logical list line reserves its marker width for continuation
         // rows. Painting and hit testing apply the same continuation offset.
@@ -4846,13 +4896,15 @@ impl gpui::Element for ComposerTextElement {
             };
             // The path tooltip stays flush so the pointer can move onto it.
             let (tooltip_height, tooltip_gap) = (MENTION_TOOLTIP_HEIGHT, 1.0);
+            let label = chip_pad_ranges(display)[0].end;
             for local_bounds in input.bounds_for_display_range(display.clone()) {
+                let row_top = origin.y + local_bounds.origin.y;
+                // Centered on the label (see `paint_chip`).
+                let label_offset = input.chip_label_offset(label, row_top, px(1.5), window);
                 let chip_bounds = Bounds::new(
                     point(
                         origin.x + local_bounds.origin.x,
-                        // Centered on the row, which centers the label (see
-                        // `paint_chip`).
-                        origin.y + local_bounds.origin.y + px(1.5),
+                        row_top + px(1.5) + label_offset,
                     ),
                     size(local_bounds.size.width, local_bounds.size.height - px(3.0)),
                 );
@@ -14835,6 +14887,105 @@ mod tests {
         assert_eq!(spans[1].path.as_ref(), "src/components/");
     }
 
+    /// The padding pinned to Geist is exactly the chip's NBSP padding, so the
+    /// label keeps the interface font and the insets don't follow it.
+    #[test]
+    fn chip_pad_ranges_cover_only_the_padding() {
+        let raw = format!(
+            "open {} now",
+            zeron_proto::attachment_mentions::attachment_mention_link(1, None)
+        );
+        let (display, spans) = sent_mention_display(&raw).expect("image chip projects");
+        let [lead, trail] = chip_pad_ranges(&spans[0].range);
+        assert_eq!(
+            &display[lead.clone()],
+            format!("{MENTION_SIDE_PAD}{CHIP_ICON_SLOT}")
+        );
+        assert_eq!(&display[trail.clone()], CHIP_TRAILING_PAD);
+        assert_eq!(&display[lead.end..trail.start], "Image\u{a0}1");
+    }
+
+    /// The composer shapes a chip's padding in Geist and everything else,
+    /// the chip's label included, in the interface font.
+    #[gpui::test]
+    fn composer_chip_padding_is_shaped_in_geist(cx: &mut gpui::TestAppContext) {
+        with_composer_input(cx, |input, window, cx| {
+            let raw = format!("open {} now", local_file_link("src/composer.rs", false));
+            input.set_text(&raw, cx);
+            let mut style = window.text_style();
+            style.font_family = "Geist Mono".into();
+            input.layout_text(px(600.0), &style, window, cx);
+            let (_, chip) = input.projection.mentions[0].clone();
+            let pads = chip_pad_ranges(&chip);
+            let mut at = 0;
+            let mut pinned = 0;
+            for run in &input.last_runs {
+                let range = at..at + run.len;
+                at = range.end;
+                if pads.iter().any(|pad| pad.contains(&range.start)) {
+                    assert_eq!(run.font.family.as_ref(), CHIP_PAD_FAMILY, "{range:?}");
+                    assert!(pads.iter().any(|pad| pad.end >= range.end), "{range:?}");
+                    pinned += run.len;
+                } else {
+                    assert_eq!(run.font.family.as_ref(), "Geist Mono", "{range:?}");
+                }
+            }
+            assert_eq!(pinned, pads.iter().map(|pad| pad.len()).sum::<usize>());
+        });
+    }
+
+    /// The queue's family overrides are every chip's padding, in order and
+    /// never empty, as `with_font_family_overrides` requires.
+    #[test]
+    fn queue_chip_overrides_are_the_padding_in_order() {
+        let raw = format!(
+            "{} then {}",
+            local_file_link("a.rs", false),
+            zeron_proto::attachment_mentions::attachment_mention_link(1, None),
+        );
+        let (_, spans) = sent_mention_display(&raw).expect("chips project");
+        let overrides = chip_pad_overrides(&spans);
+        let expected: Vec<_> = spans
+            .iter()
+            .flat_map(|span| chip_pad_ranges(&span.range))
+            .collect();
+        assert_eq!(overrides, expected);
+        assert!(
+            overrides
+                .windows(2)
+                .all(|pair| pair[0].end <= pair[1].start)
+        );
+    }
+
+    /// A chip centers on its label's cap height: the row's middle for Geist,
+    /// and a nudge toward the label for faces whose caps sit higher or lower.
+    #[test]
+    fn chip_centering_follows_the_label_face() {
+        // A 14 px label on a 22 px row whose top is at y = 100, at 1x.
+        let center = |ascent: f32, descent: f32, cap: f32| {
+            let em = |units: f32| units / 1000.0 * 14.0;
+            label_center_offset(100.0, 22.0, em(ascent), em(descent), em(cap), 1.0)
+        };
+        // Geist, alone or as the padding beside a Geist Mono label.
+        assert_eq!(center(1005.0, 295.0, 710.0), 0.0);
+        // A label with much shorter caps sits lower, so the pill follows.
+        assert_eq!(center(1005.0, 295.0, 560.0), 1.0);
+        // A tall face lowers the baseline past the next pixel.
+        assert_eq!(center(1200.0, 295.0, 710.0), 1.0);
+        // Without a cap height there is nothing to center on.
+        assert_eq!(center(1005.0, 295.0, 0.0), 0.0);
+        // The baseline snaps to a pixel where the row lands, so the same
+        // face can need the pill a pixel lower on a row a little further down.
+        assert_eq!(
+            label_center_offset(100.0, 22.0, 14.966, 4.13, 10.0, 1.0),
+            0.0
+        );
+        assert_eq!(
+            label_center_offset(100.2, 22.0, 14.966, 4.13, 10.0, 1.0),
+            1.0
+        );
+    }
+
     /// Ordinary prompts must stay on the zero-cost path, including ones that
     /// merely *talk about* the scheme without containing a valid mention.
     #[test]
diff --git a/crates/ui/src/composer/chip.rs b/crates/ui/src/composer/chip.rs
index 5d2d9557dc..25d2481eab 100644
--- a/crates/ui/src/composer/chip.rs
+++ b/crates/ui/src/composer/chip.rs
@@ -14,6 +14,11 @@ pub(super) struct ChipAttachment {
 pub(super) const CHIP_ICON_SLOT: &str = "\u{00A0}\u{00A0}\u{00A0}\u{00A0}\u{00A0}";
 /// Breathing room after a chip's label.
 pub(super) const CHIP_TRAILING_PAD: &str = "\u{00A0}\u{00A0}";
+/// The bundled face a chip's padding is shaped in. A space's advance follows
+/// the font (Geist Mono's is 2.4× Geist's), and the counts above are tuned to
+/// Geist, so pinning the padding keeps every chip's icon slot and insets the
+/// same whatever the interface font. The label keeps the surrounding font.
+pub(crate) const CHIP_PAD_FAMILY: &str = "Geist";
 /// The icon sits at this size in its well.
 const CHIP_ICON_SIZE: f32 = 14.0;
 
@@ -35,6 +40,125 @@ pub(crate) enum ChipIcon {
     FileTheme(SharedString),
 }
 
+/// The padding around the label in a chip's display `range`: the side
+/// bearing and icon slot before it, and the trailing room after it. Callers
+/// shape both in [`CHIP_PAD_FAMILY`].
+pub(crate) fn chip_pad_ranges(range: &Range<usize>) -> [Range<usize>; 2] {
+    let lead_end = (range.start + MENTION_SIDE_PAD.len() + CHIP_ICON_SLOT.len()).min(range.end);
+    let trail_start = range
+        .end
+        .saturating_sub(CHIP_TRAILING_PAD.len())
+        .max(lead_end);
+    [range.start..lead_end, trail_start..range.end]
+}
+
+/// How far to move a chip's pill down from the middle of its row, which
+/// starts at `row_top`, so the pill centers its label's caps. GPUI puts a
+/// line's baseline `(ascent - descent) / 2` below the row's middle, with the
+/// tallest face's metrics, then rounds it to a device pixel (`scale` per
+/// point). Geist's caps sit on the middle (1005 - 295 = 710, its cap height);
+/// other faces and the rounding drift them by a pixel or so. Everything is in
+/// window coordinates, since the rounding depends on where the row lands.
+pub(super) fn label_center_offset(
+    row_top: f32,
+    line_height: f32,
+    ascent: f32,
+    descent: f32,
+    cap_height: f32,
+    scale: f32,
+) -> f32 {
+    if cap_height <= 0.0 {
+        // A face without a cap height: keep the row's middle.
+        return 0.0;
+    }
+    // GPUI's glyph snapping: halves round toward zero.
+    let snap = |y: f32| {
+        let device = y * scale;
+        let rounded = if device.fract().abs() == 0.5 {
+            device.trunc()
+        } else {
+            device.round()
+        };
+        rounded / scale
+    };
+    let baseline = snap(row_top + (line_height - ascent - descent) / 2.0 + ascent);
+    let offset = baseline - cap_height / 2.0 - (row_top + line_height / 2.0);
+    // The pill lands on whole device pixels too; a fraction would only
+    // round it away from a label that is already centered.
+    snap(offset)
+}
+
+/// How far to move a chip's pill down from the middle of its row so it
+/// centers the label (see [`paint_chip`]). `label` is the label's first byte
+/// within `line`, and `row_top` the row's top in window coordinates. The
+/// shift stays within `room`, the pill's inset from its row, so it never
+/// reaches into the next row.
+pub(crate) fn chip_label_offset(
+    line: &gpui::LineLayout,
+    label: usize,
+    row_top: Pixels,
+    line_height: Pixels,
+    room: Pixels,
+    window: &Window,
+) -> Pixels {
+    // The face that actually shaped the label, fallbacks included.
+    let Some(font_id) = line
+        .runs
+        .iter()
+        .find(|run| run.glyphs.iter().any(|glyph| glyph.index >= label))
+        .map(|run| run.font_id)
+    else {
+        return px(0.0);
+    };
+    let cap_height = window.text_system().cap_height(font_id, line.font_size);
+    let offset = label_center_offset(
+        f32::from(row_top),
+        f32::from(line_height),
+        f32::from(line.ascent),
+        f32::from(line.descent),
+        f32::from(cap_height),
+        window.scale_factor(),
+    );
+    px(offset.clamp(-f32::from(room), f32::from(room)))
+}
+
+/// [`chip_label_offset`] for a chip at byte `label` of a text element's
+/// `layout`, whose lines are its text split at newlines.
+pub(crate) fn text_chip_label_offset(
+    layout: &gpui::TextLayout,
+    label: usize,
+    row_top: Pixels,
+    room: Pixels,
+    window: &Window,
+) -> Pixels {
+    let mut start = 0;
+    for line in layout.line_layouts() {
+        let end = start + line.unwrapped_layout.len;
+        if label < end {
+            return chip_label_offset(
+                &line.unwrapped_layout,
+                label - start,
+                row_top,
+                layout.line_height(),
+                room,
+                window,
+            );
+        }
+        start = end + 1;
+    }
+    px(0.0)
+}
+
+/// The non-empty padding ranges of `spans`, in order: what [`chip_text`]
+/// shapes in [`CHIP_PAD_FAMILY`].
+pub(super) fn chip_pad_overrides(spans: &[SentMentionSpan]) -> Vec<Range<usize>> {
+    spans
+        .iter()
+        .flat_map(|span| chip_pad_ranges(&span.range))
+        .filter(|range| !range.is_empty())
+        .collect()
+}
+
 /// The icon of a chip. `path` names the file or folder for the file kinds.
 pub(crate) fn chip_icon(
     kind: ChipKind,
@@ -56,8 +180,9 @@ pub(crate) fn chip_icon(
 
 /// Paint a chip like the transcript's file badges: a soft rounded pill whose
 /// first row starts with the icon on a small well. Callers center `chip` on
-/// the line box: Geist's cap height sits exactly on its middle (ascent 1005,
-/// descent 295, cap 710 per 1000 units), so a centered pill centers the label.
+/// the label's cap height: the row's middle moved by [`chip_label_offset`],
+/// which is zero for Geist (ascent 1005, descent 295, cap 710 per 1000 units)
+/// and corrects for other interface fonts.
 pub(crate) fn paint_chip(
     window: &mut Window,
     chip: Bounds<Pixels>,
@@ -122,7 +247,18 @@ pub(crate) fn chip_text(
     if spans.is_empty() {
         return text.into_any_element();
     }
-    let styled = gpui::StyledText::new(text);
+    // Split runs at the padding (a default highlight changes nothing else),
+    // so the family override lands on whole runs over the inherited style.
+    let pads = chip_pad_overrides(&spans);
+    let styled = gpui::StyledText::new(text)
+        .with_highlights(
+            pads.iter()
+                .map(|range| (range.clone(), gpui::HighlightStyle::default())),
+        )
+        .with_font_family_overrides(
+            pads.into_iter()
+                .map(|range| (range, SharedString::from(CHIP_PAD_FAMILY))),
+        );
     let layout = styled.layout().clone();
     let icons: Vec<ChipIcon> = spans
         .iter()
@@ -133,11 +269,15 @@ pub(crate) fn chip_text(
         |_, _, _| (),
         move |_, _, window, cx| {
             for (span, icon) in spans.iter().zip(&icons) {
+                let label = chip_pad_ranges(&span.range)[0].end;
                 for (row, rect) in
                     crate::markdown::render::range_rects(&layout, &span.range, 0.0, 2.0)
                         .into_iter()
                         .enumerate()
                 {
+                    let row_top = rect.origin.y - px(2.0);
+                    let offset = text_chip_label_offset(&layout, label, row_top, px(2.0), window);
+                    let rect = Bounds::new(rect.origin + point(px(0.0), offset), rect.size);
                     paint_chip(window, rect, (row == 0).then_some(icon), &theme, cx);
                 }
             }
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index cc4c9f9f48..2e0f37ea0e 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -8077,19 +8077,16 @@ fn agent_message_display(text: &str) -> String {
     format!("Message from {name}\n\n{body}")
 }
 
-fn user_bubble_text(
-    row_id: &SharedString,
-    text: SharedString,
-    mentions: Arc<Vec<crate::composer::SentMentionSpan>>,
+/// The bubble text's runs: body text in the sans font, chips as labels in it
+/// with their padding pinned to [`crate::composer::CHIP_PAD_FAMILY`], and an
+/// agent attribution's name in bold.
+fn user_bubble_runs(
+    text: &str,
+    mentions: &[crate::composer::SentMentionSpan],
     theme: &Theme,
-    measured_h: Rc<Cell<f32>>,
-    entity_id: gpui::EntityId,
-    overlays: Vec<ChipOverlay>,
-    open_image: Rc<dyn Fn(&SharedString, &mut Window, &mut gpui::App)>,
-) -> AnyElement {
-    // Split runs at chip boundaries (spans are in order): body text keeps the
-    // sans font, chips read as inline code. Size/line-height flow from the
-    // bubble's div like every text child.
+) -> Vec<TextRun> {
+    // Split runs at chip boundaries (spans are in order). Size and line
+    // height flow from the bubble's div like every text child.
     let body_run = |len: usize| TextRun {
         len,
         font: gpui::font(theme.font_sans.clone()),
@@ -8104,8 +8101,22 @@ fn user_bubble_text(
         if at < span.range.start {
             runs.push(body_run(span.range.start - at));
         }
-        // Chips are labels in the body font, like the composer's.
-        runs.push(body_run(span.range.len()));
+        // Chips are labels in the body font, like the composer's, with their
+        // padding pinned to the face its insets are tuned for.
+        let [lead, trail] = crate::composer::chip_pad_ranges(&span.range);
+        for (len, pad) in [
+            (lead.len(), true),
+            (trail.start - lead.end, false),
+            (trail.len(), true),
+        ] {
+            if len > 0 {
+                let mut run = body_run(len);
+                if pad {
+                    run.font.family = crate::composer::CHIP_PAD_FAMILY.into();
+                }
+                runs.push(run);
+            }
+        }
         at = span.range.end;
     }
     if at < text.len() {
@@ -8144,6 +8155,20 @@ fn user_bubble_text(
             })
             .collect();
     }
+    runs
+}
+
+fn user_bubble_text(
+    row_id: &SharedString,
+    text: SharedString,
+    mentions: Arc<Vec<crate::composer::SentMentionSpan>>,
+    theme: &Theme,
+    measured_h: Rc<Cell<f32>>,
+    entity_id: gpui::EntityId,
+    overlays: Vec<ChipOverlay>,
+    open_image: Rc<dyn Fn(&SharedString, &mut Window, &mut gpui::App)>,
+) -> AnyElement {
+    let runs = user_bubble_runs(&text, &mentions, theme);
     let styled = StyledText::new(text.clone()).with_runs(runs);
     let layout = styled.layout().clone();
     let chip_layout = layout.clone();
@@ -8163,11 +8188,21 @@ fn user_bubble_text(
         |bounds, window, _| window.insert_hitbox(bounds, gpui::HitboxBehavior::Normal),
         move |_, hitbox, window, cx| {
             for (span, icon) in mentions.iter().zip(&chip_icons) {
-                // Centered on the line box like the composer's chips.
+                // Centered on the label like the composer's chips.
+                let label = crate::composer::chip_pad_ranges(&span.range)[0].end;
                 for (row, rect) in render::range_rects(&layout, &span.range, 0.0, 2.0)
                     .into_iter()
                     .enumerate()
                 {
+                    let row_top = rect.origin.y - px(2.0);
+                    let offset = crate::composer::text_chip_label_offset(
+                        &layout,
+                        label,
+                        row_top,
+                        px(2.0),
+                        window,
+                    );
+                    let rect = Bounds::new(rect.origin + point(px(0.0), offset), rect.size);
                     let icon = icon.as_ref().filter(|_| row == 0);
                     crate::composer::paint_chip(window, rect, icon, &sel_theme, cx);
                 }
@@ -14350,6 +14385,38 @@ mod tests {
         assert_eq!(attachments.len(), 1);
     }
 
+    /// A sent bubble shapes each chip's padding in Geist and its label, like
+    /// the rest of the body, in the interface font.
+    #[test]
+    fn bubble_chip_padding_is_shaped_in_geist() {
+        let raw = format!(
+            "open {} and {}",
+            zeron_proto::attachment_mentions::attachment_mention_link(1, None),
+            zeron_proto::attachment_mentions::attachment_mention_link(2, Some("notes.md")),
+        );
+        let (text, spans) = crate::composer::sent_mention_display(&raw).expect("chips project");
+        let mut theme = Theme::dark();
+        theme.font_sans = "Geist Mono".into();
+        let runs = user_bubble_runs(&text, &spans, &theme);
+        assert_eq!(runs.iter().map(|run| run.len).sum::<usize>(), text.len());
+        let mut at = 0;
+        let mut pads = Vec::new();
+        for run in &runs {
+            let range = at..at + run.len;
+            at = range.end;
+            if run.font.family.as_ref() == crate::composer::CHIP_PAD_FAMILY {
+                pads.push(range);
+            } else {
+                assert_eq!(run.font.family.as_ref(), "Geist Mono");
+            }
+        }
+        let expected: Vec<_> = spans
+            .iter()
+            .flat_map(|span| crate::composer::chip_pad_ranges(&span.range))
+            .collect();
+        assert_eq!(pads, expected);
+    }
+
     /// A sent prompt's file mentions render as chips in the transcript: the
     /// row carries the projected display text plus spans, while ordinary
     /// prompts keep the empty-spans fast path. The row version derives from

From 8e6da95908ee536012dba4f3268ca4bd87fe602b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Tue, 6 Oct 2026 23:57:12 -0300
Subject: [PATCH 55/74] Fix iOS showing fixture conversations when a session
 fails to open (#826)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* test(ios): reproduce fixture fallback for unknown chat routes

* fix(ios): return to sessions when a chat cannot be opened

---------

Co-authored-by: José Gurruchaga <jsgrrchg@outlook.com>
---
 apps/ios/Zeron/App/AppModel.swift             | 12 +++++---
 .../Zeron/Session/SessionViewController.swift |  5 ++--
 apps/ios/Zeron/Shell/MainTabController.swift  | 21 +++++++++++--
 .../ios/Zeron/Shell/SplitRootController.swift | 30 +++++++++++++++++--
 .../Zeron/Threads/SessionListController.swift |  6 +++-
 apps/ios/ZeronUITests/SessionFlowTests.swift  | 27 +++++++++++++++++
 6 files changed, 88 insertions(+), 13 deletions(-)

diff --git a/apps/ios/Zeron/App/AppModel.swift b/apps/ios/Zeron/App/AppModel.swift
index 2809bc8793..9cc98061c6 100644
--- a/apps/ios/Zeron/App/AppModel.swift
+++ b/apps/ios/Zeron/App/AppModel.swift
@@ -436,11 +436,15 @@ final class AppModel {
 
     // MARK: Sessions
 
-    func sessionSource(_ chatId: String) -> SessionSource {
-        guard let client, let handle = try? client.openSession(chatId: chatId) else {
-            return FixtureSessionSource(title: "Unavailable", subtitle: "")
+    func sessionSource(_ chatId: String) -> SessionSource? {
+        guard let client else { return nil }
+        do {
+            let handle = try client.openSession(chatId: chatId)
+            return CoreSessionSource(app: self, client: client, handle: handle, chatId: chatId)
+        } catch {
+            NSLog("open session failed: \(error)")
+            return nil
         }
-        return CoreSessionSource(app: self, client: client, handle: handle, chatId: chatId)
     }
 
     // MARK: New session
diff --git a/apps/ios/Zeron/Session/SessionViewController.swift b/apps/ios/Zeron/Session/SessionViewController.swift
index d5587a13d7..5e8d7548f9 100644
--- a/apps/ios/Zeron/Session/SessionViewController.swift
+++ b/apps/ios/Zeron/Session/SessionViewController.swift
@@ -20,10 +20,11 @@ final class SessionViewController: UIViewController, UIGestureRecognizerDelegate
     private let openedAt = CACurrentMediaTime()
     private var reportedOpen = false
 
-    init(app: AppModel, chatId: String) {
+    init?(app: AppModel, chatId: String) {
+        guard let source = app.sessionSource(chatId) else { return nil }
         self.app = app
         self.chatId = chatId
-        self.source = app.sessionSource(chatId)
+        self.source = source
         super.init(nibName: nil, bundle: nil)
         hidesBottomBarWhenPushed = true
     }
diff --git a/apps/ios/Zeron/Shell/MainTabController.swift b/apps/ios/Zeron/Shell/MainTabController.swift
index 1d33a51f4c..ce493afdd7 100644
--- a/apps/ios/Zeron/Shell/MainTabController.swift
+++ b/apps/ios/Zeron/Shell/MainTabController.swift
@@ -144,7 +144,9 @@ final class MainTabController: UITabBarController, UITabBarControllerDelegate, A
         else { return openSession(chatId) }
         selectedTab = tab
         guard let nav = tab.viewController as? UINavigationController else { return openSession(chatId) }
-        let session = SessionViewController(app: app, chatId: chatId)
+        guard let session = SessionViewController(app: app, chatId: chatId) else {
+            return showSessionOpenError()
+        }
         UIView.performWithoutAnimation {
             nav.popToRootViewController(animated: false)
             nav.pushViewController(session, animated: false)
@@ -175,14 +177,27 @@ final class MainTabController: UITabBarController, UITabBarControllerDelegate, A
         nav.popToRootViewController(animated: false)
     }
 
+    func showSessionOpenError() {
+        if presentedViewController != nil { dismiss(animated: false) }
+        view.endEditing(true)
+        selectedTab = tabs.first { $0.identifier == "sessions" }
+        popToFrontPage()
+        syncAccessory()
+        view.layoutIfNeeded()
+        Toast.show("Couldn't open session. Try again.", in: view.window)
+    }
+
     /// Push a session on the Sessions tab (from new-session, deep links, search).
     func openSession(_ chatId: String) {
-        if presentedViewController != nil { dismiss(animated: true) }
         guard let tab = tabs.first(where: { $0.identifier == "sessions" }) else { return }
         selectedTab = tab
         guard let nav = tab.viewController as? UINavigationController else { return }
+        guard let session = SessionViewController(app: app, chatId: chatId) else {
+            return showSessionOpenError()
+        }
+        if presentedViewController != nil { dismiss(animated: true) }
         nav.popToRootViewController(animated: false)
-        nav.pushViewController(SessionViewController(app: app, chatId: chatId), animated: true)
+        nav.pushViewController(session, animated: true)
     }
 }
 
diff --git a/apps/ios/Zeron/Shell/SplitRootController.swift b/apps/ios/Zeron/Shell/SplitRootController.swift
index dce09b4f3b..ed707d9e6e 100644
--- a/apps/ios/Zeron/Shell/SplitRootController.swift
+++ b/apps/ios/Zeron/Shell/SplitRootController.swift
@@ -72,9 +72,21 @@ final class SplitRootController: UISplitViewController, UISplitViewControllerDel
         if presentedViewController != nil { dismiss(animated: true) }
         guard !isCollapsed else { return tabs.openSession(chatId) }
         if currentChatId == chatId, detail.viewControllers.first is SessionViewController { return }
+        guard let session = SessionViewController(app: app, chatId: chatId) else {
+            return showSessionOpenError()
+        }
         currentChatId = chatId
         sidebar.currentChatId = chatId
-        detail.setViewControllers([SessionViewController(app: app, chatId: chatId)], animated: false)
+        detail.setViewControllers([session], animated: false)
+    }
+
+    private func showSessionOpenError() {
+        if presentedViewController != nil { dismiss(animated: false) }
+        view.endEditing(true)
+        showDraft(prompt: nil, focus: false)
+        sidebar.showSessions()
+        show(.primary)
+        Toast.show("Couldn't open session. Try again.", in: view.window)
     }
 
     func presentNewSession(prompt: String?) {
@@ -94,9 +106,11 @@ final class SplitRootController: UISplitViewController, UISplitViewControllerDel
             }
             // In place: the chat replaces the draft in the column and the
             // handoff carries the composer and message across.
+            guard let session = SessionViewController(app: self.app, chatId: chatId) else {
+                return self.showSessionOpenError()
+            }
             self.currentChatId = chatId
             self.sidebar.currentChatId = chatId
-            let session = SessionViewController(app: self.app, chatId: chatId)
             UIView.performWithoutAnimation {
                 self.detail.setViewControllers([session], animated: false)
                 self.view.layoutIfNeeded()
@@ -163,7 +177,10 @@ final class SplitRootController: UISplitViewController, UISplitViewControllerDel
             let shown = (self.detail.viewControllers.first as? SessionViewController)?.chatId
             if let chatId = current {
                 if shown != chatId {
-                    self.detail.setViewControllers([SessionViewController(app: self.app, chatId: chatId)], animated: false)
+                    guard let session = SessionViewController(app: self.app, chatId: chatId) else {
+                        return self.showSessionOpenError()
+                    }
+                    self.detail.setViewControllers([session], animated: false)
                 }
                 self.sidebar.currentChatId = chatId
             } else if self.detail.viewControllers.isEmpty {
@@ -255,6 +272,13 @@ final class SidebarViewController: UIViewController, UISearchResultsUpdating {
         nav.popToRootViewController(animated: false)
         search.searchBar.becomeFirstResponder()
     }
+
+    func showSessions() {
+        search.isActive = false
+        search.searchBar.text = ""
+        list.query = ""
+        nav.popToRootViewController(animated: false)
+    }
 }
 
 extension UIViewController {
diff --git a/apps/ios/Zeron/Threads/SessionListController.swift b/apps/ios/Zeron/Threads/SessionListController.swift
index 7593a3a29f..b624d5c9b7 100644
--- a/apps/ios/Zeron/Threads/SessionListController.swift
+++ b/apps/ios/Zeron/Threads/SessionListController.swift
@@ -206,7 +206,11 @@ class SessionListController: UIViewController, UICollectionViewDelegate {
             split.openSession(id)
             return
         }
-        navigationController?.pushViewController(SessionViewController(app: app, chatId: id), animated: true)
+        guard let session = SessionViewController(app: app, chatId: id) else {
+            (tabBarController as? MainTabController)?.showSessionOpenError()
+            return
+        }
+        navigationController?.pushViewController(session, animated: true)
     }
 
     func openFolder(_ id: String) {
diff --git a/apps/ios/ZeronUITests/SessionFlowTests.swift b/apps/ios/ZeronUITests/SessionFlowTests.swift
index b299630fe7..5b6edc5ae9 100644
--- a/apps/ios/ZeronUITests/SessionFlowTests.swift
+++ b/apps/ios/ZeronUITests/SessionFlowTests.swift
@@ -205,6 +205,33 @@ final class SessionFlowTests: XCTestCase {
         snapshot(app, "notification-opened")
     }
 
+    /// An unknown chat stays on Sessions and reports the failed open.
+    /// `-route` calls the same AppRouter.openSession entry point as a push
+    /// tap, without needing APNs or a host-side sender. This reproduces the
+    /// failed-open path, not the original notification's delivery or
+    /// the sync timing that may have made its chat unavailable.
+    func testUnknownChatRouteReturnsToSessions() {
+        let chatId = "missing-notification-chat-\(UUID().uuidString)"
+        let app = launch(["-route", "chat:\(chatId)"])
+        XCTAssertTrue(app.staticTexts["Couldn't open session. Try again."].waitForExistence(timeout: 10))
+        XCTAssertTrue(app.navigationBars["Sessions"].waitForExistence(timeout: 5))
+        XCTAssertTrue(app.buttons["new-session"].waitForExistence(timeout: 5))
+        XCTAssertFalse(app.scrollViews["transcript"].exists, "failed open must not present a conversation")
+        XCTAssertFalse(app.staticTexts["Unavailable"].exists)
+
+        let prompt = app.staticTexts.matching(NSPredicate(
+            format: "label == %@",
+            "You: How does the layout engine avoid measuring text on the main thread?"
+        )).firstMatch
+        let reply = app.staticTexts.matching(NSPredicate(
+            format: "label CONTAINS %@", "Plan for the rewrite"
+        )).firstMatch
+        XCTAssertFalse(prompt.exists, "fixture prompt must never appear for a missing chat")
+        XCTAssertFalse(reply.exists, "fixture reply must never appear for a missing chat")
+        XCTAssertFalse(app.cells["session-\(chatId)"].exists)
+        snapshot(app, "unknown-chat-returned-to-sessions")
+    }
+
     func testTabsAndSearch() {
         let app = launch()
         XCTAssertTrue(app.staticTexts["Sessions"].waitForExistence(timeout: 10))

From 4a5fb8b4438196aed3249e4efae1291d39100932 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Wed, 7 Oct 2026 03:47:32 -0300
Subject: [PATCH 56/74] Internal session plumbing and packaging cleanup (#819)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* test(codex): document and probe native voice capabilities

* feat(proto): define local voice session contracts

* fix(harness): bound realtime media and prioritize control messages

* feat(codex): attach realtime voice to an idle thread runtime

* feat(engine): own voice leases and enforce subscription eligibility

* feat(mcp): create standalone sessions on selected hosts

Add chat/side kinds with compatible defaults, resolve projects within the selected device, and validate that host's harness and model catalogs before writing. Route transcript reads to the chat host and preserve send baselines across waits so missing session rows and delayed replies cannot return an old response.

Cover invalid requests, remote catalogs, mixed batches, wait races, two-engine execution and interrupt delivery. Add an isolated MCP stdio smoke fixture.

* feat(doc): persist canonical voice transcripts once

* docs(mcp): document standalone and remote session workflows

* feat(audio): add native capture and streaming playback

* feat(audio): handle echo cancellation and voice interruptions

* feat(ui): coordinate voice ownership over local engine RPC

* feat(ui): extract the Bezel orb into a native Zeron component

* feat(ui): replace the composer with a central orb during voice sessions

* feat(mcp): constrain voice orchestration to subscription policy

* build(voice): add microphone permissions and offline audio CI

* test(voice): verify lifecycle, billing boundaries and rollout gates

* fix(voice): preserve text transport and idle billing boundaries

* feat(codex): connect subscription voice through native WebRTC

* feat(engine): activate native voice ownership and preserve delegated work

* feat(ui): enable native voice with central orb and retained drafts

* fix(mcp): keep voice delegation on subscription-backed Codex

* test(voice): document native transport and add opt-in connectivity smoke

* fix(voice): close audit races and validate project subscription context

* Fix Codex voice initialization and macOS microphone permissions

* Allow Codex voice agents to delegate through upstream MCP

* Make voice a persistent orchestrator with a dedicated stage

* Add call controls and elapsed time to the voice stage

* Remove decorative rings around the voice orb

* Add voice selection menu and simplify stage artwork

* Remove voice status labels beneath the orb

* Fix dictation and realtime voice integration after rebase

* Move Codex voice style selection into Voice settings

* Restore window dragging from the voice stage titlebar

* Open the voice stage immediately when starting a call

* Smooth voice orb motion and speaking transitions

* Remove the green audio pulse from the voice microphone control

* Show the live voice orb above the orchestrator chat composer

* Use full chat IDs in MCP reply instructions

* Correlate MCP replies by message IDs instead of remote timestamps

* Keep the voice stage open when launched from Settings

* test(voice): add a split-host Codex voice compatibility probe

* feat(voice): package a standalone desktop media runtime

* feat(proto): define client-media voice control contracts

* refactor(codex): separate voice signaling from local audio

* feat(engine): own remote voice sessions with ephemeral leases

* feat(rpc): route versioned voice controls to execution hosts

* feat(voice): coordinate local media with remote Codex control

* feat(ui): start voice on a selected remote Codex host

* test(voice): cover cancelled preparations and stale session controls

* test(voice): prepare desktop rollout validation and offline CI

* feat(ios): add a pinned native WebRTC compatibility endpoint

* feat(mobile): expose remote voice sessions through UniFFI

* feat(ios): bridge native audio lifecycle to remote voice calls

* feat(ios): add remote voice controls and registered host selection

* test(voice): cover relay and iOS lifecycle and prepare live acceptance

Add half-open and native callback regressions, stage-only diagnostics, complete runtime notices, and development test instructions. Keep real Mac/Fedora/iPhone acceptance opt-in for user validation.

* refactor(orb): share the thinking-orb engine through zeron-orb

Move the renderer-agnostic engine, presets, motion and a new OrbAnimator
(clock, audio response, state crossfades) into crates/orb. The GPUI widget
now delegates to the animator, so desktop and mobile paint identical frames.

* feat(voice): rebuild iOS remote voice around the desktop orb and phone-call audio

- Share the call view (phase, caption, levels, speaking, orb state) in
  voice-session; the client derives speaking because client media has no
  host meter. Keep owner-event headroom so level meters never overflow it.
- Title remote orchestrator chats "Voice session" like local ones.
- UniFFI: typed call state and end reasons instead of JSON, a distinct
  denied-microphone failure, and OrbRenderer frames from zeron-orb.
- iOS: OrbView paints the desktop orb; start voice from the New session bar
  (live strip while a call runs), the session nav bar and the iPad sidebar;
  full-screen call stage with caption, transcript (flagged when Codex waits
  for an answer), mute, route picker and hang-up.
- Phone-call audio: proximity sensor moves output to the earpiece, headsets
  win, calls survive screen lock, headset loss re-routes instead of ending.
  Install the WebRTC audio configuration globally so it is not reverted when
  the audio unit starts.

* fix(voice): install the macOS voice runtime under codex-resources/voice

Codex's helper only initializes from a codex-resources/voice directory and
exits with code 23 on initializeRuntime anywhere else, which the desktop
reported as "Voice could not connect". Bundle the runtime at
Contents/Resources/codex-resources/voice, reject other locations up front,
and report a helper that cannot start as an unavailable runtime.

Ship the runtime byte-for-byte with OpenAI's Developer ID signatures instead
of re-signing it ad hoc.

* fix(ios): reopen the call stage from the live strip and redo voice settings

The live strip in the bottom bar is a plain UIControl, which never sends
.primaryActionTriggered, so tapping it did nothing; listen for touchUpInside.
UI tests cover reopening the stage after the transcript and after minimizing.

Voice settings now follow the Settings list style: the resting orb, the
devices Codex can run on with their status, the voice as a pop-up menu, and
what to expect during a call.

* fix(ios): resume the orb animation when the app becomes active again

At willEnterForeground the app still reports .background, so the display
link never restarted and the orb stayed frozen after returning from Home.

* fix(ios): guard voice preview state in Release builds

* feat(voice): veil streamed caption words in on desktop and iPhone

Move the transcript's renderer-agnostic streaming veil into zeron-veil so
the voice call caption can use the same chunk fades on both platforms. A
new CaptionVeil keeps the veil aligned with the ellipsized tail and fades
the previous utterance out when the speaker turn changes; reduced motion
shows text directly. Desktop recolors GPUI runs; iOS gets UTF-16 spans
through CaptionFader and paints an attributed caption on a display link.
The desktop transcript keeps its behavior; the iOS transcript is untouched.

* fix(ui): step the voice stage aside when opening any session

Opening a session only hid the stage indirectly, when the selection changed,
so clicking the thread already under the stage (or the one you came from
Settings) did nothing. open_chat now hides the stage explicitly; the call
keeps running in the background.

* feat(voice): reuse host orchestrator chats across calls

* fix(voice): reserve orchestrator atomically and preserve rotation retries

* feat(voice): rotate the orchestrator transcript after 1000 entries

* feat(voice): package remote media runtime for Linux and Windows

* feat(voice): use the installed Codex helper everywhere and stop bundling it

Remote voice now plays audio through the client's own standalone Codex
installation, like local voice, instead of a runtime packaged inside
Zeron. The resolver moves to zeron-voice-media and is shared by the
harness and the desktop media endpoint; ZERON_VOICE_MEDIA_DIR remains a
development override. macOS, Linux and Windows packages no longer
contain Codex binaries, GStreamer/GLib or the Visual C++ runtime, so
Zeron takes on none of their redistribution or update obligations.
package-voice-runtime.py stays as a development projection tool.

Missing-runtime messages point to Codex's official installer, since npm
installs lack the voice runtime.

Notices and disclosures:
- THIRD_PARTY_NOTICES: full MIT chain for the orb (Bezel,
  gpui-thinking-orbs, thinking-orbs), Codex NOTICE, OpenAI trademark and
  non-affiliation statement, and WebRTC for iOS.
- The iOS app carries the orb's MIT notice; the Linux tarball now ships
  LICENSE and THIRD_PARTY_NOTICES.md.
- Microphone purpose strings on macOS and iOS state that voice sessions
  stream audio to OpenAI; dictation stays on device.
- Docs describe the voice data flow, and the acceptance checklist lists
  the legal and privacy decisions that block a public release.

* feat(ios): show the voice call in the Dynamic Island and on the Lock Screen

* fix(voice): hide the voice trigger when this device has no Codex

The microphone in the sidebar footer only shows when Codex is installed and
enabled on this device, following the same catalog the composer offers. It
re-reads after Settings → Agents changes and when returning to a window that
hides it. A start without Codex now asks for an install instead of a retry.

* test(voice): seed the real rotation threshold in the remote rotation test

* feat(voice): sound the start and end of a call on desktop and iPhone

A call sounds as it is placed, before the microphone opens, and again when
the user hangs up or a connected call ends. A failure to connect stays quiet
and explains itself. Nothing sounds in between. The iPhone plays them as
system sounds, so they follow the ringer switch.

* perf(voice): skip the rate limits round trip before each call

The pre-call probe read account/rateLimits/read, a ~1 s backend round
trip, and ran twice per call (prepare and negotiate). Its result was never
shown: the native backend makes the final usage decision. Dropping it
saves about 1.7 s per call on desktop and iPhone.

* perf(voice): release the orchestrator runtime 5 minutes after hang-up

The voice orchestrator's Codex runtime and MCP servers hold ~200 MB. Its
idle window was the generic 30 minutes, counted from the runtime's start,
so a call ending late in the window left a runtime reaped right after the
hang-up. It now idles 5 minutes, restarted at each hang-up.

Hang-ups wake the reaper directly, so even a short call restarts the
window, and a reap armed before a call began rechecks for it instead of
cutting the call.

* fix(voice): enable client-owned remote voice by default

* fix(harness): read whole resumed histories and report why stdout failed

509818ed capped every JSON-RPC line at 8 MiB on the transport shared by
text chats. A resumed long chat returns its history in one response
(54-71 MiB measured), so resume failed and was reported as an exit even
though Codex was alive. Lift the cap (voice bounds its own messages) and
keep the read error's cause for every waiting and later request.

* fix(harness): name the rejected request in JSON-RPC errors again

dca9a05f made peer rejections structured but dropped the method from
their message, so chats showed 'JSON-RPC rejection -32600: …' without
saying which request failed. Prefix the method again and render it as
upstream did, keeping the code available for auth detection.

* test: skip POSIX mode check on Windows hosts

* fix: launch Codex batch shims from plain paths and answer account/read in fake

* refactor(engine): remove the superseded local session RPC surface

The client-media protocol replaced these methods; nothing calls them anymore.

* refactor(harness): restore the shared JSON-RPC transport

Return the stdio transport every agent uses to its upstream behavior
(unbounded writes, no timeouts or polling timers) and keep only an
additive notification route that is registered while a subscriber
exists.

* fix(ui): let the full-window stage show the window glass

On translucent appearances the stage painted an opaque fill unlike the
new-thread page. Drop the fill there and fade out the page it covers.

* fix(ui): show the full-window stage over Settings

Settings replaces the workspace layout and never mounted the stage, so
opening it from there did nothing. Mount it beside the settings sidebar
and fade the page it covers.

* fix(voice-session): keep the live caption on the newest turn

Turns arrive interleaved: a user final often lands after the answer has
started streaming. Keep each turn's text separately and caption the
newest one, so a late final never takes the caption back and deltas
never restart it. Desktop and mobile now share this state.

* ci: build the desktop UI only in the UI workflow

The offline-linux job compiled zeron-ui without the WebKitGTK and
JSON-GLib packages its build script requires, so it failed every run.
Drop its UI step; the UI workflow already runs those lib tests and now
also runs the orb geometry test.
---
 .github/workflows/ui-tests.yml                |    2 +-
 .github/workflows/voice-tests.yml             |  123 +
 .gitignore                                    |    1 +
 Cargo.lock                                    |  226 +-
 Cargo.toml                                    |   10 +
 THIRD_PARTY_NOTICES.md                        |  276 +
 apps/ios/README.md                            |    5 +
 apps/ios/Zeron.xcodeproj/project.pbxproj      |  186 +-
 .../xcshareddata/swiftpm/Package.resolved     |   15 +
 apps/ios/Zeron/App/AppModel.swift             |    7 +-
 apps/ios/Zeron/App/SceneDelegate.swift        |   16 +
 .../ios/Zeron/Core/Generated/zeron_core.swift | 9687 ++++++++++-------
 apps/ios/Zeron/Info.plist                     |    8 +
 .../Zeron/Session/SessionViewController.swift |   18 +
 apps/ios/Zeron/Shell/MainTabController.swift  |  122 +-
 apps/ios/Zeron/Shell/MoreViewController.swift |    5 +
 .../ios/Zeron/Shell/SplitRootController.swift |   16 +
 apps/ios/Zeron/Voice/CodexVoicePeer.swift     |  230 +
 apps/ios/Zeron/Voice/NativeVoiceMedia.swift   |   82 +
 apps/ios/Zeron/Voice/OrbView.swift            |  131 +
 .../Zeron/Voice/RemoteVoiceController.swift   |  331 +
 apps/ios/Zeron/Voice/Sounds/voice-end.wav     |  Bin 0 -> 165164 bytes
 apps/ios/Zeron/Voice/Sounds/voice-start.wav   |  Bin 0 -> 172844 bytes
 apps/ios/Zeron/Voice/ThinkingOrbs-LICENSE.txt |   30 +
 .../Zeron/Voice/VoiceActivityController.swift |  103 +
 apps/ios/Zeron/Voice/VoiceControls.swift      |  205 +
 .../Voice/VoiceStageViewController.swift      |  432 +
 .../ios/Zeron/Voice/VoiceViewController.swift |  251 +
 apps/ios/Zeron/Voice/WebRTC-LICENSE.txt       |   29 +
 .../Assets.xcassets/Contents.json             |    3 +
 .../Contents.json                             |   16 +
 .../orb-awaiting-avatar.svg                   |    1 +
 .../Contents.json                             |   16 +
 .../orb-awaiting-inline.svg                   |    1 +
 .../Contents.json                             |   16 +
 .../orb-connecting-avatar.svg                 |    1 +
 .../Contents.json                             |   16 +
 .../orb-connecting-inline.svg                 |    1 +
 .../Contents.json                             |   16 +
 .../orb-listening-avatar.svg                  |    1 +
 .../Contents.json                             |   16 +
 .../orb-listening-inline.svg                  |    1 +
 .../orb-muted-avatar.imageset/Contents.json   |   16 +
 .../orb-muted-avatar.svg                      |    1 +
 .../orb-muted-inline.imageset/Contents.json   |   16 +
 .../orb-muted-inline.svg                      |    1 +
 .../Contents.json                             |   16 +
 .../orb-speaking-avatar.svg                   |    1 +
 .../Contents.json                             |   16 +
 .../orb-speaking-inline.svg                   |    1 +
 .../orb-working-avatar.imageset/Contents.json |   16 +
 .../orb-working-avatar.svg                    |    1 +
 .../orb-working-inline.imageset/Contents.json |   16 +
 .../orb-working-inline.svg                    |    1 +
 apps/ios/ZeronLiveActivity/Info.plist         |   16 +
 .../ZeronLiveActivity/VoiceLiveActivity.swift |  260 +
 .../ZeronLiveActivityBundle.swift             |    9 +
 apps/ios/ZeronShared/VoiceActivity.swift      |   69 +
 .../RemoteVoiceLifecycleTests.swift           |   72 +
 apps/ios/ZeronUITests/VoiceFlowTests.swift    |   72 +
 apps/zeron/build.rs                           |   12 +
 crates/audio/Cargo.toml                       |   19 +
 crates/audio/src/aec.rs                       |   89 +
 crates/audio/src/dsp.rs                       |   68 +
 crates/audio/src/lib.rs                       |   79 +
 crates/audio/src/native.rs                    |  248 +
 crates/audio/src/worker.rs                    |  104 +
 crates/client/Cargo.toml                      |    1 +
 crates/client/src/client.rs                   |   15 +
 crates/client/src/live/relay.rs               |   15 +
 crates/client/src/workspace/view.rs           |    4 +-
 crates/doc/src/lib.rs                         |    1 +
 crates/doc/src/voice.rs                       |  112 +
 crates/engine/Cargo.toml                      |    1 +
 crates/engine/src/diff_sync.rs                |    4 +-
 crates/engine/src/doc_host.rs                 |   23 +-
 crates/engine/src/lib.rs                      |    1 +
 crates/engine/src/rpc.rs                      |  211 +-
 crates/engine/src/rpc/voice_chat.rs           |  211 +
 crates/engine/src/rpc/voice_remote.rs         |  189 +
 crates/engine/src/sessions.rs                 |  361 +-
 crates/engine/src/titles.rs                   |    1 +
 crates/engine/src/voice.rs                    |  310 +
 crates/engine/src/voice/remote.rs             |  495 +
 crates/engine/tests/support/voice_relay.rs    |   96 +
 crates/engine/tests/voice_runtime.rs          |  492 +
 crates/harness/Cargo.toml                     |    3 +-
 .../examples/cursor_stability_probe.rs        |    4 +
 .../harness/examples/cursor_steering_probe.rs |    1 +
 crates/harness/examples/devin_models_probe.rs |    1 +
 .../harness/examples/grok_subagent_probe.rs   |    1 +
 .../examples/opencode_subagent_probe.rs       |    1 +
 .../harness/examples/opencode_turn_probe.rs   |    1 +
 crates/harness/examples/steering_probe.rs     |    1 +
 crates/harness/src/acp/mod.rs                 |    1 +
 crates/harness/src/claude/mod.rs              |    1 +
 crates/harness/src/codex/mod.rs               |  113 +-
 crates/harness/src/codex/realtime.rs          |  632 ++
 crates/harness/src/codex/realtime_host.rs     |    3 +
 crates/harness/src/cursor/mod.rs              |    1 +
 crates/harness/src/jsonrpc.rs                 |   86 +
 crates/harness/src/lib.rs                     |   10 +
 crates/harness/src/opencode/mod.rs            |    1 +
 crates/harness/src/opencode/tests.rs          |    1 +
 crates/harness/src/pi/mod.rs                  |    1 +
 crates/harness/tests/acp.rs                   |    1 +
 crates/harness/tests/acp_quiet.rs             |    1 +
 crates/harness/tests/acp_stall.rs             |    1 +
 crates/harness/tests/claude.rs                |    2 +
 crates/harness/tests/codex.rs                 |  153 +
 crates/harness/tests/cursor.rs                |    1 +
 .../tests/fixtures/codex/voice-0.159.0.json   |  463 +
 .../tests/fixtures/fake-codex-voice-host.py   |   37 +
 .../tests/fixtures/fake-codex-voice-native.py |   69 +
 .../tests/fixtures/fake-codex-voice.py        |   24 +
 crates/harness/tests/fixtures/fake-codex.sh   |    4 +
 crates/harness/tests/managed_install.rs       |    1 +
 .../harness/tests/managed_install_failure.rs  |    1 +
 crates/harness/tests/opencode.rs              |    1 +
 crates/harness/tests/pi_live.rs               |    3 +
 crates/harness/tests/pi_rpc.rs                |    1 +
 crates/harness/tests/real_acp_lifecycle.rs    |    1 +
 crates/harness/tests/real_quiet_survey.rs     |    1 +
 crates/harness/tests/windows_native.rs        |    3 +
 crates/mcp/src/tools.rs                       |  147 +-
 crates/mobile/Cargo.toml                      |    6 +
 crates/mobile/src/caption.rs                  |   94 +
 crates/mobile/src/client_ffi/mod.rs           |    2 +
 crates/mobile/src/client_ffi/voice.rs         |  550 +
 crates/mobile/src/lib.rs                      |    4 +
 crates/mobile/src/orb.rs                      |  192 +
 crates/orb/Cargo.toml                         |   10 +
 crates/orb/src/animator.rs                    |  300 +
 crates/orb/src/engine/braid.rs                |   58 +
 crates/orb/src/engine/concepts.rs             |  195 +
 crates/orb/src/engine/core.rs                 |  232 +
 crates/orb/src/engine/lattice.rs              |  292 +
 crates/orb/src/engine/mod.rs                  |   82 +
 crates/orb/src/engine/morph.rs                |  172 +
 crates/orb/src/engine/orbits.rs               |   90 +
 crates/orb/src/engine/profiles.rs             |  385 +
 crates/orb/src/engine/ribbon.rs               |  110 +
 crates/orb/src/engine/web.rs                  |  120 +
 crates/orb/src/lib.rs                         |   23 +
 crates/orb/src/motion.rs                      |  158 +
 crates/orb/src/presets.rs                     |  354 +
 crates/orb/src/types.rs                       |  217 +
 crates/proto/src/entities.rs                  |    6 +
 crates/proto/src/lib.rs                       |    1 +
 crates/proto/src/voice.rs                     |  260 +
 crates/proto/src/voice/remote.rs              |  188 +
 crates/proto/src/workspace.rs                 |    4 +-
 crates/rpc/src/lib.rs                         |    8 +
 crates/ui/Cargo.toml                          |    6 +
 crates/ui/assets/icons/microphone-off.svg     |    1 +
 crates/ui/assets/icons/microphone.svg         |    2 +-
 crates/ui/assets/icons/phone-hang-up.svg      |    1 +
 crates/ui/assets/sounds/voice-end.wav         |  Bin 0 -> 165164 bytes
 crates/ui/assets/sounds/voice-start.wav       |  Bin 0 -> 172844 bytes
 crates/ui/src/dictation/model.rs              |  158 +-
 crates/ui/src/icons.rs                        |    5 +-
 crates/ui/src/lib.rs                          |    2 +
 crates/ui/src/markdown/veil.rs                |  404 +-
 crates/ui/src/orb/mod.rs                      |   19 +
 crates/ui/src/orb/orb.rs                      |  451 +
 crates/ui/src/orb/paint.rs                    |  133 +
 crates/ui/src/settings.rs                     |   12 +
 crates/ui/src/shell.rs                        |  361 +-
 crates/ui/src/shell/command_palette.rs        |    2 +-
 crates/ui/src/shell/navigation_focus.rs       |    2 +
 crates/ui/src/shell/spaces.rs                 |    2 +-
 crates/ui/src/shell/tabs.rs                   |    4 +
 crates/ui/src/shell/voice_stage.rs            | 1120 ++
 crates/ui/src/sound.rs                        |   15 +-
 crates/ui/src/state.rs                        |   29 +-
 crates/ui/src/voice.rs                        |  635 ++
 crates/ui/src/voice/permissions.rs            |   68 +
 crates/ui/src/voice/remote.rs                 |   70 +
 crates/ui/tests/voice_orb_geometry.rs         |  352 +
 crates/veil/Cargo.toml                        |   10 +
 crates/veil/src/caption.rs                    |  204 +
 crates/veil/src/lib.rs                        |  402 +
 crates/voice-media/Cargo.toml                 |   19 +
 crates/voice-media/src/lib.rs                 |  570 +
 crates/voice-session/Cargo.toml               |   21 +
 crates/voice-session/src/lib.rs               |  638 ++
 crates/voice-session/src/view.rs              |  541 +
 dist/macos/Info-dev.plist                     |    4 +-
 dist/macos/Info-unbundled.plist               |   10 +
 dist/macos/Info.plist                         |    4 +-
 dist/macos/voice.entitlements                 |    5 +
 dist/voice/Codex-LICENSE.txt                  |  201 +
 dist/voice/README.md                          |   29 +
 docs/research/codex-voice-ios.md              |   53 +
 docs/research/codex-voice-remote.md           |  166 +
 docs/research/codex-voice.md                  |  231 +
 docs/research/voice-remote-testing.md         |  170 +
 scripts/codex-voice-probe.py                  |   74 +
 scripts/codex-voice-remote-smoke.py           |  413 +
 scripts/codex-voice-smoke.py                  |  119 +
 scripts/package-linux.sh                      |    1 +
 scripts/package-macos.sh                      |    3 +-
 scripts/package-voice-runtime.py              |  137 +
 scripts/package-windows.ps1                   |    1 +
 scripts/run-macos-dev.sh                      |   12 +
 scripts/tests/test_voice_packaging.py         |  154 +
 scripts/tests/test_voice_remote.py            |  211 +
 scripts/tests/voice_remote_fixture.py         |  111 +
 208 files changed, 26316 insertions(+), 4357 deletions(-)
 create mode 100644 .github/workflows/voice-tests.yml
 create mode 100644 apps/ios/Zeron.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
 create mode 100644 apps/ios/Zeron/Voice/CodexVoicePeer.swift
 create mode 100644 apps/ios/Zeron/Voice/NativeVoiceMedia.swift
 create mode 100644 apps/ios/Zeron/Voice/OrbView.swift
 create mode 100644 apps/ios/Zeron/Voice/RemoteVoiceController.swift
 create mode 100644 apps/ios/Zeron/Voice/Sounds/voice-end.wav
 create mode 100644 apps/ios/Zeron/Voice/Sounds/voice-start.wav
 create mode 100644 apps/ios/Zeron/Voice/ThinkingOrbs-LICENSE.txt
 create mode 100644 apps/ios/Zeron/Voice/VoiceActivityController.swift
 create mode 100644 apps/ios/Zeron/Voice/VoiceControls.swift
 create mode 100644 apps/ios/Zeron/Voice/VoiceStageViewController.swift
 create mode 100644 apps/ios/Zeron/Voice/VoiceViewController.swift
 create mode 100644 apps/ios/Zeron/Voice/WebRTC-LICENSE.txt
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/orb-awaiting-avatar.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/orb-awaiting-inline.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/orb-connecting-avatar.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/orb-connecting-inline.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/orb-listening-avatar.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/orb-listening-inline.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/orb-muted-avatar.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/orb-muted-inline.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/orb-speaking-avatar.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/orb-speaking-inline.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/orb-working-avatar.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/Contents.json
 create mode 100644 apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/orb-working-inline.svg
 create mode 100644 apps/ios/ZeronLiveActivity/Info.plist
 create mode 100644 apps/ios/ZeronLiveActivity/VoiceLiveActivity.swift
 create mode 100644 apps/ios/ZeronLiveActivity/ZeronLiveActivityBundle.swift
 create mode 100644 apps/ios/ZeronShared/VoiceActivity.swift
 create mode 100644 apps/ios/ZeronTests/RemoteVoiceLifecycleTests.swift
 create mode 100644 apps/ios/ZeronUITests/VoiceFlowTests.swift
 create mode 100644 crates/audio/Cargo.toml
 create mode 100644 crates/audio/src/aec.rs
 create mode 100644 crates/audio/src/dsp.rs
 create mode 100644 crates/audio/src/lib.rs
 create mode 100644 crates/audio/src/native.rs
 create mode 100644 crates/audio/src/worker.rs
 create mode 100644 crates/doc/src/voice.rs
 create mode 100644 crates/engine/src/rpc/voice_chat.rs
 create mode 100644 crates/engine/src/rpc/voice_remote.rs
 create mode 100644 crates/engine/src/voice.rs
 create mode 100644 crates/engine/src/voice/remote.rs
 create mode 100644 crates/engine/tests/support/voice_relay.rs
 create mode 100644 crates/engine/tests/voice_runtime.rs
 create mode 100644 crates/harness/src/codex/realtime.rs
 create mode 100644 crates/harness/src/codex/realtime_host.rs
 create mode 100644 crates/harness/tests/fixtures/codex/voice-0.159.0.json
 create mode 100755 crates/harness/tests/fixtures/fake-codex-voice-host.py
 create mode 100755 crates/harness/tests/fixtures/fake-codex-voice-native.py
 create mode 100755 crates/harness/tests/fixtures/fake-codex-voice.py
 create mode 100644 crates/mobile/src/caption.rs
 create mode 100644 crates/mobile/src/client_ffi/voice.rs
 create mode 100644 crates/mobile/src/orb.rs
 create mode 100644 crates/orb/Cargo.toml
 create mode 100644 crates/orb/src/animator.rs
 create mode 100644 crates/orb/src/engine/braid.rs
 create mode 100644 crates/orb/src/engine/concepts.rs
 create mode 100644 crates/orb/src/engine/core.rs
 create mode 100644 crates/orb/src/engine/lattice.rs
 create mode 100644 crates/orb/src/engine/mod.rs
 create mode 100644 crates/orb/src/engine/morph.rs
 create mode 100644 crates/orb/src/engine/orbits.rs
 create mode 100644 crates/orb/src/engine/profiles.rs
 create mode 100644 crates/orb/src/engine/ribbon.rs
 create mode 100644 crates/orb/src/engine/web.rs
 create mode 100644 crates/orb/src/lib.rs
 create mode 100644 crates/orb/src/motion.rs
 create mode 100644 crates/orb/src/presets.rs
 create mode 100644 crates/orb/src/types.rs
 create mode 100644 crates/proto/src/voice.rs
 create mode 100644 crates/proto/src/voice/remote.rs
 create mode 100644 crates/ui/assets/icons/microphone-off.svg
 create mode 100644 crates/ui/assets/icons/phone-hang-up.svg
 create mode 100644 crates/ui/assets/sounds/voice-end.wav
 create mode 100644 crates/ui/assets/sounds/voice-start.wav
 create mode 100644 crates/ui/src/orb/mod.rs
 create mode 100644 crates/ui/src/orb/orb.rs
 create mode 100644 crates/ui/src/orb/paint.rs
 create mode 100644 crates/ui/src/shell/voice_stage.rs
 create mode 100644 crates/ui/src/voice.rs
 create mode 100644 crates/ui/src/voice/permissions.rs
 create mode 100644 crates/ui/src/voice/remote.rs
 create mode 100644 crates/ui/tests/voice_orb_geometry.rs
 create mode 100644 crates/veil/Cargo.toml
 create mode 100644 crates/veil/src/caption.rs
 create mode 100644 crates/veil/src/lib.rs
 create mode 100644 crates/voice-media/Cargo.toml
 create mode 100644 crates/voice-media/src/lib.rs
 create mode 100644 crates/voice-session/Cargo.toml
 create mode 100644 crates/voice-session/src/lib.rs
 create mode 100644 crates/voice-session/src/view.rs
 create mode 100644 dist/macos/Info-unbundled.plist
 create mode 100644 dist/macos/voice.entitlements
 create mode 100644 dist/voice/Codex-LICENSE.txt
 create mode 100644 dist/voice/README.md
 create mode 100644 docs/research/codex-voice-ios.md
 create mode 100644 docs/research/codex-voice-remote.md
 create mode 100644 docs/research/codex-voice.md
 create mode 100644 docs/research/voice-remote-testing.md
 create mode 100644 scripts/codex-voice-probe.py
 create mode 100644 scripts/codex-voice-remote-smoke.py
 create mode 100644 scripts/codex-voice-smoke.py
 create mode 100644 scripts/package-voice-runtime.py
 create mode 100644 scripts/tests/test_voice_packaging.py
 create mode 100644 scripts/tests/test_voice_remote.py
 create mode 100644 scripts/tests/voice_remote_fixture.py

diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 75c36c72e6..8e5b78f7ad 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -67,7 +67,7 @@ jobs:
             libfontconfig1-dev libfreetype-dev libasound2-dev
             libvulkan-dev pkg-config cmake libwebkit2gtk-4.1-dev libjson-glib-dev
       - name: UI and headless layout regressions
-        run: cargo nextest run --config-file scripts/ci/nextest.toml --locked --no-fail-fast -p zeron-ui --lib
+        run: cargo nextest run --config-file scripts/ci/nextest.toml --locked --no-fail-fast -p zeron-ui --lib --test voice_orb_geometry
 
   linux-browser:
     runs-on: ubuntu-24.04
diff --git a/.github/workflows/voice-tests.yml b/.github/workflows/voice-tests.yml
new file mode 100644
index 0000000000..8aeec8e2a0
--- /dev/null
+++ b/.github/workflows/voice-tests.yml
@@ -0,0 +1,123 @@
+name: Native Codex voice
+on:
+  pull_request:
+    paths:
+      - 'crates/audio/**'
+      - 'crates/voice-media/**'
+      - 'crates/voice-session/**'
+      - 'crates/orb/**'
+      - 'crates/proto/src/voice/**'
+      - 'crates/rpc/**'
+      - 'crates/client/**'
+      - 'crates/mobile/**'
+      - 'apps/ios/Zeron/Voice/**'
+      - 'apps/ios/ZeronTests/RemoteVoiceLifecycleTests.swift'
+      - 'dist/voice/**'
+      - 'scripts/package-voice-runtime.py'
+      - 'crates/proto/src/voice.rs'
+      - 'crates/harness/**'
+      - 'crates/engine/**'
+      - 'crates/ui/**'
+      - 'crates/mcp/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'scripts/codex-voice-remote-smoke.py'
+      - 'scripts/tests/*voice_remote*'
+      - 'scripts/tests/test_voice_packaging.py'
+      - '.github/workflows/voice-tests.yml'
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  runtime-packaging:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, windows-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: '3.12'
+      - name: Development runtime projection fixtures (no downloads or audio devices)
+        run: python -m unittest discover -s scripts/tests -p 'test_voice_packaging.py' -v
+
+  split-host-probe:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, macos-14]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Split-host diagnostic fixtures (no Codex, microphone or provider)
+        run: python3 -m unittest discover -s scripts/tests -p 'test_voice_remote*.py' -v
+
+  offline-linux:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 45
+    env:
+      CARGO_BUILD_JOBS: 2
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: llvm-tools-preview
+      - name: Native audio and GPUI build tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libasound2-dev clang libclang-dev pkg-config meson ninja-build libwayland-dev libxkbcommon-dev libxcb1-dev libxcb-shape0-dev libxcb-xfixes0-dev libx11-xcb-dev libxrandr-dev libxi-dev libxcursor-dev libx11-dev libxinerama-dev libegl1-mesa-dev libvulkan-dev libfontconfig1-dev libfreetype6-dev libssl-dev libdbus-1-dev
+      - uses: Swatinem/rust-cache@v2
+      - name: Protocol, transport and idle runtime (no provider access)
+        run: |
+          cargo test --locked -p zeron-voice-media --lib
+          cargo test --locked -p zeron-orb
+          cargo test --locked -p zeron-voice-session --lib
+          cargo test --locked -p zeron-mobile --lib voice
+          cargo test --locked -p zeron-mobile --lib orb
+          cargo test --locked -p zeron-proto voice --lib
+          cargo test --locked -p zeron-harness --lib
+          cargo test --locked -p zeron-harness --test codex --test acp
+          cargo test --locked -p zeron-doc voice --lib
+          cargo test --locked -p zeron-engine --lib voice
+          cargo test --locked -p zeron-engine --test voice_runtime
+          cargo test --locked -p zeron-engine --test device_routing
+          cargo test --locked -p zeron-rpc --test device_room
+          cargo test --locked -p zeron-mcp --lib
+      - name: Native audio and WebRTC AEC3
+        run: cargo test --locked -p zeron-audio --features aec --lib
+
+  native-platform-check:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-14, windows-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
+    env:
+      CARGO_BUILD_JOBS: 2
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Compile subscription bridge without audio hardware or provider access
+        run: cargo check --locked -p zeron-harness -p zeron-engine
+      - name: Installed and development runtime resolution
+        run: cargo test --locked -p zeron-voice-media --lib
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        if: runner.os == 'Windows'
+        with:
+          python-version: '3.12'
+      - name: Initialize a projected Windows runtime (no provider or audio devices)
+        if: runner.os == 'Windows'
+        run: |
+          $env:ZERON_VOICE_MEDIA_DIR = Join-Path $env:RUNNER_TEMP 'zeron-media/codex-resources/voice'
+          python scripts/package-voice-runtime.py --download --destination $env:ZERON_VOICE_MEDIA_DIR
+          if ($LASTEXITCODE -ne 0) { throw 'Voice runtime packaging failed' }
+          cargo test --locked -p zeron-voice-media --lib packaged_native_runtime_initializes_without_audio_devices -- --ignored
diff --git a/.gitignore b/.gitignore
index 56b41bfb5c..d138f7f9df 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,4 @@ edge/dist/
 .agents
 .claude
 CLAUDE.md
+/scripts/**/__pycache__/
diff --git a/Cargo.lock b/Cargo.lock
index f6a3905224..cdbe320ca9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -837,6 +837,15 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "autotools"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef941527c41b0fc0dd48511a8154cd5fc7e29200a0ff8b7203c5d777dbc795cf"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "av-scenechange"
 version = "0.14.1"
@@ -954,6 +963,26 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags 2.13.1",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.12.1",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash 2.1.3",
+ "shlex 1.3.0",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.8.0"
@@ -1916,10 +1945,10 @@ dependencies = [
  "alsa",
  "coreaudio-rs",
  "dasp_sample",
- "jni",
+ "jni 0.21.1",
  "js-sys",
  "libc",
- "mach2",
+ "mach2 0.5.0",
  "ndk",
  "ndk-context",
  "num-derive",
@@ -1937,6 +1966,36 @@ dependencies = [
  "windows 0.62.2",
 ]
 
+[[package]]
+name = "cpal"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f02e8d0327b42d3e2e4ab2119af397344eb9fc54a34bf0ddeaa1277af8681f1"
+dependencies = [
+ "alsa",
+ "block2 0.6.2",
+ "coreaudio-rs",
+ "dasp_sample",
+ "jni 0.22.4",
+ "js-sys",
+ "libc",
+ "mach2 0.6.0",
+ "ndk",
+ "ndk-context",
+ "num-derive",
+ "num-traits",
+ "objc2 0.6.4",
+ "objc2-audio-toolbox",
+ "objc2-avf-audio",
+ "objc2-core-audio",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+ "web-sys",
+ "windows 0.62.2",
+ "windows-core 0.62.2",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -3086,6 +3145,12 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
 [[package]]
 name = "fsevent-sys"
 version = "4.1.0"
@@ -3589,7 +3654,7 @@ dependencies = [
  "async-channel",
  "async-task",
  "backtrace",
- "bindgen",
+ "bindgen 0.71.1",
  "bitflags 2.13.1",
  "block",
  "cbindgen",
@@ -3622,7 +3687,7 @@ dependencies = [
  "itertools 0.14.0",
  "log",
  "lyon",
- "mach2",
+ "mach2 0.5.0",
  "media",
  "metal",
  "num_cpus",
@@ -3778,7 +3843,7 @@ dependencies = [
  "itertools 0.14.0",
  "libc",
  "log",
- "mach2",
+ "mach2 0.5.0",
  "media",
  "metal",
  "objc",
@@ -4821,6 +4886,36 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "jni"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
+dependencies = [
+ "cfg-if",
+ "combine",
+ "jni-macros",
+ "jni-sys 0.4.1",
+ "log",
+ "simd_cesu8",
+ "thiserror 2.0.20",
+ "walkdir",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jni-macros"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "simd_cesu8",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "jni-sys"
 version = "0.3.1"
@@ -5378,6 +5473,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "mach2"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
+
 [[package]]
 name = "macro_rules_attribute"
 version = "0.2.3"
@@ -5465,7 +5566,7 @@ version = "0.1.0"
 source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
 dependencies = [
  "anyhow",
- "bindgen",
+ "bindgen 0.71.1",
  "core-foundation 0.10.1",
  "core-video",
  "ctor",
@@ -6002,7 +6103,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
- "proc-macro-crate 1.3.1",
+ "proc-macro-crate 3.5.0",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -6113,6 +6214,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"
 dependencies = [
+ "bitflags 2.13.1",
  "objc2 0.6.4",
  "objc2-foundation 0.3.2",
 ]
@@ -9146,6 +9248,16 @@ version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
 
+[[package]]
+name = "simd_cesu8"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"
+dependencies = [
+ "rustc_version",
+ "simdutf8",
+]
+
 [[package]]
 name = "simd_helpers"
 version = "0.1.0"
@@ -10093,6 +10205,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "futures-util",
+ "libc",
  "pin-project-lite",
  "tokio",
 ]
@@ -11491,6 +11604,37 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "webrtc-audio-processing"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "190c57ced88d6307ba91778c245265a99f99d900a9239c87a1b15142330c9f7e"
+dependencies = [
+ "webrtc-audio-processing-config",
+ "webrtc-audio-processing-sys",
+]
+
+[[package]]
+name = "webrtc-audio-processing-config"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "142cbc598e3dcf1a71e90109b6169ca9ce28ec1910bf74eef30f3c420ce850a4"
+
+[[package]]
+name = "webrtc-audio-processing-sys"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8f6c2b4b20a03b165378172f0dbe23c49b2630b70091026589afbe04e79cd3e"
+dependencies = [
+ "anyhow",
+ "autotools",
+ "bindgen 0.72.1",
+ "cc",
+ "fs_extra",
+ "pkg-config",
+ "regex",
+]
+
 [[package]]
 name = "webview2-com"
 version = "0.38.2"
@@ -12291,7 +12435,7 @@ dependencies = [
  "gtk",
  "http",
  "javascriptcore-rs",
- "jni",
+ "jni 0.21.1",
  "libc",
  "ndk",
  "objc2 0.6.4",
@@ -12817,6 +12961,18 @@ dependencies = [
  "zeron-update",
 ]
 
+[[package]]
+name = "zeron-audio"
+version = "0.2.104"
+dependencies = [
+ "base64 0.22.1",
+ "cpal 0.18.2",
+ "crossbeam-queue",
+ "thiserror 2.0.20",
+ "webrtc-audio-processing",
+ "zeron-proto",
+]
+
 [[package]]
 name = "zeron-client"
 version = "0.2.104"
@@ -12839,6 +12995,7 @@ dependencies = [
  "zeron-proto",
  "zeron-rpc",
  "zeron-sync",
+ "zeron-voice-session",
 ]
 
 [[package]]
@@ -12920,6 +13077,7 @@ dependencies = [
  "uuid",
  "windows-sys 0.61.2",
  "zeron-proto",
+ "zeron-voice-media",
  "zip",
 ]
 
@@ -12952,19 +13110,29 @@ dependencies = [
 name = "zeron-mobile"
 version = "0.2.104"
 dependencies = [
+ "async-trait",
  "serde",
  "serde_json",
  "similar",
  "thiserror 2.0.20",
+ "tokio",
+ "tokio-util",
  "uniffi",
  "zeron-client",
  "zeron-doc",
  "zeron-markdown",
+ "zeron-orb",
  "zeron-proto",
  "zeron-syntax",
  "zeron-text",
+ "zeron-veil",
+ "zeron-voice-session",
 ]
 
+[[package]]
+name = "zeron-orb"
+version = "0.2.104"
+
 [[package]]
 name = "zeron-preview"
 version = "0.2.104"
@@ -13157,6 +13325,7 @@ dependencies = [
  "tempfile",
  "thiserror 2.0.20",
  "tokio",
+ "tokio-util",
  "tracing",
  "tracing-subscriber",
  "ttf-parser",
@@ -13172,12 +13341,16 @@ dependencies = [
  "zeron-engine",
  "zeron-harness",
  "zeron-markdown",
+ "zeron-orb",
  "zeron-proto",
  "zeron-rpc",
  "zeron-syntax",
  "zeron-theme",
  "zeron-update",
+ "zeron-veil",
  "zeron-voice",
+ "zeron-voice-media",
+ "zeron-voice-session",
 ]
 
 [[package]]
@@ -13196,12 +13369,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "zeron-veil"
+version = "0.2.104"
+
 [[package]]
 name = "zeron-voice"
 version = "0.2.104"
 dependencies = [
  "anyhow",
- "cpal",
+ "cpal 0.17.3",
  "hound",
  "parakeet-rs",
  "reqwest",
@@ -13213,6 +13390,37 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "zeron-voice-media"
+version = "0.2.104"
+dependencies = [
+ "async-trait",
+ "semver",
+ "serde_json",
+ "sha2",
+ "tempfile",
+ "tokio",
+ "tokio-util",
+ "zeron-proto",
+ "zeron-voice-session",
+]
+
+[[package]]
+name = "zeron-voice-session"
+version = "0.2.104"
+dependencies = [
+ "async-trait",
+ "futures",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "zeron-orb",
+ "zeron-proto",
+ "zeron-rpc",
+]
+
 [[package]]
 name = "zerotrie"
 version = "0.2.5"
diff --git a/Cargo.toml b/Cargo.toml
index 47682c6295..1715a65e49 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,12 @@
 resolver = "2"
 members = [
     "crates/voice",
+    "crates/voice-media",
+    "crates/voice-session",
+    "crates/orb",
+    "crates/veil",
     "crates/theme",
+    "crates/audio",
     "crates/proto",
     "crates/preview",
     "crates/doc",
@@ -28,6 +33,11 @@ license = "MIT"
 publish = false
 
 [workspace.dependencies]
+zeron-voice-session = { path = "crates/voice-session" }
+zeron-orb = { path = "crates/orb" }
+zeron-veil = { path = "crates/veil" }
+zeron-voice-media = { path = "crates/voice-media" }
+zeron-audio = { path = "crates/audio" }
 zeron-proto = { path = "crates/proto" }
 zeron-preview = { path = "crates/preview" }
 zeron-doc = { path = "crates/doc" }
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 886febec29..e58d4dc56a 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -147,3 +147,279 @@ Attribution is retained in the pinned Zui dependency’s `NOTICE`.
 Parakeet TDT 0.6B v3 model weights are by NVIDIA under CC BY 4.0. The optional download uses Ivan Stupakov's INT8 ONNX conversion, pinned to revision `8f23f0c03c8761650bdb5b40aaf3e40d2c15f1ce`, with per-file SHA-256 verification. Original: https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3. Conversion: https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx. License: https://creativecommons.org/licenses/by/4.0/.
 
 Native runtime dependencies: parakeet-rs 0.3.8 (MIT OR Apache-2.0), ort/ort-sys 2.0.0-rc.13 (MIT OR Apache-2.0), ONNX Runtime 1.28.0 (MIT), cpal 0.17.3 (Apache-2.0), and rubato 0.16.2 (MIT). See `crates/voice/NOTICE.md` for exact conversion provenance, changes, runtime/platform limitations and supported languages. Models are not included in the application bundle.
+
+## Bezel thinking orbs
+
+`crates/orb/` and `crates/ui/src/orb/` were extracted from Bezel
+(https://github.com/clearloop/bezel), revision
+`6141af9c16f7353cdf36003f7404e0a94566a163`, `crates/agent/src/orbs/`.
+This code is compiled into the desktop app and, through the mobile core,
+the iOS app; Bezel is not a dependency. The upstream module is a port of
+gpui-thinking-orbs (https://github.com/FrancoEscob/gpui-thinking-orbs), itself
+a port of Jakub Antalik's thinking-orbs
+(https://github.com/Jakubantalik/thinking-orbs); the orb algorithms and
+per-state tunings originate there. All three are MIT-licensed. Original
+attribution comments are retained. The iOS app carries this notice as
+`Voice/ThinkingOrbs-LICENSE.txt`.
+
+MIT License
+
+Copyright (c) 2026 clearloop
+Copyright (c) 2026 Wing (portions extracted from zeronsh/comet)
+Copyright (c) 2026 gpui-thinking-orbs contributors
+Copyright (c) 2026 Jakub Antalik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## Codex native voice protocol
+
+The bounded helper control protocol and native runtime environment in
+`crates/voice-media/src/lib.rs` are adapted from OpenAI Codex
+`rust-v0.159.0` (`377f7f557a6bdea0f3a2d26d4d899c66db4789d0`),
+`codex-rs/realtime-webrtc/src/{protocol,client,linux_alsa}.rs`.
+Copyright 2025 OpenAI. Licensed under the Apache License, Version 2.0.
+Upstream NOTICE: "OpenAI Codex. Copyright 2025 OpenAI."
+Zeron runs the helper of the user's separately installed standalone Codex, on
+every platform; Zeron packages do not contain or redistribute Codex binaries or
+its native audio runtime. This adaptation uses asynchronous bounded pipes and
+the Zeron engine's owner leases. The iOS voice endpoint
+(`apps/ios/Zeron/Voice/CodexVoicePeer.swift`) implements the transport behavior
+described by `codex-rs/voice-host/src/transport.rs` at
+`a956835d020762cb2b570053af06f643a11c0ecc` without copying its code.
+
+Voice sessions use OpenAI's service under the user's own ChatGPT-authenticated
+Codex account and OpenAI's terms; this license covers the adapted code only.
+OpenAI, ChatGPT and Codex are trademarks of OpenAI. Zeron is not affiliated
+with or endorsed by OpenAI. The license text follows.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 OpenAI
+
+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
+
+       http://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.
+
+## WebRTC for iOS voice
+
+The iOS app links the WebRTC XCFramework from the `stasel/WebRTC` Swift package,
+pinned to 150.0.0 (binary SHA-256
+`f9890492b0016e4c88ab20f07867b8b420054caedc8a692b2ec6ac041f3cf6b2`), a build of
+Google's WebRTC: https://github.com/stasel/WebRTC/tree/150.0.0. WebRTC is
+licensed under the BSD 3-Clause License, "Copyright (c) 2011, The WebRTC project
+authors. All rights reserved.", with Google's additional patent grant:
+https://webrtc.org/support/license. The full license text ships in the iOS app
+as `Voice/WebRTC-LICENSE.txt`. The binary also contains WebRTC's own bundled
+third-party components (such as BoringSSL, libsrtp, Opus, libyuv and Abseil)
+under their respective licenses; see the WebRTC source tree's `third_party/`
+for each license.
diff --git a/apps/ios/README.md b/apps/ios/README.md
index 682317fd2f..b83117fcae 100644
--- a/apps/ios/README.md
+++ b/apps/ios/README.md
@@ -48,6 +48,11 @@ Zeron/
   Shell/       Tab bar (Sessions, Settings, search; "New session" accessory
                with live summary), sign-in
   Debug/       Transcript lab + hitch meter
+ZeronLiveActivity/  Widget extension: the voice call's Live Activity (Dynamic
+               Island + Lock Screen), with the orb's states exported from
+               zeron-orb as vector assets
+ZeronShared/   Compiled into the app and the extension: the activity's
+               attributes and its mute/end App Intents
 ```
 
 ### Transcript pipeline
diff --git a/apps/ios/Zeron.xcodeproj/project.pbxproj b/apps/ios/Zeron.xcodeproj/project.pbxproj
index e1d7866b8c..535f4d6817 100644
--- a/apps/ios/Zeron.xcodeproj/project.pbxproj
+++ b/apps/ios/Zeron.xcodeproj/project.pbxproj
@@ -14,6 +14,21 @@
 			);
 			target = A1000000000000000000T001 /* Zeron */;
 		};
+		A400000000000000000000E1 /* Exceptions for "ZeronLiveActivity" folder in "ZeronLiveActivity" target */ = {
+			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+			membershipExceptions = (
+				Info.plist,
+			);
+			target = A4000000000000000000T001 /* ZeronLiveActivity */;
+		};
+		A400000000000000000000E2 /* Exceptions for "Zeron" folder in "ZeronLiveActivity" target */ = {
+			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+			membershipExceptions = (
+				"Fonts/Geist-Medium.ttf",
+				"Fonts/GeistMono-Medium.ttf",
+			);
+			target = A4000000000000000000T001 /* ZeronLiveActivity */;
+		};
 /* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
 
 /* Begin PBXFileSystemSynchronizedRootGroup section */
@@ -21,6 +36,7 @@
 			isa = PBXFileSystemSynchronizedRootGroup;
 			exceptions = (
 				A100000000000000000000E1 /* Exceptions for "Zeron" folder in "Zeron" target */,
+				A400000000000000000000E2 /* Exceptions for "Zeron" folder in "ZeronLiveActivity" target */,
 			);
 			path = Zeron;
 			sourceTree = "<group>";
@@ -35,6 +51,19 @@
 			path = ZeronUITests;
 			sourceTree = "<group>";
 		};
+		A4000000000000000000G001 /* ZeronLiveActivity */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			exceptions = (
+				A400000000000000000000E1 /* Exceptions for "ZeronLiveActivity" folder in "ZeronLiveActivity" target */,
+			);
+			path = ZeronLiveActivity;
+			sourceTree = "<group>";
+		};
+		A5000000000000000000G001 /* ZeronShared */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			path = ZeronShared;
+			sourceTree = "<group>";
+		};
 /* End PBXFileSystemSynchronizedRootGroup section */
 
 /* Begin PBXContainerItemProxy section */
@@ -52,6 +81,13 @@
 			remoteGlobalIDString = A1000000000000000000T001;
 			remoteInfo = Zeron;
 		};
+		A4000000000000000000X001 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = A1000000000000000000PJ01 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = A4000000000000000000T001;
+			remoteInfo = ZeronLiveActivity;
+		};
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXTargetDependency section */
@@ -65,19 +101,56 @@
 			target = A1000000000000000000T001 /* Zeron */;
 			targetProxy = A3000000000000000000X001 /* PBXContainerItemProxy */;
 		};
+		A4000000000000000000D001 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = A4000000000000000000T001 /* ZeronLiveActivity */;
+			targetProxy = A4000000000000000000X001 /* PBXContainerItemProxy */;
+		};
 /* End PBXTargetDependency section */
 
 /* Begin PBXFileReference section */
 		A1000000000000000000PR01 /* Zeron.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Zeron.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		A2000000000000000000PR01 /* ZeronTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = ZeronTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		A3000000000000000000PR01 /* ZeronUITests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = ZeronUITests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		A4000000000000000000PR01 /* ZeronLiveActivity.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = ZeronLiveActivity.appex; sourceTree = BUILT_PRODUCTS_DIR; };
 /* End PBXFileReference section */
 
+/* Begin PBXBuildFile section */
+        B71000000000000000000001 /* WebRTC in Frameworks */ = {isa = PBXBuildFile; productRef = B71000000000000000000002 /* WebRTC */; };
+		A4000000000000000000BF01 /* ZeronLiveActivity.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = A4000000000000000000PR01 /* ZeronLiveActivity.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
+/* End PBXBuildFile section */
+/* Begin PBXCopyFilesBuildPhase section */
+		A1000000000000000000CP01 /* Embed Foundation Extensions */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 13;
+			files = (
+				A4000000000000000000BF01 /* ZeronLiveActivity.appex in Embed Foundation Extensions */,
+			);
+			name = "Embed Foundation Extensions";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+/* Begin XCRemoteSwiftPackageReference section */
+        B71000000000000000000003 /* WebRTC */ = {isa = XCRemoteSwiftPackageReference; repositoryURL = "https://github.com/stasel/WebRTC.git"; requirement = {kind = exactVersion; version = 150.0.0; }; };
+/* End XCRemoteSwiftPackageReference section */
+/* Begin XCSwiftPackageProductDependency section */
+        B71000000000000000000002 /* WebRTC */ = {isa = XCSwiftPackageProductDependency; package = B71000000000000000000003; productName = WebRTC; };
+/* End XCSwiftPackageProductDependency section */
 /* Begin PBXFrameworksBuildPhase section */
 		A1000000000000000000F001 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+                B71000000000000000000001 /* WebRTC in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		A4000000000000000000F001 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -90,6 +163,8 @@
 				A1000000000000000000G001 /* Zeron */,
 				A2000000000000000000G001 /* ZeronTests */,
 				A3000000000000000000G001 /* ZeronUITests */,
+				A4000000000000000000G001 /* ZeronLiveActivity */,
+				A5000000000000000000G001 /* ZeronShared */,
 				A1000000000000000000G002 /* Products */,
 			);
 			sourceTree = "<group>";
@@ -100,6 +175,7 @@
 				A1000000000000000000PR01 /* Zeron.app */,
 				A2000000000000000000PR01 /* ZeronTests.xctest */,
 				A3000000000000000000PR01 /* ZeronUITests.xctest */,
+				A4000000000000000000PR01 /* ZeronLiveActivity.appex */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -115,17 +191,20 @@
 				A1000000000000000000S001 /* Sources */,
 				A1000000000000000000F001 /* Frameworks */,
 				A1000000000000000000R001 /* Resources */,
+				A1000000000000000000CP01 /* Embed Foundation Extensions */,
 			);
 			buildRules = (
 			);
 			dependencies = (
+				A4000000000000000000D001 /* PBXTargetDependency */,
 			);
 			fileSystemSynchronizedGroups = (
 				A1000000000000000000G001 /* Zeron */,
+				A5000000000000000000G001 /* ZeronShared */,
 			);
 			name = Zeron;
 			packageProductDependencies = (
-			);
+                B71000000000000000000002 /* WebRTC */,			);
 			productName = Zeron;
 			productReference = A1000000000000000000PR01 /* Zeron.app */;
 			productType = "com.apple.product-type.application";
@@ -172,11 +251,35 @@
 			productReference = A3000000000000000000PR01 /* ZeronUITests.xctest */;
 			productType = "com.apple.product-type.bundle.ui-testing";
 		};
+		A4000000000000000000T001 /* ZeronLiveActivity */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = A4000000000000000000C001 /* Build configuration list for PBXNativeTarget "ZeronLiveActivity" */;
+			buildPhases = (
+				A4000000000000000000S001 /* Sources */,
+				A4000000000000000000F001 /* Frameworks */,
+				A4000000000000000000R001 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			fileSystemSynchronizedGroups = (
+				A4000000000000000000G001 /* ZeronLiveActivity */,
+				A5000000000000000000G001 /* ZeronShared */,
+			);
+			name = ZeronLiveActivity;
+			packageProductDependencies = (
+			);
+			productName = ZeronLiveActivity;
+			productReference = A4000000000000000000PR01 /* ZeronLiveActivity.appex */;
+			productType = "com.apple.product-type.app-extension";
+		};
 /* End PBXNativeTarget section */
 
 /* Begin PBXProject section */
 		A1000000000000000000PJ01 /* Project object */ = {
 			isa = PBXProject;
+            packageReferences = (B71000000000000000000003);
 			attributes = {
 				BuildIndependentTargetsInParallel = 1;
 				LastSwiftUpdateCheck = 2630;
@@ -185,6 +288,9 @@
 					A1000000000000000000T001 = {
 						CreatedOnToolsVersion = 26.3;
 					};
+					A4000000000000000000T001 = {
+						CreatedOnToolsVersion = 26.3;
+					};
 				};
 			};
 			buildConfigurationList = A1000000000000000000C000 /* Build configuration list for PBXProject "Zeron" */;
@@ -204,6 +310,7 @@
 				A1000000000000000000T001 /* Zeron */,
 				A2000000000000000000T001 /* ZeronTests */,
 				A3000000000000000000T001 /* ZeronUITests */,
+				A4000000000000000000T001 /* ZeronLiveActivity */,
 			);
 		};
 /* End PBXProject section */
@@ -216,6 +323,13 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
+		A4000000000000000000R001 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
@@ -263,6 +377,13 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
+		A4000000000000000000S001 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 /* End PBXSourcesBuildPhase section */
 
 /* Begin XCBuildConfiguration section */
@@ -470,6 +591,60 @@
 			};
 			name = Release;
 		};
+		A4000000000000000000BC03 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				APPLICATION_EXTENSION_API_ONLY = YES;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				DEVELOPMENT_TEAM = 5XY3M483YQ;
+				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = ZeronLiveActivity/Info.plist;
+				INFOPLIST_KEY_CFBundleDisplayName = Zeron;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@executable_path/../../Frameworks",
+				);
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = sh.zeron.ios.LiveActivity;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SKIP_INSTALL = YES;
+				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+				SUPPORTS_MACCATALYST = NO;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		A4000000000000000000BC04 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				APPLICATION_EXTENSION_API_ONLY = YES;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				DEVELOPMENT_TEAM = 5XY3M483YQ;
+				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = ZeronLiveActivity/Info.plist;
+				INFOPLIST_KEY_CFBundleDisplayName = Zeron;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@executable_path/../../Frameworks",
+				);
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = sh.zeron.ios.LiveActivity;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SKIP_INSTALL = YES;
+				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+				SUPPORTS_MACCATALYST = NO;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
@@ -509,6 +684,15 @@
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
+		A4000000000000000000C001 /* Build configuration list for PBXNativeTarget "ZeronLiveActivity" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A4000000000000000000BC03 /* Debug */,
+				A4000000000000000000BC04 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
 /* End XCConfigurationList section */
 
 	};
diff --git a/apps/ios/Zeron.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/apps/ios/Zeron.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
new file mode 100644
index 0000000000..55e026c921
--- /dev/null
+++ b/apps/ios/Zeron.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -0,0 +1,15 @@
+{
+  "originHash" : "7ca243407a3b132834ec3b117a3aea85a8f743151ef868a872c8bbf8082921f6",
+  "pins" : [
+    {
+      "identity" : "webrtc",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/stasel/WebRTC.git",
+      "state" : {
+        "revision" : "6ed87f05368632f71dc95c89c14c051561710925",
+        "version" : "150.0.0"
+      }
+    }
+  ],
+  "version" : 3
+}
diff --git a/apps/ios/Zeron/App/AppModel.swift b/apps/ios/Zeron/App/AppModel.swift
index 9cc98061c6..78156eb861 100644
--- a/apps/ios/Zeron/App/AppModel.swift
+++ b/apps/ios/Zeron/App/AppModel.swift
@@ -17,6 +17,7 @@ final class AppModel {
         var awaiting = 0
     }
 
+    @MainActor lazy var voice = RemoteVoiceController(app: self)
     private(set) var client: CoreClient?
     private(set) var frontPage = FrontPage()
     private(set) var archived: [SessionRowVM] = []
@@ -196,7 +197,8 @@ final class AppModel {
     }
 
     /// The user signing out: this device forgets the account's local docs.
-    func signOut() {
+    @MainActor func signOut() {
+        voice.stop()
         forgetOnSignOut = true
         onSignOut?()
     }
@@ -206,7 +208,8 @@ final class AppModel {
     /// keeps a different account out of it.
     private var forgetOnSignOut = false
 
-    func signOutLocally() {
+    @MainActor func signOutLocally() {
+        voice.stop()
         client?.shutdown()
         client = nil
         Credentials.clearStored()
diff --git a/apps/ios/Zeron/App/SceneDelegate.swift b/apps/ios/Zeron/App/SceneDelegate.swift
index fe75152937..2afd6f584f 100644
--- a/apps/ios/Zeron/App/SceneDelegate.swift
+++ b/apps/ios/Zeron/App/SceneDelegate.swift
@@ -53,6 +53,14 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
         window.makeKeyAndVisible()
         if !args.contains("-lab") { shellShown() }
 
+        #if DEBUG
+        if args.contains("-voice-preview") {
+            app.voice.preview()
+            if args.contains("-voice-stage") {
+                DispatchQueue.main.async { [app] in window.rootViewController?.presentVoiceStage(app: app, source: nil) }
+            }
+        }
+        #endif
         if let router = window.rootViewController as? AppRouter, let i = args.firstIndex(of: "-route"), i + 1 < args.count {
             let route = args[i + 1]
             DispatchQueue.main.async {
@@ -93,6 +101,14 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
         }
     }
 
+    /// `zeron://voice` (the call's Live Activity) returns to the stage.
+    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
+        guard URLContexts.contains(where: { $0.url.scheme == "zeron" && $0.url.host == "voice" }),
+              app.voice.live, let root = window?.rootViewController
+        else { return }
+        root.presentVoiceStage(app: app, source: nil)
+    }
+
     func sceneDidEnterBackground(_ scene: UIScene) {
         app.didEnterBackground()
     }
diff --git a/apps/ios/Zeron/Core/Generated/zeron_core.swift b/apps/ios/Zeron/Core/Generated/zeron_core.swift
index a8d2fe3ff8..55e89c2ef4 100644
--- a/apps/ios/Zeron/Core/Generated/zeron_core.swift
+++ b/apps/ios/Zeron/Core/Generated/zeron_core.swift
@@ -671,6 +671,143 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer {
 
 
 
+/**
+ * One call's caption. Advance it whenever the caption changes and on every
+ * display frame while the last frame was `animating`.
+ */
+public protocol CaptionFaderProtocol: AnyObject, Sendable {
+    
+    func frame(item: String?, text: String, reducedMotion: Bool)  -> CaptionFrame
+    
+}
+/**
+ * One call's caption. Advance it whenever the caption changes and on every
+ * display frame while the last frame was `animating`.
+ */
+open class CaptionFader: CaptionFaderProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
+
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoHandle {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_zeron_mobile_fn_clone_captionfader(self.handle, $0) }
+    }
+public convenience init(maxChars: UInt32) {
+    let handle =
+        try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_constructor_captionfader_new(
+        FfiConverterUInt32.lower(maxChars),uniffiCallStatus
+    )
+}
+    self.init(unsafeFromHandle: handle)
+}
+
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
+
+        try! rustCall { uniffi_zeron_mobile_fn_free_captionfader(handle, $0) }
+    }
+
+    
+
+    
+open func frame(item: String?, text: String, reducedMotion: Bool) -> CaptionFrame  {
+    return try!  FfiConverterTypeCaptionFrame_lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_captionfader_frame(
+            self.uniffiCloneHandle(),
+        FfiConverterOptionString.lower(item),
+        FfiConverterString.lower(text),
+        FfiConverterBool.lower(reducedMotion),uniffiCallStatus
+    )
+})
+}
+    
+
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCaptionFader: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = CaptionFader
+
+    public static func lift(_ handle: UInt64) throws -> CaptionFader {
+        return CaptionFader(unsafeFromHandle: handle)
+    }
+
+    public static func lower(_ value: CaptionFader) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CaptionFader {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: CaptionFader, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCaptionFader_lift(_ handle: UInt64) throws -> CaptionFader {
+    return try FfiConverterTypeCaptionFader.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCaptionFader_lower(_ value: CaptionFader) -> UInt64 {
+    return FfiConverterTypeCaptionFader.lower(value)
+}
+
+
+
+
+
+
 /**
  * Receives coalesced change events (at most one burst per display frame).
  * Called on a client thread: hop to the main thread and pull there.
@@ -1098,6 +1235,12 @@ public protocol CoreClientProtocol: AnyObject, Sendable {
      */
     func workspaceRevision()  -> UInt64
     
+    /**
+     * Returns immediately. Callbacks are dispatched on the core runtime; the
+     * platform must hop to its media/UI executor and call complete_media.
+     */
+    func startVoice(hostDeviceId: String, voice: String?, media: VoiceMediaListener, listener: VoiceSessionListener)  -> VoiceCall
+    
 }
 /**
  * One signed-in account (or Demo mode). Create one per sign-in; call
@@ -1899,6 +2042,23 @@ open func workspaceRevision() -> UInt64  {
 })
 }
     
+    /**
+     * Returns immediately. Callbacks are dispatched on the core runtime; the
+     * platform must hop to its media/UI executor and call complete_media.
+     */
+open func startVoice(hostDeviceId: String, voice: String?, media: VoiceMediaListener, listener: VoiceSessionListener) -> VoiceCall  {
+    return try!  FfiConverterTypeVoiceCall_lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_coreclient_start_voice(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(hostDeviceId),
+        FfiConverterOptionString.lower(voice),
+        FfiConverterTypeVoiceMediaListener_lower(media),
+        FfiConverterTypeVoiceSessionListener_lower(listener),uniffiCallStatus
+    )
+})
+}
+    
 
     
 }
@@ -2467,6 +2627,183 @@ public func FfiConverterTypeLayoutListener_lower(_ value: LayoutListener) -> UIn
 
 
 
+/**
+ * One animated orb. Calls are cheap and safe from any thread; drive
+ * [`OrbRenderer::next_frame`] from the display link.
+ */
+public protocol OrbRendererProtocol: AnyObject, Sendable {
+    
+    /**
+     * Advance to now and return the frame to paint. Time only accumulates
+     * while `animating`; reduced motion shows the static representative frame.
+     */
+    func nextFrame(animating: Bool, reducedMotion: Bool)  -> OrbFrame
+    
+    /**
+     * Normalized 0…1 peaks; they speed the motion up, never the geometry.
+     */
+    func setAudioLevels(microphone: Float, speaker: Float) 
+    
+    func setOrb(orb: VoiceOrb) 
+    
+}
+/**
+ * One animated orb. Calls are cheap and safe from any thread; drive
+ * [`OrbRenderer::next_frame`] from the display link.
+ */
+open class OrbRenderer: OrbRendererProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
+
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoHandle {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_zeron_mobile_fn_clone_orbrenderer(self.handle, $0) }
+    }
+    /**
+     * Crossfades state changes over 300 ms, like the desktop voice orbs.
+     */
+public convenience init(preset: OrbPreset, orb: VoiceOrb) {
+    let handle =
+        try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_constructor_orbrenderer_new(
+        FfiConverterTypeOrbPreset_lower(preset),
+        FfiConverterTypeVoiceOrb_lower(orb),uniffiCallStatus
+    )
+}
+    self.init(unsafeFromHandle: handle)
+}
+
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
+
+        try! rustCall { uniffi_zeron_mobile_fn_free_orbrenderer(handle, $0) }
+    }
+
+    
+
+    
+    /**
+     * Advance to now and return the frame to paint. Time only accumulates
+     * while `animating`; reduced motion shows the static representative frame.
+     */
+open func nextFrame(animating: Bool, reducedMotion: Bool) -> OrbFrame  {
+    return try!  FfiConverterTypeOrbFrame_lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_orbrenderer_next_frame(
+            self.uniffiCloneHandle(),
+        FfiConverterBool.lower(animating),
+        FfiConverterBool.lower(reducedMotion),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * Normalized 0…1 peaks; they speed the motion up, never the geometry.
+     */
+open func setAudioLevels(microphone: Float, speaker: Float)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_orbrenderer_set_audio_levels(
+            self.uniffiCloneHandle(),
+        FfiConverterFloat.lower(microphone),
+        FfiConverterFloat.lower(speaker),uniffiCallStatus
+    )
+}
+}
+    
+open func setOrb(orb: VoiceOrb)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_orbrenderer_set_orb(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeVoiceOrb_lower(orb),uniffiCallStatus
+    )
+}
+}
+    
+
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeOrbRenderer: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = OrbRenderer
+
+    public static func lift(_ handle: UInt64) throws -> OrbRenderer {
+        return OrbRenderer(unsafeFromHandle: handle)
+    }
+
+    public static func lower(_ value: OrbRenderer) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OrbRenderer {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: OrbRenderer, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeOrbRenderer_lift(_ handle: UInt64) throws -> OrbRenderer {
+    return try FfiConverterTypeOrbRenderer.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeOrbRenderer_lower(_ value: OrbRenderer) -> UInt64 {
+    return FfiConverterTypeOrbRenderer.lower(value)
+}
+
+
+
+
+
+
 /**
  * Measures text the bundled faces can't render (emoji, CJK…) with the
  * platform's own text engine — pretext's "browser as ground truth".
@@ -3753,101 +4090,133 @@ public func FfiConverterTypeUploadProgress_lower(_ value: UploadProgress) -> UIn
 
 
 
-public struct AppshotLabel: Equatable, Hashable {
-    public var appName: String
-    public var windowTitle: String?
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(appName: String, windowTitle: String?) {
-        self.appName = appName
-        self.windowTitle = windowTitle
-    }
 
+public protocol VoiceCallProtocol: AnyObject, Sendable {
     
-
+    /**
+     * Late native callbacks simply miss the retired request. No resume is possible.
+     */
+    func completeMedia(requestId: UInt64, failure: VoiceMediaFailure?, sdp: String?, microphone: UInt16, speaker: UInt16) 
+    
+    func setMuted(muted: Bool) 
+    
+    func stop() 
     
 }
+open class VoiceCall: VoiceCallProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
 
-#if compiler(>=6)
-extension AppshotLabel: Sendable {}
-#endif
-
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeAppshotLabel: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppshotLabel {
-        return
-            try AppshotLabel(
-                appName: FfiConverterString.read(from: &buf), 
-                windowTitle: FfiConverterOptionString.read(from: &buf)
-        )
+    public struct NoHandle {
+        public init() {}
     }
 
-    public static func write(_ value: AppshotLabel, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.appName, into: &buf)
-        FfiConverterOptionString.write(value.windowTitle, into: &buf)
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
     }
-}
-
 
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAppshotLabel_lift(_ buf: RustBuffer) throws -> AppshotLabel {
-    return try FfiConverterTypeAppshotLabel.lift(buf)
-}
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
 
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAppshotLabel_lower(_ value: AppshotLabel) -> RustBuffer {
-    return FfiConverterTypeAppshotLabel.lower(value)
-}
-
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_zeron_mobile_fn_clone_voicecall(self.handle, $0) }
+    }
+    // No primary constructor declared for this class.
 
-public struct AuthExchange: Equatable, Hashable {
-    public var user: AuthUser
-    /**
-     * Unscoped pair: refresh with an organization id before use.
-     */
-    public var tokens: AuthTokens
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(user: AuthUser, 
-        /**
-         * Unscoped pair: refresh with an organization id before use.
-         */tokens: AuthTokens) {
-        self.user = user
-        self.tokens = tokens
+        try! rustCall { uniffi_zeron_mobile_fn_free_voicecall(handle, $0) }
     }
 
     
 
     
+    /**
+     * Late native callbacks simply miss the retired request. No resume is possible.
+     */
+open func completeMedia(requestId: UInt64, failure: VoiceMediaFailure?, sdp: String?, microphone: UInt16, speaker: UInt16)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_voicecall_complete_media(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(requestId),
+        FfiConverterOptionTypeVoiceMediaFailure.lower(failure),
+        FfiConverterOptionString.lower(sdp),
+        FfiConverterUInt16.lower(microphone),
+        FfiConverterUInt16.lower(speaker),uniffiCallStatus
+    )
+}
+}
+    
+open func setMuted(muted: Bool)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_voicecall_set_muted(
+            self.uniffiCloneHandle(),
+        FfiConverterBool.lower(muted),uniffiCallStatus
+    )
+}
+}
+    
+open func stop()  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_voicecall_stop(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+}
+}
+    
+
+    
 }
 
-#if compiler(>=6)
-extension AuthExchange: Sendable {}
-#endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeAuthExchange: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthExchange {
-        return
-            try AuthExchange(
-                user: FfiConverterTypeAuthUser.read(from: &buf), 
-                tokens: FfiConverterTypeAuthTokens.read(from: &buf)
-        )
+public struct FfiConverterTypeVoiceCall: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = VoiceCall
+
+    public static func lift(_ handle: UInt64) throws -> VoiceCall {
+        return VoiceCall(unsafeFromHandle: handle)
     }
 
-    public static func write(_ value: AuthExchange, into buf: inout [UInt8]) {
-        FfiConverterTypeAuthUser.write(value.user, into: &buf)
-        FfiConverterTypeAuthTokens.write(value.tokens, into: &buf)
+    public static func lower(_ value: VoiceCall) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceCall {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: VoiceCall, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
     }
 }
 
@@ -3855,173 +4224,197 @@ public struct FfiConverterTypeAuthExchange: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthExchange_lift(_ buf: RustBuffer) throws -> AuthExchange {
-    return try FfiConverterTypeAuthExchange.lift(buf)
+public func FfiConverterTypeVoiceCall_lift(_ handle: UInt64) throws -> VoiceCall {
+    return try FfiConverterTypeVoiceCall.lift(handle)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthExchange_lower(_ value: AuthExchange) -> RustBuffer {
-    return FfiConverterTypeAuthExchange.lower(value)
+public func FfiConverterTypeVoiceCall_lower(_ value: VoiceCall) -> UInt64 {
+    return FfiConverterTypeVoiceCall.lower(value)
 }
 
 
-public struct AuthOrg: Equatable, Hashable {
-    public var id: String
-    public var organizationId: String
-    public var name: String
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(id: String, organizationId: String, name: String) {
-        self.id = id
-        self.organizationId = organizationId
-        self.name = name
-    }
 
-    
 
+
+public protocol VoiceMediaListener: AnyObject, Sendable {
+    
+    func onRequest(request: VoiceMediaRequest) 
     
 }
+open class VoiceMediaListenerImpl: VoiceMediaListener, @unchecked Sendable {
+    fileprivate let handle: UInt64
 
-#if compiler(>=6)
-extension AuthOrg: Sendable {}
-#endif
-
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeAuthOrg: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthOrg {
-        return
-            try AuthOrg(
-                id: FfiConverterString.read(from: &buf), 
-                organizationId: FfiConverterString.read(from: &buf), 
-                name: FfiConverterString.read(from: &buf)
-        )
+    public struct NoHandle {
+        public init() {}
     }
 
-    public static func write(_ value: AuthOrg, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.organizationId, into: &buf)
-        FfiConverterString.write(value.name, into: &buf)
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
     }
-}
-
 
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthOrg_lift(_ buf: RustBuffer) throws -> AuthOrg {
-    return try FfiConverterTypeAuthOrg.lift(buf)
-}
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
 
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthOrg_lower(_ value: AuthOrg) -> RustBuffer {
-    return FfiConverterTypeAuthOrg.lower(value)
-}
-
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_zeron_mobile_fn_clone_voicemedialistener(self.handle, $0) }
+    }
+    // No primary constructor declared for this class.
 
-public struct AuthTokens: Equatable, Hashable {
-    public var accessToken: String
-    public var refreshToken: String
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(accessToken: String, refreshToken: String) {
-        self.accessToken = accessToken
-        self.refreshToken = refreshToken
+        try! rustCall { uniffi_zeron_mobile_fn_free_voicemedialistener(handle, $0) }
     }
 
     
 
     
+open func onRequest(request: VoiceMediaRequest)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_voicemedialistener_on_request(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeVoiceMediaRequest_lower(request),uniffiCallStatus
+    )
 }
-
-#if compiler(>=6)
-extension AuthTokens: Sendable {}
-#endif
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public struct FfiConverterTypeAuthTokens: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthTokens {
-        return
-            try AuthTokens(
-                accessToken: FfiConverterString.read(from: &buf), 
-                refreshToken: FfiConverterString.read(from: &buf)
-        )
-    }
-
-    public static func write(_ value: AuthTokens, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.accessToken, into: &buf)
-        FfiConverterString.write(value.refreshToken, into: &buf)
-    }
 }
+    
 
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public func FfiConverterTypeAuthTokens_lift(_ buf: RustBuffer) throws -> AuthTokens {
-    return try FfiConverterTypeAuthTokens.lift(buf)
+    
 }
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public func FfiConverterTypeAuthTokens_lower(_ value: AuthTokens) -> RustBuffer {
-    return FfiConverterTypeAuthTokens.lower(value)
-}
 
 
-public struct AuthUser: Equatable, Hashable {
-    public var id: String
-    public var email: String?
-    public var firstName: String?
-    public var lastName: String?
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceVoiceMediaListener {
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(id: String, email: String?, firstName: String?, lastName: String?) {
-        self.id = id
-        self.email = email
-        self.firstName = firstName
-        self.lastName = lastName
-    }
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // Store the vtable directly.
+    static let vtable: UniffiVTableCallbackInterfaceVoiceMediaListener = UniffiVTableCallbackInterfaceVoiceMediaListener(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterTypeVoiceMediaListener.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface VoiceMediaListener: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterTypeVoiceMediaListener.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface VoiceMediaListener: handle missing in uniffiClone")
+            }
+        },
+        onRequest: { (
+            uniffiHandle: UInt64,
+            request: RustBuffer,
+            uniffiOutReturn: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> () in
+                guard let uniffiObj = try? FfiConverterTypeVoiceMediaListener.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.onRequest(
+                     request: try FfiConverterTypeVoiceMediaRequest_lift(request)
+                )
+            }
 
-    
+            
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )
 
-    
+    // Rust stores this pointer for future callback invocations, so it must live
+    // for the process lifetime (not just for the init function call).
+    //
+    // `nonisolated(unsafe)` is needed under Swift 6 strict concurrency.
+    // This is safe because the pointee is initialized once during static init
+    // and never mutated by either side of the FFI.  Its fields are C function pointers.
+    nonisolated(unsafe) static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceVoiceMediaListener> = {
+        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceVoiceMediaListener>.allocate(capacity: 1)
+        ptr.initialize(to: vtable)
+        return UnsafePointer(ptr)
+    }()
 }
 
-#if compiler(>=6)
-extension AuthUser: Sendable {}
-#endif
+private func uniffiCallbackInitVoiceMediaListener() {
+    uniffi_zeron_mobile_fn_init_callback_vtable_voicemedialistener(UniffiCallbackInterfaceVoiceMediaListener.vtablePtr)
+}
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeAuthUser: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthUser {
-        return
-            try AuthUser(
-                id: FfiConverterString.read(from: &buf), 
-                email: FfiConverterOptionString.read(from: &buf), 
-                firstName: FfiConverterOptionString.read(from: &buf), 
-                lastName: FfiConverterOptionString.read(from: &buf)
-        )
+public struct FfiConverterTypeVoiceMediaListener: FfiConverter {
+    fileprivate static let handleMap = UniffiHandleMap<VoiceMediaListener>()
+
+    typealias FfiType = UInt64
+    typealias SwiftType = VoiceMediaListener
+
+    public static func lift(_ handle: UInt64) throws -> VoiceMediaListener {
+        if ((handle & 1) == 0) {
+            // Rust-generated handle, construct a new class that uses the handle to implement the
+            // interface
+            return VoiceMediaListenerImpl(unsafeFromHandle: handle)
+        } else {
+            // Swift-generated handle, get the object from the handle map
+            return try handleMap.remove(handle: handle)
+        }
     }
 
-    public static func write(_ value: AuthUser, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterOptionString.write(value.email, into: &buf)
-        FfiConverterOptionString.write(value.firstName, into: &buf)
-        FfiConverterOptionString.write(value.lastName, into: &buf)
+    public static func lower(_ value: VoiceMediaListener) -> UInt64 {
+         if let rustImpl = value as? VoiceMediaListenerImpl {
+             // Rust-implemented object.  Clone the handle and return it
+            return rustImpl.uniffiCloneHandle()
+         } else {
+            // Swift object, generate a new vtable handle and return that.
+            return handleMap.insert(obj: value)
+         }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceMediaListener {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: VoiceMediaListener, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
     }
 }
 
@@ -4029,164 +4422,238 @@ public struct FfiConverterTypeAuthUser: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthUser_lift(_ buf: RustBuffer) throws -> AuthUser {
-    return try FfiConverterTypeAuthUser.lift(buf)
+public func FfiConverterTypeVoiceMediaListener_lift(_ handle: UInt64) throws -> VoiceMediaListener {
+    return try FfiConverterTypeVoiceMediaListener.lift(handle)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthUser_lower(_ value: AuthUser) -> RustBuffer {
-    return FfiConverterTypeAuthUser.lower(value)
+public func FfiConverterTypeVoiceMediaListener_lower(_ value: VoiceMediaListener) -> UInt64 {
+    return FfiConverterTypeVoiceMediaListener.lower(value)
 }
 
 
-public struct BoxPrim: Equatable, Hashable {
-    public var x: Float
-    public var y: Float
-    public var w: Float
-    public var h: Float
-    public var radius: Float
-    public var style: BoxStyle
-    public var color: ColorRole
-    public var scroller: UInt32?
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(x: Float, y: Float, w: Float, h: Float, radius: Float, style: BoxStyle, color: ColorRole, scroller: UInt32?) {
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.radius = radius
-        self.style = style
-        self.color = color
-        self.scroller = scroller
-    }
 
-    
 
+
+public protocol VoiceSessionListener: AnyObject, Sendable {
+    
+    func onVoiceState(state: VoiceCallState) 
+    
+    /**
+     * Terminal, exactly once. `None` is an orderly end.
+     */
+    func onVoiceClosed(reason: VoiceEndReason?) 
     
 }
+open class VoiceSessionListenerImpl: VoiceSessionListener, @unchecked Sendable {
+    fileprivate let handle: UInt64
 
-#if compiler(>=6)
-extension BoxPrim: Sendable {}
-#endif
-
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeBoxPrim: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxPrim {
-        return
-            try BoxPrim(
-                x: FfiConverterFloat.read(from: &buf), 
-                y: FfiConverterFloat.read(from: &buf), 
-                w: FfiConverterFloat.read(from: &buf), 
-                h: FfiConverterFloat.read(from: &buf), 
-                radius: FfiConverterFloat.read(from: &buf), 
-                style: FfiConverterTypeBoxStyle.read(from: &buf), 
-                color: FfiConverterTypeColorRole.read(from: &buf), 
-                scroller: FfiConverterOptionUInt32.read(from: &buf)
-        )
+    public struct NoHandle {
+        public init() {}
     }
 
-    public static func write(_ value: BoxPrim, into buf: inout [UInt8]) {
-        FfiConverterFloat.write(value.x, into: &buf)
-        FfiConverterFloat.write(value.y, into: &buf)
-        FfiConverterFloat.write(value.w, into: &buf)
-        FfiConverterFloat.write(value.h, into: &buf)
-        FfiConverterFloat.write(value.radius, into: &buf)
-        FfiConverterTypeBoxStyle.write(value.style, into: &buf)
-        FfiConverterTypeColorRole.write(value.color, into: &buf)
-        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
     }
-}
-
 
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeBoxPrim_lift(_ buf: RustBuffer) throws -> BoxPrim {
-    return try FfiConverterTypeBoxPrim.lift(buf)
-}
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
 
 #if swift(>=5.8)
-@_documentation(visibility: private)
+    @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeBoxPrim_lower(_ value: BoxPrim) -> RustBuffer {
-    return FfiConverterTypeBoxPrim.lower(value)
-}
-
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_zeron_mobile_fn_clone_voicesessionlistener(self.handle, $0) }
+    }
+    // No primary constructor declared for this class.
 
-/**
- * A chat's run configuration. Ids are wire strings.
- */
-public struct ChatConfig: Equatable, Hashable {
-    /**
-     * `claude-code`, `codex`, …
-     */
-    public var harness: String
-    public var model: String?
-    /**
-     * `low` … `ultrathink`.
-     */
-    public var reasoning: String?
-    /**
-     * Model option id → choice id (`contextWindow` → `1m`).
-     */
-    public var modelOptions: [String: String]
-    public var sandbox: SandboxLevel
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
 
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(
-        /**
-         * `claude-code`, `codex`, …
-         */harness: String, model: String?, 
-        /**
-         * `low` … `ultrathink`.
-         */reasoning: String?, 
-        /**
-         * Model option id → choice id (`contextWindow` → `1m`).
-         */modelOptions: [String: String], sandbox: SandboxLevel) {
-        self.harness = harness
-        self.model = model
-        self.reasoning = reasoning
-        self.modelOptions = modelOptions
-        self.sandbox = sandbox
+        try! rustCall { uniffi_zeron_mobile_fn_free_voicesessionlistener(handle, $0) }
     }
 
     
 
     
+open func onVoiceState(state: VoiceCallState)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_voicesessionlistener_on_voice_state(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeVoiceCallState_lower(state),uniffiCallStatus
+    )
+}
+}
+    
+    /**
+     * Terminal, exactly once. `None` is an orderly end.
+     */
+open func onVoiceClosed(reason: VoiceEndReason?)  {try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_method_voicesessionlistener_on_voice_closed(
+            self.uniffiCloneHandle(),
+        FfiConverterOptionTypeVoiceEndReason.lower(reason),uniffiCallStatus
+    )
 }
+}
+    
 
-#if compiler(>=6)
-extension ChatConfig: Sendable {}
-#endif
+    
+}
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public struct FfiConverterTypeChatConfig: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChatConfig {
-        return
-            try ChatConfig(
-                harness: FfiConverterString.read(from: &buf), 
-                model: FfiConverterOptionString.read(from: &buf), 
-                reasoning: FfiConverterOptionString.read(from: &buf), 
-                modelOptions: FfiConverterDictionaryStringString.read(from: &buf), 
-                sandbox: FfiConverterTypeSandboxLevel.read(from: &buf)
-        )
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceVoiceSessionListener {
+
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // Store the vtable directly.
+    static let vtable: UniffiVTableCallbackInterfaceVoiceSessionListener = UniffiVTableCallbackInterfaceVoiceSessionListener(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterTypeVoiceSessionListener.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface VoiceSessionListener: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterTypeVoiceSessionListener.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface VoiceSessionListener: handle missing in uniffiClone")
+            }
+        },
+        onVoiceState: { (
+            uniffiHandle: UInt64,
+            state: RustBuffer,
+            uniffiOutReturn: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> () in
+                guard let uniffiObj = try? FfiConverterTypeVoiceSessionListener.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.onVoiceState(
+                     state: try FfiConverterTypeVoiceCallState_lift(state)
+                )
+            }
+
+            
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        },
+        onVoiceClosed: { (
+            uniffiHandle: UInt64,
+            reason: RustBuffer,
+            uniffiOutReturn: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> () in
+                guard let uniffiObj = try? FfiConverterTypeVoiceSessionListener.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.onVoiceClosed(
+                     reason: try FfiConverterOptionTypeVoiceEndReason.lift(reason)
+                )
+            }
+
+            
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )
+
+    // Rust stores this pointer for future callback invocations, so it must live
+    // for the process lifetime (not just for the init function call).
+    //
+    // `nonisolated(unsafe)` is needed under Swift 6 strict concurrency.
+    // This is safe because the pointee is initialized once during static init
+    // and never mutated by either side of the FFI.  Its fields are C function pointers.
+    nonisolated(unsafe) static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceVoiceSessionListener> = {
+        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceVoiceSessionListener>.allocate(capacity: 1)
+        ptr.initialize(to: vtable)
+        return UnsafePointer(ptr)
+    }()
+}
+
+private func uniffiCallbackInitVoiceSessionListener() {
+    uniffi_zeron_mobile_fn_init_callback_vtable_voicesessionlistener(UniffiCallbackInterfaceVoiceSessionListener.vtablePtr)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeVoiceSessionListener: FfiConverter {
+    fileprivate static let handleMap = UniffiHandleMap<VoiceSessionListener>()
+
+    typealias FfiType = UInt64
+    typealias SwiftType = VoiceSessionListener
+
+    public static func lift(_ handle: UInt64) throws -> VoiceSessionListener {
+        if ((handle & 1) == 0) {
+            // Rust-generated handle, construct a new class that uses the handle to implement the
+            // interface
+            return VoiceSessionListenerImpl(unsafeFromHandle: handle)
+        } else {
+            // Swift-generated handle, get the object from the handle map
+            return try handleMap.remove(handle: handle)
+        }
     }
 
-    public static func write(_ value: ChatConfig, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.harness, into: &buf)
-        FfiConverterOptionString.write(value.model, into: &buf)
-        FfiConverterOptionString.write(value.reasoning, into: &buf)
-        FfiConverterDictionaryStringString.write(value.modelOptions, into: &buf)
-        FfiConverterTypeSandboxLevel.write(value.sandbox, into: &buf)
+    public static func lower(_ value: VoiceSessionListener) -> UInt64 {
+         if let rustImpl = value as? VoiceSessionListenerImpl {
+             // Rust-implemented object.  Clone the handle and return it
+            return rustImpl.uniffiCloneHandle()
+         } else {
+            // Swift object, generate a new vtable handle and return that.
+            return handleMap.insert(obj: value)
+         }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceSessionListener {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: VoiceSessionListener, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
     }
 }
 
@@ -4194,104 +4661,29 @@ public struct FfiConverterTypeChatConfig: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeChatConfig_lift(_ buf: RustBuffer) throws -> ChatConfig {
-    return try FfiConverterTypeChatConfig.lift(buf)
+public func FfiConverterTypeVoiceSessionListener_lift(_ handle: UInt64) throws -> VoiceSessionListener {
+    return try FfiConverterTypeVoiceSessionListener.lift(handle)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeChatConfig_lower(_ value: ChatConfig) -> RustBuffer {
-    return FfiConverterTypeChatConfig.lower(value)
+public func FfiConverterTypeVoiceSessionListener_lower(_ value: VoiceSessionListener) -> UInt64 {
+    return FfiConverterTypeVoiceSessionListener.lower(value)
 }
 
 
-/**
- * Everything the composer and its status strip render.
- */
-public struct ComposerState: Equatable, Hashable {
-    public var chatId: String
-    public var revision: UInt64
-    public var title: String
-    public var host: HostInfo
-    public var live: LiveStatus
-    /**
-     * The shared queue, delivery order.
-     */
-    public var queue: [QueueItem]
-    /**
-     * This device's unadopted sends, oldest first.
-     */
-    public var pendingSends: [PendingSend]
-    /**
-     * Headline state of the oldest pending send.
-     */
-    public var sendState: SendState?
-    /**
-     * A send now would queue rather than deliver promptly.
-     */
-    public var deliveryDegraded: Bool
-    public var room: RoomState
-    /**
-     * Attachment escort progress (0..1).
-     */
-    public var transferProgress: Double?
-    /**
-     * Answer this instead of typing.
-     */
-    public var openInput: InputRequest?
-    /**
-     * Last queue action failure.
-     */
-    public var queueError: String?
-    /**
-     * Scroll-to-own-send target.
-     */
-    public var lastSubmittedMessageId: String?
-    public var contextUsage: ContextUsage?
+
+
+public struct AppshotLabel: Equatable, Hashable {
+    public var appName: String
+    public var windowTitle: String?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(chatId: String, revision: UInt64, title: String, host: HostInfo, live: LiveStatus, 
-        /**
-         * The shared queue, delivery order.
-         */queue: [QueueItem], 
-        /**
-         * This device's unadopted sends, oldest first.
-         */pendingSends: [PendingSend], 
-        /**
-         * Headline state of the oldest pending send.
-         */sendState: SendState?, 
-        /**
-         * A send now would queue rather than deliver promptly.
-         */deliveryDegraded: Bool, room: RoomState, 
-        /**
-         * Attachment escort progress (0..1).
-         */transferProgress: Double?, 
-        /**
-         * Answer this instead of typing.
-         */openInput: InputRequest?, 
-        /**
-         * Last queue action failure.
-         */queueError: String?, 
-        /**
-         * Scroll-to-own-send target.
-         */lastSubmittedMessageId: String?, contextUsage: ContextUsage?) {
-        self.chatId = chatId
-        self.revision = revision
-        self.title = title
-        self.host = host
-        self.live = live
-        self.queue = queue
-        self.pendingSends = pendingSends
-        self.sendState = sendState
-        self.deliveryDegraded = deliveryDegraded
-        self.room = room
-        self.transferProgress = transferProgress
-        self.openInput = openInput
-        self.queueError = queueError
-        self.lastSubmittedMessageId = lastSubmittedMessageId
-        self.contextUsage = contextUsage
+    public init(appName: String, windowTitle: String?) {
+        self.appName = appName
+        self.windowTitle = windowTitle
     }
 
     
@@ -4300,50 +4692,24 @@ public struct ComposerState: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ComposerState: Sendable {}
+extension AppshotLabel: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeComposerState: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ComposerState {
+public struct FfiConverterTypeAppshotLabel: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppshotLabel {
         return
-            try ComposerState(
-                chatId: FfiConverterString.read(from: &buf), 
-                revision: FfiConverterUInt64.read(from: &buf), 
-                title: FfiConverterString.read(from: &buf), 
-                host: FfiConverterTypeHostInfo.read(from: &buf), 
-                live: FfiConverterTypeLiveStatus.read(from: &buf), 
-                queue: FfiConverterSequenceTypeQueueItem.read(from: &buf), 
-                pendingSends: FfiConverterSequenceTypePendingSend.read(from: &buf), 
-                sendState: FfiConverterOptionTypeSendState.read(from: &buf), 
-                deliveryDegraded: FfiConverterBool.read(from: &buf), 
-                room: FfiConverterTypeRoomState.read(from: &buf), 
-                transferProgress: FfiConverterOptionDouble.read(from: &buf), 
-                openInput: FfiConverterOptionTypeInputRequest.read(from: &buf), 
-                queueError: FfiConverterOptionString.read(from: &buf), 
-                lastSubmittedMessageId: FfiConverterOptionString.read(from: &buf), 
-                contextUsage: FfiConverterOptionTypeContextUsage.read(from: &buf)
+            try AppshotLabel(
+                appName: FfiConverterString.read(from: &buf), 
+                windowTitle: FfiConverterOptionString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ComposerState, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.chatId, into: &buf)
-        FfiConverterUInt64.write(value.revision, into: &buf)
-        FfiConverterString.write(value.title, into: &buf)
-        FfiConverterTypeHostInfo.write(value.host, into: &buf)
-        FfiConverterTypeLiveStatus.write(value.live, into: &buf)
-        FfiConverterSequenceTypeQueueItem.write(value.queue, into: &buf)
-        FfiConverterSequenceTypePendingSend.write(value.pendingSends, into: &buf)
-        FfiConverterOptionTypeSendState.write(value.sendState, into: &buf)
-        FfiConverterBool.write(value.deliveryDegraded, into: &buf)
-        FfiConverterTypeRoomState.write(value.room, into: &buf)
-        FfiConverterOptionDouble.write(value.transferProgress, into: &buf)
-        FfiConverterOptionTypeInputRequest.write(value.openInput, into: &buf)
-        FfiConverterOptionString.write(value.queueError, into: &buf)
-        FfiConverterOptionString.write(value.lastSubmittedMessageId, into: &buf)
-        FfiConverterOptionTypeContextUsage.write(value.contextUsage, into: &buf)
+    public static func write(_ value: AppshotLabel, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.appName, into: &buf)
+        FfiConverterOptionString.write(value.windowTitle, into: &buf)
     }
 }
 
@@ -4351,49 +4717,33 @@ public struct FfiConverterTypeComposerState: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeComposerState_lift(_ buf: RustBuffer) throws -> ComposerState {
-    return try FfiConverterTypeComposerState.lift(buf)
+public func FfiConverterTypeAppshotLabel_lift(_ buf: RustBuffer) throws -> AppshotLabel {
+    return try FfiConverterTypeAppshotLabel.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeComposerState_lower(_ value: ComposerState) -> RustBuffer {
-    return FfiConverterTypeComposerState.lower(value)
+public func FfiConverterTypeAppshotLabel_lower(_ value: AppshotLabel) -> RustBuffer {
+    return FfiConverterTypeAppshotLabel.lower(value)
 }
 
 
-public struct Connectivity: Equatable, Hashable {
-    public var state: ConnectivityState
+public struct AuthExchange: Equatable, Hashable {
+    public var user: AuthUser
     /**
-     * Epoch ms of the next scheduled redial (countdown), if any.
-     */
-    public var retryAtMs: Int64?
-    /**
-     * The failure that started the current outage.
-     */
-    public var lastFailure: String?
-    /**
-     * Open chats whose room is graced-degraded.
+     * Unscoped pair: refresh with an organization id before use.
      */
-    public var degradedChats: [String]
+    public var tokens: AuthTokens
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(state: ConnectivityState, 
-        /**
-         * Epoch ms of the next scheduled redial (countdown), if any.
-         */retryAtMs: Int64?, 
-        /**
-         * The failure that started the current outage.
-         */lastFailure: String?, 
+    public init(user: AuthUser, 
         /**
-         * Open chats whose room is graced-degraded.
-         */degradedChats: [String]) {
-        self.state = state
-        self.retryAtMs = retryAtMs
-        self.lastFailure = lastFailure
-        self.degradedChats = degradedChats
+         * Unscoped pair: refresh with an organization id before use.
+         */tokens: AuthTokens) {
+        self.user = user
+        self.tokens = tokens
     }
 
     
@@ -4402,28 +4752,24 @@ public struct Connectivity: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension Connectivity: Sendable {}
+extension AuthExchange: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeConnectivity: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Connectivity {
+public struct FfiConverterTypeAuthExchange: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthExchange {
         return
-            try Connectivity(
-                state: FfiConverterTypeConnectivityState.read(from: &buf), 
-                retryAtMs: FfiConverterOptionInt64.read(from: &buf), 
-                lastFailure: FfiConverterOptionString.read(from: &buf), 
-                degradedChats: FfiConverterSequenceString.read(from: &buf)
+            try AuthExchange(
+                user: FfiConverterTypeAuthUser.read(from: &buf), 
+                tokens: FfiConverterTypeAuthTokens.read(from: &buf)
         )
     }
 
-    public static func write(_ value: Connectivity, into buf: inout [UInt8]) {
-        FfiConverterTypeConnectivityState.write(value.state, into: &buf)
-        FfiConverterOptionInt64.write(value.retryAtMs, into: &buf)
-        FfiConverterOptionString.write(value.lastFailure, into: &buf)
-        FfiConverterSequenceString.write(value.degradedChats, into: &buf)
+    public static func write(_ value: AuthExchange, into buf: inout [UInt8]) {
+        FfiConverterTypeAuthUser.write(value.user, into: &buf)
+        FfiConverterTypeAuthTokens.write(value.tokens, into: &buf)
     }
 }
 
@@ -4431,27 +4777,29 @@ public struct FfiConverterTypeConnectivity: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeConnectivity_lift(_ buf: RustBuffer) throws -> Connectivity {
-    return try FfiConverterTypeConnectivity.lift(buf)
+public func FfiConverterTypeAuthExchange_lift(_ buf: RustBuffer) throws -> AuthExchange {
+    return try FfiConverterTypeAuthExchange.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeConnectivity_lower(_ value: Connectivity) -> RustBuffer {
-    return FfiConverterTypeConnectivity.lower(value)
+public func FfiConverterTypeAuthExchange_lower(_ value: AuthExchange) -> RustBuffer {
+    return FfiConverterTypeAuthExchange.lower(value)
 }
 
 
-public struct ContextUsage: Equatable, Hashable {
-    public var tokens: UInt64?
-    public var window: UInt64?
+public struct AuthOrg: Equatable, Hashable {
+    public var id: String
+    public var organizationId: String
+    public var name: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(tokens: UInt64?, window: UInt64?) {
-        self.tokens = tokens
-        self.window = window
+    public init(id: String, organizationId: String, name: String) {
+        self.id = id
+        self.organizationId = organizationId
+        self.name = name
     }
 
     
@@ -4460,24 +4808,26 @@ public struct ContextUsage: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ContextUsage: Sendable {}
+extension AuthOrg: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeContextUsage: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ContextUsage {
+public struct FfiConverterTypeAuthOrg: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthOrg {
         return
-            try ContextUsage(
-                tokens: FfiConverterOptionUInt64.read(from: &buf), 
-                window: FfiConverterOptionUInt64.read(from: &buf)
+            try AuthOrg(
+                id: FfiConverterString.read(from: &buf), 
+                organizationId: FfiConverterString.read(from: &buf), 
+                name: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ContextUsage, into buf: inout [UInt8]) {
-        FfiConverterOptionUInt64.write(value.tokens, into: &buf)
-        FfiConverterOptionUInt64.write(value.window, into: &buf)
+    public static func write(_ value: AuthOrg, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.organizationId, into: &buf)
+        FfiConverterString.write(value.name, into: &buf)
     }
 }
 
@@ -4485,70 +4835,27 @@ public struct FfiConverterTypeContextUsage: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeContextUsage_lift(_ buf: RustBuffer) throws -> ContextUsage {
-    return try FfiConverterTypeContextUsage.lift(buf)
+public func FfiConverterTypeAuthOrg_lift(_ buf: RustBuffer) throws -> AuthOrg {
+    return try FfiConverterTypeAuthOrg.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeContextUsage_lower(_ value: ContextUsage) -> RustBuffer {
-    return FfiConverterTypeContextUsage.lower(value)
+public func FfiConverterTypeAuthOrg_lower(_ value: AuthOrg) -> RustBuffer {
+    return FfiConverterTypeAuthOrg.lower(value)
 }
 
 
-/**
- * Static per-install configuration.
- */
-public struct CoreConfig: Equatable, Hashable {
-    /**
-     * Edge base URL (`auth_production_edge_url()` for prod).
-     */
-    public var edgeUrl: String
-    /**
-     * Writable directory for registry/doc snapshots and caches, scoped by
-     * the platform to the signed-in identity (sign-out wipes it).
-     */
-    public var dataDir: String
-    /**
-     * Stable device id (`ios-xxxxxxxx`), stamped on every command/queue row.
-     */
-    public var deviceId: String
-    /**
-     * Human name for presence/attribution ("Wing's iPhone").
-     */
-    public var deviceName: String
-    /**
-     * `ios` / `android`.
-     */
-    public var platform: String
-    public var appVersion: String
+public struct AuthTokens: Equatable, Hashable {
+    public var accessToken: String
+    public var refreshToken: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(
-        /**
-         * Edge base URL (`auth_production_edge_url()` for prod).
-         */edgeUrl: String, 
-        /**
-         * Writable directory for registry/doc snapshots and caches, scoped by
-         * the platform to the signed-in identity (sign-out wipes it).
-         */dataDir: String, 
-        /**
-         * Stable device id (`ios-xxxxxxxx`), stamped on every command/queue row.
-         */deviceId: String, 
-        /**
-         * Human name for presence/attribution ("Wing's iPhone").
-         */deviceName: String, 
-        /**
-         * `ios` / `android`.
-         */platform: String, appVersion: String) {
-        self.edgeUrl = edgeUrl
-        self.dataDir = dataDir
-        self.deviceId = deviceId
-        self.deviceName = deviceName
-        self.platform = platform
-        self.appVersion = appVersion
+    public init(accessToken: String, refreshToken: String) {
+        self.accessToken = accessToken
+        self.refreshToken = refreshToken
     }
 
     
@@ -4557,32 +4864,24 @@ public struct CoreConfig: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension CoreConfig: Sendable {}
+extension AuthTokens: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeCoreConfig: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CoreConfig {
+public struct FfiConverterTypeAuthTokens: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthTokens {
         return
-            try CoreConfig(
-                edgeUrl: FfiConverterString.read(from: &buf), 
-                dataDir: FfiConverterString.read(from: &buf), 
-                deviceId: FfiConverterString.read(from: &buf), 
-                deviceName: FfiConverterString.read(from: &buf), 
-                platform: FfiConverterString.read(from: &buf), 
-                appVersion: FfiConverterString.read(from: &buf)
+            try AuthTokens(
+                accessToken: FfiConverterString.read(from: &buf), 
+                refreshToken: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: CoreConfig, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.edgeUrl, into: &buf)
-        FfiConverterString.write(value.dataDir, into: &buf)
-        FfiConverterString.write(value.deviceId, into: &buf)
-        FfiConverterString.write(value.deviceName, into: &buf)
-        FfiConverterString.write(value.platform, into: &buf)
-        FfiConverterString.write(value.appVersion, into: &buf)
+    public static func write(_ value: AuthTokens, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.accessToken, into: &buf)
+        FfiConverterString.write(value.refreshToken, into: &buf)
     }
 }
 
@@ -4590,34 +4889,31 @@ public struct FfiConverterTypeCoreConfig: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeCoreConfig_lift(_ buf: RustBuffer) throws -> CoreConfig {
-    return try FfiConverterTypeCoreConfig.lift(buf)
+public func FfiConverterTypeAuthTokens_lift(_ buf: RustBuffer) throws -> AuthTokens {
+    return try FfiConverterTypeAuthTokens.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeCoreConfig_lower(_ value: CoreConfig) -> RustBuffer {
-    return FfiConverterTypeCoreConfig.lower(value)
+public func FfiConverterTypeAuthTokens_lower(_ value: AuthTokens) -> RustBuffer {
+    return FfiConverterTypeAuthTokens.lower(value)
 }
 
 
-/**
- * A debug/demo transcript entry (markdown text), for fixtures and benches.
- */
-public struct DebugEntry: Equatable, Hashable {
+public struct AuthUser: Equatable, Hashable {
     public var id: String
-    public var user: Bool
-    public var text: String
-    public var streaming: Bool
+    public var email: String?
+    public var firstName: String?
+    public var lastName: String?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, user: Bool, text: String, streaming: Bool) {
+    public init(id: String, email: String?, firstName: String?, lastName: String?) {
         self.id = id
-        self.user = user
-        self.text = text
-        self.streaming = streaming
+        self.email = email
+        self.firstName = firstName
+        self.lastName = lastName
     }
 
     
@@ -4626,28 +4922,28 @@ public struct DebugEntry: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension DebugEntry: Sendable {}
+extension AuthUser: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeDebugEntry: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DebugEntry {
+public struct FfiConverterTypeAuthUser: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthUser {
         return
-            try DebugEntry(
+            try AuthUser(
                 id: FfiConverterString.read(from: &buf), 
-                user: FfiConverterBool.read(from: &buf), 
-                text: FfiConverterString.read(from: &buf), 
-                streaming: FfiConverterBool.read(from: &buf)
+                email: FfiConverterOptionString.read(from: &buf), 
+                firstName: FfiConverterOptionString.read(from: &buf), 
+                lastName: FfiConverterOptionString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: DebugEntry, into buf: inout [UInt8]) {
+    public static func write(_ value: AuthUser, into buf: inout [UInt8]) {
         FfiConverterString.write(value.id, into: &buf)
-        FfiConverterBool.write(value.user, into: &buf)
-        FfiConverterString.write(value.text, into: &buf)
-        FfiConverterBool.write(value.streaming, into: &buf)
+        FfiConverterOptionString.write(value.email, into: &buf)
+        FfiConverterOptionString.write(value.firstName, into: &buf)
+        FfiConverterOptionString.write(value.lastName, into: &buf)
     }
 }
 
@@ -4655,43 +4951,39 @@ public struct FfiConverterTypeDebugEntry: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDebugEntry_lift(_ buf: RustBuffer) throws -> DebugEntry {
-    return try FfiConverterTypeDebugEntry.lift(buf)
+public func FfiConverterTypeAuthUser_lift(_ buf: RustBuffer) throws -> AuthUser {
+    return try FfiConverterTypeAuthUser.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDebugEntry_lower(_ value: DebugEntry) -> RustBuffer {
-    return FfiConverterTypeDebugEntry.lower(value)
+public func FfiConverterTypeAuthUser_lower(_ value: AuthUser) -> RustBuffer {
+    return FfiConverterTypeAuthUser.lower(value)
 }
 
 
-public struct DemoOptions: Equatable, Hashable {
-    public var fixture: DemoFixture
-    /**
-     * Size of the flagship chat's (`chat-veil`) transcript.
-     */
-    public var transcriptScale: TranscriptScale
-    public var streamSpeed: StreamSpeed
-    /**
-     * Repeat the scripted reply 12× (long streaming stress).
-     */
-    public var longReply: Bool
-
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(fixture: DemoFixture, 
-        /**
-         * Size of the flagship chat's (`chat-veil`) transcript.
-         */transcriptScale: TranscriptScale, streamSpeed: StreamSpeed, 
-        /**
-         * Repeat the scripted reply 12× (long streaming stress).
-         */longReply: Bool) {
-        self.fixture = fixture
-        self.transcriptScale = transcriptScale
-        self.streamSpeed = streamSpeed
-        self.longReply = longReply
+public struct BoxPrim: Equatable, Hashable {
+    public var x: Float
+    public var y: Float
+    public var w: Float
+    public var h: Float
+    public var radius: Float
+    public var style: BoxStyle
+    public var color: ColorRole
+    public var scroller: UInt32?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(x: Float, y: Float, w: Float, h: Float, radius: Float, style: BoxStyle, color: ColorRole, scroller: UInt32?) {
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.radius = radius
+        self.style = style
+        self.color = color
+        self.scroller = scroller
     }
 
     
@@ -4700,28 +4992,36 @@ public struct DemoOptions: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension DemoOptions: Sendable {}
+extension BoxPrim: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeDemoOptions: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DemoOptions {
+public struct FfiConverterTypeBoxPrim: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxPrim {
         return
-            try DemoOptions(
-                fixture: FfiConverterTypeDemoFixture.read(from: &buf), 
-                transcriptScale: FfiConverterTypeTranscriptScale.read(from: &buf), 
-                streamSpeed: FfiConverterTypeStreamSpeed.read(from: &buf), 
-                longReply: FfiConverterBool.read(from: &buf)
+            try BoxPrim(
+                x: FfiConverterFloat.read(from: &buf), 
+                y: FfiConverterFloat.read(from: &buf), 
+                w: FfiConverterFloat.read(from: &buf), 
+                h: FfiConverterFloat.read(from: &buf), 
+                radius: FfiConverterFloat.read(from: &buf), 
+                style: FfiConverterTypeBoxStyle.read(from: &buf), 
+                color: FfiConverterTypeColorRole.read(from: &buf), 
+                scroller: FfiConverterOptionUInt32.read(from: &buf)
         )
     }
 
-    public static func write(_ value: DemoOptions, into buf: inout [UInt8]) {
-        FfiConverterTypeDemoFixture.write(value.fixture, into: &buf)
-        FfiConverterTypeTranscriptScale.write(value.transcriptScale, into: &buf)
-        FfiConverterTypeStreamSpeed.write(value.streamSpeed, into: &buf)
-        FfiConverterBool.write(value.longReply, into: &buf)
+    public static func write(_ value: BoxPrim, into buf: inout [UInt8]) {
+        FfiConverterFloat.write(value.x, into: &buf)
+        FfiConverterFloat.write(value.y, into: &buf)
+        FfiConverterFloat.write(value.w, into: &buf)
+        FfiConverterFloat.write(value.h, into: &buf)
+        FfiConverterFloat.write(value.radius, into: &buf)
+        FfiConverterTypeBoxStyle.write(value.style, into: &buf)
+        FfiConverterTypeColorRole.write(value.color, into: &buf)
+        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
     }
 }
 
@@ -4729,49 +5029,51 @@ public struct FfiConverterTypeDemoOptions: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDemoOptions_lift(_ buf: RustBuffer) throws -> DemoOptions {
-    return try FfiConverterTypeDemoOptions.lift(buf)
+public func FfiConverterTypeBoxPrim_lift(_ buf: RustBuffer) throws -> BoxPrim {
+    return try FfiConverterTypeBoxPrim.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDemoOptions_lower(_ value: DemoOptions) -> RustBuffer {
-    return FfiConverterTypeDemoOptions.lower(value)
+public func FfiConverterTypeBoxPrim_lower(_ value: BoxPrim) -> RustBuffer {
+    return FfiConverterTypeBoxPrim.lower(value)
 }
 
 
-public struct DeviceView: Equatable, Hashable {
-    public var id: String
-    public var name: String
-    public var platform: String
-    public var online: Bool
-    public var lastSeenMs: Int64?
-    public var version: String?
-    public var capabilities: [String]
+public struct CaptionFrame: Equatable, Hashable {
     /**
-     * Can run sessions (desktop/server engines — not phones).
+     * The tail of the utterance to show (ellipsized in front when long).
      */
-    public var isExecutionHost: Bool
-    public var isSelf: Bool
-    public var sessionCount: UInt32
+    public var text: String
+    public var spans: [CaptionSpan]
+    /**
+     * The previous utterance while it fades out, and its opacity.
+     */
+    public var previous: String?
+    public var previousAlpha: Float
+    /**
+     * Something is still fading: ask for the next frame.
+     */
+    public var animating: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, name: String, platform: String, online: Bool, lastSeenMs: Int64?, version: String?, capabilities: [String], 
+    public init(
         /**
-         * Can run sessions (desktop/server engines — not phones).
-         */isExecutionHost: Bool, isSelf: Bool, sessionCount: UInt32) {
-        self.id = id
-        self.name = name
-        self.platform = platform
-        self.online = online
-        self.lastSeenMs = lastSeenMs
-        self.version = version
-        self.capabilities = capabilities
-        self.isExecutionHost = isExecutionHost
-        self.isSelf = isSelf
-        self.sessionCount = sessionCount
+         * The tail of the utterance to show (ellipsized in front when long).
+         */text: String, spans: [CaptionSpan], 
+        /**
+         * The previous utterance while it fades out, and its opacity.
+         */previous: String?, previousAlpha: Float, 
+        /**
+         * Something is still fading: ask for the next frame.
+         */animating: Bool) {
+        self.text = text
+        self.spans = spans
+        self.previous = previous
+        self.previousAlpha = previousAlpha
+        self.animating = animating
     }
 
     
@@ -4780,40 +5082,30 @@ public struct DeviceView: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension DeviceView: Sendable {}
+extension CaptionFrame: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeDeviceView: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DeviceView {
+public struct FfiConverterTypeCaptionFrame: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CaptionFrame {
         return
-            try DeviceView(
-                id: FfiConverterString.read(from: &buf), 
-                name: FfiConverterString.read(from: &buf), 
-                platform: FfiConverterString.read(from: &buf), 
-                online: FfiConverterBool.read(from: &buf), 
-                lastSeenMs: FfiConverterOptionInt64.read(from: &buf), 
-                version: FfiConverterOptionString.read(from: &buf), 
-                capabilities: FfiConverterSequenceString.read(from: &buf), 
-                isExecutionHost: FfiConverterBool.read(from: &buf), 
-                isSelf: FfiConverterBool.read(from: &buf), 
-                sessionCount: FfiConverterUInt32.read(from: &buf)
+            try CaptionFrame(
+                text: FfiConverterString.read(from: &buf), 
+                spans: FfiConverterSequenceTypeCaptionSpan.read(from: &buf), 
+                previous: FfiConverterOptionString.read(from: &buf), 
+                previousAlpha: FfiConverterFloat.read(from: &buf), 
+                animating: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: DeviceView, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterString.write(value.platform, into: &buf)
-        FfiConverterBool.write(value.online, into: &buf)
-        FfiConverterOptionInt64.write(value.lastSeenMs, into: &buf)
-        FfiConverterOptionString.write(value.version, into: &buf)
-        FfiConverterSequenceString.write(value.capabilities, into: &buf)
-        FfiConverterBool.write(value.isExecutionHost, into: &buf)
-        FfiConverterBool.write(value.isSelf, into: &buf)
-        FfiConverterUInt32.write(value.sessionCount, into: &buf)
+    public static func write(_ value: CaptionFrame, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterSequenceTypeCaptionSpan.write(value.spans, into: &buf)
+        FfiConverterOptionString.write(value.previous, into: &buf)
+        FfiConverterFloat.write(value.previousAlpha, into: &buf)
+        FfiConverterBool.write(value.animating, into: &buf)
     }
 }
 
@@ -4821,27 +5113,32 @@ public struct FfiConverterTypeDeviceView: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDeviceView_lift(_ buf: RustBuffer) throws -> DeviceView {
-    return try FfiConverterTypeDeviceView.lift(buf)
+public func FfiConverterTypeCaptionFrame_lift(_ buf: RustBuffer) throws -> CaptionFrame {
+    return try FfiConverterTypeCaptionFrame.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDeviceView_lower(_ value: DeviceView) -> RustBuffer {
-    return FfiConverterTypeDeviceView.lower(value)
+public func FfiConverterTypeCaptionFrame_lower(_ value: CaptionFrame) -> RustBuffer {
+    return FfiConverterTypeCaptionFrame.lower(value)
 }
 
 
-public struct FaceData: Equatable, Hashable {
-    public var role: FaceRole
-    public var bytes: Data
+/**
+ * A veiled UTF-16 range of the caption and its opacity (0..1).
+ */
+public struct CaptionSpan: Equatable, Hashable {
+    public var start: UInt32
+    public var end: UInt32
+    public var alpha: Float
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(role: FaceRole, bytes: Data) {
-        self.role = role
-        self.bytes = bytes
+    public init(start: UInt32, end: UInt32, alpha: Float) {
+        self.start = start
+        self.end = end
+        self.alpha = alpha
     }
 
     
@@ -4850,24 +5147,26 @@ public struct FaceData: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FaceData: Sendable {}
+extension CaptionSpan: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFaceData: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FaceData {
+public struct FfiConverterTypeCaptionSpan: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CaptionSpan {
         return
-            try FaceData(
-                role: FfiConverterTypeFaceRole.read(from: &buf), 
-                bytes: FfiConverterData.read(from: &buf)
+            try CaptionSpan(
+                start: FfiConverterUInt32.read(from: &buf), 
+                end: FfiConverterUInt32.read(from: &buf), 
+                alpha: FfiConverterFloat.read(from: &buf)
         )
     }
 
-    public static func write(_ value: FaceData, into buf: inout [UInt8]) {
-        FfiConverterTypeFaceRole.write(value.role, into: &buf)
-        FfiConverterData.write(value.bytes, into: &buf)
+    public static func write(_ value: CaptionSpan, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.start, into: &buf)
+        FfiConverterUInt32.write(value.end, into: &buf)
+        FfiConverterFloat.write(value.alpha, into: &buf)
     }
 }
 
@@ -4875,40 +5174,54 @@ public struct FfiConverterTypeFaceData: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFaceData_lift(_ buf: RustBuffer) throws -> FaceData {
-    return try FfiConverterTypeFaceData.lift(buf)
+public func FfiConverterTypeCaptionSpan_lift(_ buf: RustBuffer) throws -> CaptionSpan {
+    return try FfiConverterTypeCaptionSpan.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFaceData_lower(_ value: FaceData) -> RustBuffer {
-    return FfiConverterTypeFaceData.lower(value)
+public func FfiConverterTypeCaptionSpan_lower(_ value: CaptionSpan) -> RustBuffer {
+    return FfiConverterTypeCaptionSpan.lower(value)
 }
 
 
 /**
- * An overflow fade: runs whose baseline falls inside the rect's vertical
- * band are painted through an alpha ramp — the text itself fades, so it
- * works over any background.
+ * A chat's run configuration. Ids are wire strings.
  */
-public struct Fade: Equatable, Hashable {
-    public var x: Float
-    public var y: Float
-    public var w: Float
-    public var h: Float
-    public var edge: FadeEdge
-    public var scroller: UInt32?
+public struct ChatConfig: Equatable, Hashable {
+    /**
+     * `claude-code`, `codex`, …
+     */
+    public var harness: String
+    public var model: String?
+    /**
+     * `low` … `ultrathink`.
+     */
+    public var reasoning: String?
+    /**
+     * Model option id → choice id (`contextWindow` → `1m`).
+     */
+    public var modelOptions: [String: String]
+    public var sandbox: SandboxLevel
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(x: Float, y: Float, w: Float, h: Float, edge: FadeEdge, scroller: UInt32?) {
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.edge = edge
-        self.scroller = scroller
+    public init(
+        /**
+         * `claude-code`, `codex`, …
+         */harness: String, model: String?, 
+        /**
+         * `low` … `ultrathink`.
+         */reasoning: String?, 
+        /**
+         * Model option id → choice id (`contextWindow` → `1m`).
+         */modelOptions: [String: String], sandbox: SandboxLevel) {
+        self.harness = harness
+        self.model = model
+        self.reasoning = reasoning
+        self.modelOptions = modelOptions
+        self.sandbox = sandbox
     }
 
     
@@ -4917,32 +5230,30 @@ public struct Fade: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension Fade: Sendable {}
+extension ChatConfig: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFade: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Fade {
+public struct FfiConverterTypeChatConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChatConfig {
         return
-            try Fade(
-                x: FfiConverterFloat.read(from: &buf), 
-                y: FfiConverterFloat.read(from: &buf), 
-                w: FfiConverterFloat.read(from: &buf), 
-                h: FfiConverterFloat.read(from: &buf), 
-                edge: FfiConverterTypeFadeEdge.read(from: &buf), 
-                scroller: FfiConverterOptionUInt32.read(from: &buf)
+            try ChatConfig(
+                harness: FfiConverterString.read(from: &buf), 
+                model: FfiConverterOptionString.read(from: &buf), 
+                reasoning: FfiConverterOptionString.read(from: &buf), 
+                modelOptions: FfiConverterDictionaryStringString.read(from: &buf), 
+                sandbox: FfiConverterTypeSandboxLevel.read(from: &buf)
         )
     }
 
-    public static func write(_ value: Fade, into buf: inout [UInt8]) {
-        FfiConverterFloat.write(value.x, into: &buf)
-        FfiConverterFloat.write(value.y, into: &buf)
-        FfiConverterFloat.write(value.w, into: &buf)
-        FfiConverterFloat.write(value.h, into: &buf)
-        FfiConverterTypeFadeEdge.write(value.edge, into: &buf)
-        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
+    public static func write(_ value: ChatConfig, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.harness, into: &buf)
+        FfiConverterOptionString.write(value.model, into: &buf)
+        FfiConverterOptionString.write(value.reasoning, into: &buf)
+        FfiConverterDictionaryStringString.write(value.modelOptions, into: &buf)
+        FfiConverterTypeSandboxLevel.write(value.sandbox, into: &buf)
     }
 }
 
@@ -4950,30 +5261,104 @@ public struct FfiConverterTypeFade: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFade_lift(_ buf: RustBuffer) throws -> Fade {
-    return try FfiConverterTypeFade.lift(buf)
+public func FfiConverterTypeChatConfig_lift(_ buf: RustBuffer) throws -> ChatConfig {
+    return try FfiConverterTypeChatConfig.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFade_lower(_ value: Fade) -> RustBuffer {
-    return FfiConverterTypeFade.lower(value)
+public func FfiConverterTypeChatConfig_lower(_ value: ChatConfig) -> RustBuffer {
+    return FfiConverterTypeChatConfig.lower(value)
 }
 
 
 /**
- * A workspace file or folder for `@` mentions.
+ * Everything the composer and its status strip render.
  */
-public struct FileMatch: Equatable, Hashable {
-    public var path: String
-    public var isDir: Bool
-
+public struct ComposerState: Equatable, Hashable {
+    public var chatId: String
+    public var revision: UInt64
+    public var title: String
+    public var host: HostInfo
+    public var live: LiveStatus
+    /**
+     * The shared queue, delivery order.
+     */
+    public var queue: [QueueItem]
+    /**
+     * This device's unadopted sends, oldest first.
+     */
+    public var pendingSends: [PendingSend]
+    /**
+     * Headline state of the oldest pending send.
+     */
+    public var sendState: SendState?
+    /**
+     * A send now would queue rather than deliver promptly.
+     */
+    public var deliveryDegraded: Bool
+    public var room: RoomState
+    /**
+     * Attachment escort progress (0..1).
+     */
+    public var transferProgress: Double?
+    /**
+     * Answer this instead of typing.
+     */
+    public var openInput: InputRequest?
+    /**
+     * Last queue action failure.
+     */
+    public var queueError: String?
+    /**
+     * Scroll-to-own-send target.
+     */
+    public var lastSubmittedMessageId: String?
+    public var contextUsage: ContextUsage?
+
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(path: String, isDir: Bool) {
-        self.path = path
-        self.isDir = isDir
+    public init(chatId: String, revision: UInt64, title: String, host: HostInfo, live: LiveStatus, 
+        /**
+         * The shared queue, delivery order.
+         */queue: [QueueItem], 
+        /**
+         * This device's unadopted sends, oldest first.
+         */pendingSends: [PendingSend], 
+        /**
+         * Headline state of the oldest pending send.
+         */sendState: SendState?, 
+        /**
+         * A send now would queue rather than deliver promptly.
+         */deliveryDegraded: Bool, room: RoomState, 
+        /**
+         * Attachment escort progress (0..1).
+         */transferProgress: Double?, 
+        /**
+         * Answer this instead of typing.
+         */openInput: InputRequest?, 
+        /**
+         * Last queue action failure.
+         */queueError: String?, 
+        /**
+         * Scroll-to-own-send target.
+         */lastSubmittedMessageId: String?, contextUsage: ContextUsage?) {
+        self.chatId = chatId
+        self.revision = revision
+        self.title = title
+        self.host = host
+        self.live = live
+        self.queue = queue
+        self.pendingSends = pendingSends
+        self.sendState = sendState
+        self.deliveryDegraded = deliveryDegraded
+        self.room = room
+        self.transferProgress = transferProgress
+        self.openInput = openInput
+        self.queueError = queueError
+        self.lastSubmittedMessageId = lastSubmittedMessageId
+        self.contextUsage = contextUsage
     }
 
     
@@ -4982,24 +5367,50 @@ public struct FileMatch: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FileMatch: Sendable {}
+extension ComposerState: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFileMatch: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FileMatch {
+public struct FfiConverterTypeComposerState: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ComposerState {
         return
-            try FileMatch(
-                path: FfiConverterString.read(from: &buf), 
-                isDir: FfiConverterBool.read(from: &buf)
+            try ComposerState(
+                chatId: FfiConverterString.read(from: &buf), 
+                revision: FfiConverterUInt64.read(from: &buf), 
+                title: FfiConverterString.read(from: &buf), 
+                host: FfiConverterTypeHostInfo.read(from: &buf), 
+                live: FfiConverterTypeLiveStatus.read(from: &buf), 
+                queue: FfiConverterSequenceTypeQueueItem.read(from: &buf), 
+                pendingSends: FfiConverterSequenceTypePendingSend.read(from: &buf), 
+                sendState: FfiConverterOptionTypeSendState.read(from: &buf), 
+                deliveryDegraded: FfiConverterBool.read(from: &buf), 
+                room: FfiConverterTypeRoomState.read(from: &buf), 
+                transferProgress: FfiConverterOptionDouble.read(from: &buf), 
+                openInput: FfiConverterOptionTypeInputRequest.read(from: &buf), 
+                queueError: FfiConverterOptionString.read(from: &buf), 
+                lastSubmittedMessageId: FfiConverterOptionString.read(from: &buf), 
+                contextUsage: FfiConverterOptionTypeContextUsage.read(from: &buf)
         )
     }
 
-    public static func write(_ value: FileMatch, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.path, into: &buf)
-        FfiConverterBool.write(value.isDir, into: &buf)
+    public static func write(_ value: ComposerState, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.chatId, into: &buf)
+        FfiConverterUInt64.write(value.revision, into: &buf)
+        FfiConverterString.write(value.title, into: &buf)
+        FfiConverterTypeHostInfo.write(value.host, into: &buf)
+        FfiConverterTypeLiveStatus.write(value.live, into: &buf)
+        FfiConverterSequenceTypeQueueItem.write(value.queue, into: &buf)
+        FfiConverterSequenceTypePendingSend.write(value.pendingSends, into: &buf)
+        FfiConverterOptionTypeSendState.write(value.sendState, into: &buf)
+        FfiConverterBool.write(value.deliveryDegraded, into: &buf)
+        FfiConverterTypeRoomState.write(value.room, into: &buf)
+        FfiConverterOptionDouble.write(value.transferProgress, into: &buf)
+        FfiConverterOptionTypeInputRequest.write(value.openInput, into: &buf)
+        FfiConverterOptionString.write(value.queueError, into: &buf)
+        FfiConverterOptionString.write(value.lastSubmittedMessageId, into: &buf)
+        FfiConverterOptionTypeContextUsage.write(value.contextUsage, into: &buf)
     }
 }
 
@@ -5007,29 +5418,49 @@ public struct FfiConverterTypeFileMatch: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFileMatch_lift(_ buf: RustBuffer) throws -> FileMatch {
-    return try FfiConverterTypeFileMatch.lift(buf)
+public func FfiConverterTypeComposerState_lift(_ buf: RustBuffer) throws -> ComposerState {
+    return try FfiConverterTypeComposerState.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFileMatch_lower(_ value: FileMatch) -> RustBuffer {
-    return FfiConverterTypeFileMatch.lower(value)
+public func FfiConverterTypeComposerState_lower(_ value: ComposerState) -> RustBuffer {
+    return FfiConverterTypeComposerState.lower(value)
 }
 
 
-public struct FolderEntry: Equatable, Hashable {
-    public var name: String
-    public var isDir: Bool
-    public var isRepo: Bool
+public struct Connectivity: Equatable, Hashable {
+    public var state: ConnectivityState
+    /**
+     * Epoch ms of the next scheduled redial (countdown), if any.
+     */
+    public var retryAtMs: Int64?
+    /**
+     * The failure that started the current outage.
+     */
+    public var lastFailure: String?
+    /**
+     * Open chats whose room is graced-degraded.
+     */
+    public var degradedChats: [String]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(name: String, isDir: Bool, isRepo: Bool) {
-        self.name = name
-        self.isDir = isDir
-        self.isRepo = isRepo
+    public init(state: ConnectivityState, 
+        /**
+         * Epoch ms of the next scheduled redial (countdown), if any.
+         */retryAtMs: Int64?, 
+        /**
+         * The failure that started the current outage.
+         */lastFailure: String?, 
+        /**
+         * Open chats whose room is graced-degraded.
+         */degradedChats: [String]) {
+        self.state = state
+        self.retryAtMs = retryAtMs
+        self.lastFailure = lastFailure
+        self.degradedChats = degradedChats
     }
 
     
@@ -5038,26 +5469,28 @@ public struct FolderEntry: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FolderEntry: Sendable {}
+extension Connectivity: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFolderEntry: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FolderEntry {
+public struct FfiConverterTypeConnectivity: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Connectivity {
         return
-            try FolderEntry(
-                name: FfiConverterString.read(from: &buf), 
-                isDir: FfiConverterBool.read(from: &buf), 
-                isRepo: FfiConverterBool.read(from: &buf)
+            try Connectivity(
+                state: FfiConverterTypeConnectivityState.read(from: &buf), 
+                retryAtMs: FfiConverterOptionInt64.read(from: &buf), 
+                lastFailure: FfiConverterOptionString.read(from: &buf), 
+                degradedChats: FfiConverterSequenceString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: FolderEntry, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterBool.write(value.isDir, into: &buf)
-        FfiConverterBool.write(value.isRepo, into: &buf)
+    public static func write(_ value: Connectivity, into buf: inout [UInt8]) {
+        FfiConverterTypeConnectivityState.write(value.state, into: &buf)
+        FfiConverterOptionInt64.write(value.retryAtMs, into: &buf)
+        FfiConverterOptionString.write(value.lastFailure, into: &buf)
+        FfiConverterSequenceString.write(value.degradedChats, into: &buf)
     }
 }
 
@@ -5065,29 +5498,27 @@ public struct FfiConverterTypeFolderEntry: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFolderEntry_lift(_ buf: RustBuffer) throws -> FolderEntry {
-    return try FfiConverterTypeFolderEntry.lift(buf)
+public func FfiConverterTypeConnectivity_lift(_ buf: RustBuffer) throws -> Connectivity {
+    return try FfiConverterTypeConnectivity.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFolderEntry_lower(_ value: FolderEntry) -> RustBuffer {
-    return FfiConverterTypeFolderEntry.lower(value)
+public func FfiConverterTypeConnectivity_lower(_ value: Connectivity) -> RustBuffer {
+    return FfiConverterTypeConnectivity.lower(value)
 }
 
 
-public struct FolderListing: Equatable, Hashable {
-    public var path: String
-    public var entries: [FolderEntry]
-    public var truncated: Bool
+public struct ContextUsage: Equatable, Hashable {
+    public var tokens: UInt64?
+    public var window: UInt64?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(path: String, entries: [FolderEntry], truncated: Bool) {
-        self.path = path
-        self.entries = entries
-        self.truncated = truncated
+    public init(tokens: UInt64?, window: UInt64?) {
+        self.tokens = tokens
+        self.window = window
     }
 
     
@@ -5096,26 +5527,24 @@ public struct FolderListing: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FolderListing: Sendable {}
+extension ContextUsage: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFolderListing: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FolderListing {
+public struct FfiConverterTypeContextUsage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ContextUsage {
         return
-            try FolderListing(
-                path: FfiConverterString.read(from: &buf), 
-                entries: FfiConverterSequenceTypeFolderEntry.read(from: &buf), 
-                truncated: FfiConverterBool.read(from: &buf)
+            try ContextUsage(
+                tokens: FfiConverterOptionUInt64.read(from: &buf), 
+                window: FfiConverterOptionUInt64.read(from: &buf)
         )
     }
 
-    public static func write(_ value: FolderListing, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.path, into: &buf)
-        FfiConverterSequenceTypeFolderEntry.write(value.entries, into: &buf)
-        FfiConverterBool.write(value.truncated, into: &buf)
+    public static func write(_ value: ContextUsage, into buf: inout [UInt8]) {
+        FfiConverterOptionUInt64.write(value.tokens, into: &buf)
+        FfiConverterOptionUInt64.write(value.window, into: &buf)
     }
 }
 
@@ -5123,50 +5552,70 @@ public struct FfiConverterTypeFolderListing: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFolderListing_lift(_ buf: RustBuffer) throws -> FolderListing {
-    return try FfiConverterTypeFolderListing.lift(buf)
+public func FfiConverterTypeContextUsage_lift(_ buf: RustBuffer) throws -> ContextUsage {
+    return try FfiConverterTypeContextUsage.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFolderListing_lower(_ value: FolderListing) -> RustBuffer {
-    return FfiConverterTypeFolderListing.lower(value)
+public func FfiConverterTypeContextUsage_lower(_ value: ContextUsage) -> RustBuffer {
+    return FfiConverterTypeContextUsage.lower(value)
 }
 
 
 /**
- * The Threads page — the desktop sidebar order.
+ * Static per-install configuration.
  */
-public struct FrontPage: Equatable, Hashable {
+public struct CoreConfig: Equatable, Hashable {
     /**
-     * Shared manual pin order.
+     * Edge base URL (`auth_production_edge_url()` for prod).
      */
-    public var pinned: [SessionRow]
+    public var edgeUrl: String
     /**
-     * User sections ("folders"), each in recency order.
-     */
-    public var sections: [SectionView]
+     * Writable directory for registry/doc snapshots and caches, scoped by
+     * the platform to the signed-in identity (sign-out wipes it).
+     */
+    public var dataDir: String
     /**
-     * Everything else, by recency.
+     * Stable device id (`ios-xxxxxxxx`), stamped on every command/queue row.
      */
-    public var recent: [SessionRow]
+    public var deviceId: String
+    /**
+     * Human name for presence/attribution ("Wing's iPhone").
+     */
+    public var deviceName: String
+    /**
+     * `ios` / `android`.
+     */
+    public var platform: String
+    public var appVersion: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(
         /**
-         * Shared manual pin order.
-         */pinned: [SessionRow], 
+         * Edge base URL (`auth_production_edge_url()` for prod).
+         */edgeUrl: String, 
         /**
-         * User sections ("folders"), each in recency order.
-         */sections: [SectionView], 
+         * Writable directory for registry/doc snapshots and caches, scoped by
+         * the platform to the signed-in identity (sign-out wipes it).
+         */dataDir: String, 
         /**
-         * Everything else, by recency.
-         */recent: [SessionRow]) {
-        self.pinned = pinned
-        self.sections = sections
-        self.recent = recent
+         * Stable device id (`ios-xxxxxxxx`), stamped on every command/queue row.
+         */deviceId: String, 
+        /**
+         * Human name for presence/attribution ("Wing's iPhone").
+         */deviceName: String, 
+        /**
+         * `ios` / `android`.
+         */platform: String, appVersion: String) {
+        self.edgeUrl = edgeUrl
+        self.dataDir = dataDir
+        self.deviceId = deviceId
+        self.deviceName = deviceName
+        self.platform = platform
+        self.appVersion = appVersion
     }
 
     
@@ -5175,26 +5624,32 @@ public struct FrontPage: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FrontPage: Sendable {}
+extension CoreConfig: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFrontPage: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FrontPage {
+public struct FfiConverterTypeCoreConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CoreConfig {
         return
-            try FrontPage(
-                pinned: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
-                sections: FfiConverterSequenceTypeSectionView.read(from: &buf), 
-                recent: FfiConverterSequenceTypeSessionRow.read(from: &buf)
+            try CoreConfig(
+                edgeUrl: FfiConverterString.read(from: &buf), 
+                dataDir: FfiConverterString.read(from: &buf), 
+                deviceId: FfiConverterString.read(from: &buf), 
+                deviceName: FfiConverterString.read(from: &buf), 
+                platform: FfiConverterString.read(from: &buf), 
+                appVersion: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: FrontPage, into buf: inout [UInt8]) {
-        FfiConverterSequenceTypeSessionRow.write(value.pinned, into: &buf)
-        FfiConverterSequenceTypeSectionView.write(value.sections, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.recent, into: &buf)
+    public static func write(_ value: CoreConfig, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.edgeUrl, into: &buf)
+        FfiConverterString.write(value.dataDir, into: &buf)
+        FfiConverterString.write(value.deviceId, into: &buf)
+        FfiConverterString.write(value.deviceName, into: &buf)
+        FfiConverterString.write(value.platform, into: &buf)
+        FfiConverterString.write(value.appVersion, into: &buf)
     }
 }
 
@@ -5202,59 +5657,34 @@ public struct FfiConverterTypeFrontPage: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFrontPage_lift(_ buf: RustBuffer) throws -> FrontPage {
-    return try FfiConverterTypeFrontPage.lift(buf)
+public func FfiConverterTypeCoreConfig_lift(_ buf: RustBuffer) throws -> CoreConfig {
+    return try FfiConverterTypeCoreConfig.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFrontPage_lower(_ value: FrontPage) -> RustBuffer {
-    return FfiConverterTypeFrontPage.lower(value)
+public func FfiConverterTypeCoreConfig_lower(_ value: CoreConfig) -> RustBuffer {
+    return FfiConverterTypeCoreConfig.lower(value)
 }
 
 
-public struct HarnessInfo: Equatable, Hashable {
+/**
+ * A debug/demo transcript entry (markdown text), for fixtures and benches.
+ */
+public struct DebugEntry: Equatable, Hashable {
     public var id: String
-    public var label: String
-    public var supportsSteering: Bool?
-    /**
-     * `step-boundary` / `turn-boundary`.
-     */
-    public var steeringMode: String?
-    public var reasoningLevels: [String]
-    public var installed: Bool
-    public var enabled: Bool?
-    /**
-     * Installed and not disabled on the device.
-     */
-    public var offered: Bool
-    /**
-     * Steers mid-turn (unknown until a live catalog).
-     */
-    public var midTurnSteering: Bool?
+    public var user: Bool
+    public var text: String
+    public var streaming: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, label: String, supportsSteering: Bool?, 
-        /**
-         * `step-boundary` / `turn-boundary`.
-         */steeringMode: String?, reasoningLevels: [String], installed: Bool, enabled: Bool?, 
-        /**
-         * Installed and not disabled on the device.
-         */offered: Bool, 
-        /**
-         * Steers mid-turn (unknown until a live catalog).
-         */midTurnSteering: Bool?) {
+    public init(id: String, user: Bool, text: String, streaming: Bool) {
         self.id = id
-        self.label = label
-        self.supportsSteering = supportsSteering
-        self.steeringMode = steeringMode
-        self.reasoningLevels = reasoningLevels
-        self.installed = installed
-        self.enabled = enabled
-        self.offered = offered
-        self.midTurnSteering = midTurnSteering
+        self.user = user
+        self.text = text
+        self.streaming = streaming
     }
 
     
@@ -5263,38 +5693,28 @@ public struct HarnessInfo: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension HarnessInfo: Sendable {}
+extension DebugEntry: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeHarnessInfo: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HarnessInfo {
+public struct FfiConverterTypeDebugEntry: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DebugEntry {
         return
-            try HarnessInfo(
+            try DebugEntry(
                 id: FfiConverterString.read(from: &buf), 
-                label: FfiConverterString.read(from: &buf), 
-                supportsSteering: FfiConverterOptionBool.read(from: &buf), 
-                steeringMode: FfiConverterOptionString.read(from: &buf), 
-                reasoningLevels: FfiConverterSequenceString.read(from: &buf), 
-                installed: FfiConverterBool.read(from: &buf), 
-                enabled: FfiConverterOptionBool.read(from: &buf), 
-                offered: FfiConverterBool.read(from: &buf), 
-                midTurnSteering: FfiConverterOptionBool.read(from: &buf)
+                user: FfiConverterBool.read(from: &buf), 
+                text: FfiConverterString.read(from: &buf), 
+                streaming: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: HarnessInfo, into buf: inout [UInt8]) {
+    public static func write(_ value: DebugEntry, into buf: inout [UInt8]) {
         FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.label, into: &buf)
-        FfiConverterOptionBool.write(value.supportsSteering, into: &buf)
-        FfiConverterOptionString.write(value.steeringMode, into: &buf)
-        FfiConverterSequenceString.write(value.reasoningLevels, into: &buf)
-        FfiConverterBool.write(value.installed, into: &buf)
-        FfiConverterOptionBool.write(value.enabled, into: &buf)
-        FfiConverterBool.write(value.offered, into: &buf)
-        FfiConverterOptionBool.write(value.midTurnSteering, into: &buf)
+        FfiConverterBool.write(value.user, into: &buf)
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterBool.write(value.streaming, into: &buf)
     }
 }
 
@@ -5302,49 +5722,43 @@ public struct FfiConverterTypeHarnessInfo: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeHarnessInfo_lift(_ buf: RustBuffer) throws -> HarnessInfo {
-    return try FfiConverterTypeHarnessInfo.lift(buf)
+public func FfiConverterTypeDebugEntry_lift(_ buf: RustBuffer) throws -> DebugEntry {
+    return try FfiConverterTypeDebugEntry.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeHarnessInfo_lower(_ value: HarnessInfo) -> RustBuffer {
-    return FfiConverterTypeHarnessInfo.lower(value)
+public func FfiConverterTypeDebugEntry_lower(_ value: DebugEntry) -> RustBuffer {
+    return FfiConverterTypeDebugEntry.lower(value)
 }
 
 
-public struct HostCapabilities: Equatable, Hashable {
-    public var messageQueue: Bool
-    public var queueActions: Bool
-    public var queueAttachments: Bool
-    public var cleanAttachmentText: Bool
-    public var queueEditLease: Bool
+public struct DemoOptions: Equatable, Hashable {
+    public var fixture: DemoFixture
     /**
-     * Host ≥ 0.2.12: attachments ride `pending://` refs.
+     * Size of the flagship chat's (`chat-veil`) transcript.
      */
-    public var queuedAttachments: Bool
+    public var transcriptScale: TranscriptScale
+    public var streamSpeed: StreamSpeed
     /**
-     * The chat's harness steers mid-turn (unknown until a live catalog).
+     * Repeat the scripted reply 12× (long streaming stress).
      */
-    public var midTurnSteering: Bool?
+    public var longReply: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(messageQueue: Bool, queueActions: Bool, queueAttachments: Bool, cleanAttachmentText: Bool, queueEditLease: Bool, 
+    public init(fixture: DemoFixture, 
         /**
-         * Host ≥ 0.2.12: attachments ride `pending://` refs.
-         */queuedAttachments: Bool, 
+         * Size of the flagship chat's (`chat-veil`) transcript.
+         */transcriptScale: TranscriptScale, streamSpeed: StreamSpeed, 
         /**
-         * The chat's harness steers mid-turn (unknown until a live catalog).
-         */midTurnSteering: Bool?) {
-        self.messageQueue = messageQueue
-        self.queueActions = queueActions
-        self.queueAttachments = queueAttachments
-        self.cleanAttachmentText = cleanAttachmentText
-        self.queueEditLease = queueEditLease
-        self.queuedAttachments = queuedAttachments
-        self.midTurnSteering = midTurnSteering
+         * Repeat the scripted reply 12× (long streaming stress).
+         */longReply: Bool) {
+        self.fixture = fixture
+        self.transcriptScale = transcriptScale
+        self.streamSpeed = streamSpeed
+        self.longReply = longReply
     }
 
     
@@ -5353,34 +5767,28 @@ public struct HostCapabilities: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension HostCapabilities: Sendable {}
+extension DemoOptions: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeHostCapabilities: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HostCapabilities {
+public struct FfiConverterTypeDemoOptions: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DemoOptions {
         return
-            try HostCapabilities(
-                messageQueue: FfiConverterBool.read(from: &buf), 
-                queueActions: FfiConverterBool.read(from: &buf), 
-                queueAttachments: FfiConverterBool.read(from: &buf), 
-                cleanAttachmentText: FfiConverterBool.read(from: &buf), 
-                queueEditLease: FfiConverterBool.read(from: &buf), 
-                queuedAttachments: FfiConverterBool.read(from: &buf), 
-                midTurnSteering: FfiConverterOptionBool.read(from: &buf)
+            try DemoOptions(
+                fixture: FfiConverterTypeDemoFixture.read(from: &buf), 
+                transcriptScale: FfiConverterTypeTranscriptScale.read(from: &buf), 
+                streamSpeed: FfiConverterTypeStreamSpeed.read(from: &buf), 
+                longReply: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: HostCapabilities, into buf: inout [UInt8]) {
-        FfiConverterBool.write(value.messageQueue, into: &buf)
-        FfiConverterBool.write(value.queueActions, into: &buf)
-        FfiConverterBool.write(value.queueAttachments, into: &buf)
-        FfiConverterBool.write(value.cleanAttachmentText, into: &buf)
-        FfiConverterBool.write(value.queueEditLease, into: &buf)
-        FfiConverterBool.write(value.queuedAttachments, into: &buf)
-        FfiConverterOptionBool.write(value.midTurnSteering, into: &buf)
+    public static func write(_ value: DemoOptions, into buf: inout [UInt8]) {
+        FfiConverterTypeDemoFixture.write(value.fixture, into: &buf)
+        FfiConverterTypeTranscriptScale.write(value.transcriptScale, into: &buf)
+        FfiConverterTypeStreamSpeed.write(value.streamSpeed, into: &buf)
+        FfiConverterBool.write(value.longReply, into: &buf)
     }
 }
 
@@ -5388,31 +5796,49 @@ public struct FfiConverterTypeHostCapabilities: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeHostCapabilities_lift(_ buf: RustBuffer) throws -> HostCapabilities {
-    return try FfiConverterTypeHostCapabilities.lift(buf)
+public func FfiConverterTypeDemoOptions_lift(_ buf: RustBuffer) throws -> DemoOptions {
+    return try FfiConverterTypeDemoOptions.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeHostCapabilities_lower(_ value: HostCapabilities) -> RustBuffer {
-    return FfiConverterTypeHostCapabilities.lower(value)
+public func FfiConverterTypeDemoOptions_lower(_ value: DemoOptions) -> RustBuffer {
+    return FfiConverterTypeDemoOptions.lower(value)
 }
 
 
-public struct HostInfo: Equatable, Hashable {
-    public var deviceId: String
-    public var name: String?
+public struct DeviceView: Equatable, Hashable {
+    public var id: String
+    public var name: String
+    public var platform: String
     public var online: Bool
-    public var capabilities: HostCapabilities
-
+    public var lastSeenMs: Int64?
+    public var version: String?
+    public var capabilities: [String]
+    /**
+     * Can run sessions (desktop/server engines — not phones).
+     */
+    public var isExecutionHost: Bool
+    public var isSelf: Bool
+    public var sessionCount: UInt32
+
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(deviceId: String, name: String?, online: Bool, capabilities: HostCapabilities) {
-        self.deviceId = deviceId
+    public init(id: String, name: String, platform: String, online: Bool, lastSeenMs: Int64?, version: String?, capabilities: [String], 
+        /**
+         * Can run sessions (desktop/server engines — not phones).
+         */isExecutionHost: Bool, isSelf: Bool, sessionCount: UInt32) {
+        self.id = id
         self.name = name
+        self.platform = platform
         self.online = online
+        self.lastSeenMs = lastSeenMs
+        self.version = version
         self.capabilities = capabilities
+        self.isExecutionHost = isExecutionHost
+        self.isSelf = isSelf
+        self.sessionCount = sessionCount
     }
 
     
@@ -5421,28 +5847,40 @@ public struct HostInfo: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension HostInfo: Sendable {}
+extension DeviceView: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeHostInfo: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HostInfo {
+public struct FfiConverterTypeDeviceView: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DeviceView {
         return
-            try HostInfo(
-                deviceId: FfiConverterString.read(from: &buf), 
-                name: FfiConverterOptionString.read(from: &buf), 
+            try DeviceView(
+                id: FfiConverterString.read(from: &buf), 
+                name: FfiConverterString.read(from: &buf), 
+                platform: FfiConverterString.read(from: &buf), 
                 online: FfiConverterBool.read(from: &buf), 
-                capabilities: FfiConverterTypeHostCapabilities.read(from: &buf)
+                lastSeenMs: FfiConverterOptionInt64.read(from: &buf), 
+                version: FfiConverterOptionString.read(from: &buf), 
+                capabilities: FfiConverterSequenceString.read(from: &buf), 
+                isExecutionHost: FfiConverterBool.read(from: &buf), 
+                isSelf: FfiConverterBool.read(from: &buf), 
+                sessionCount: FfiConverterUInt32.read(from: &buf)
         )
     }
 
-    public static func write(_ value: HostInfo, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.deviceId, into: &buf)
-        FfiConverterOptionString.write(value.name, into: &buf)
+    public static func write(_ value: DeviceView, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterString.write(value.platform, into: &buf)
         FfiConverterBool.write(value.online, into: &buf)
-        FfiConverterTypeHostCapabilities.write(value.capabilities, into: &buf)
+        FfiConverterOptionInt64.write(value.lastSeenMs, into: &buf)
+        FfiConverterOptionString.write(value.version, into: &buf)
+        FfiConverterSequenceString.write(value.capabilities, into: &buf)
+        FfiConverterBool.write(value.isExecutionHost, into: &buf)
+        FfiConverterBool.write(value.isSelf, into: &buf)
+        FfiConverterUInt32.write(value.sessionCount, into: &buf)
     }
 }
 
@@ -5450,29 +5888,27 @@ public struct FfiConverterTypeHostInfo: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeHostInfo_lift(_ buf: RustBuffer) throws -> HostInfo {
-    return try FfiConverterTypeHostInfo.lift(buf)
+public func FfiConverterTypeDeviceView_lift(_ buf: RustBuffer) throws -> DeviceView {
+    return try FfiConverterTypeDeviceView.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeHostInfo_lower(_ value: HostInfo) -> RustBuffer {
-    return FfiConverterTypeHostInfo.lower(value)
+public func FfiConverterTypeDeviceView_lower(_ value: DeviceView) -> RustBuffer {
+    return FfiConverterTypeDeviceView.lower(value)
 }
 
 
-public struct InputRequest: Equatable, Hashable {
-    public var entryId: String
-    public var requestId: String
-    public var questions: [UserInputQuestion]
+public struct FaceData: Equatable, Hashable {
+    public var role: FaceRole
+    public var bytes: Data
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(entryId: String, requestId: String, questions: [UserInputQuestion]) {
-        self.entryId = entryId
-        self.requestId = requestId
-        self.questions = questions
+    public init(role: FaceRole, bytes: Data) {
+        self.role = role
+        self.bytes = bytes
     }
 
     
@@ -5481,26 +5917,24 @@ public struct InputRequest: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension InputRequest: Sendable {}
+extension FaceData: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeInputRequest: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> InputRequest {
+public struct FfiConverterTypeFaceData: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FaceData {
         return
-            try InputRequest(
-                entryId: FfiConverterString.read(from: &buf), 
-                requestId: FfiConverterString.read(from: &buf), 
-                questions: FfiConverterSequenceTypeUserInputQuestion.read(from: &buf)
+            try FaceData(
+                role: FfiConverterTypeFaceRole.read(from: &buf), 
+                bytes: FfiConverterData.read(from: &buf)
         )
     }
 
-    public static func write(_ value: InputRequest, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.entryId, into: &buf)
-        FfiConverterString.write(value.requestId, into: &buf)
-        FfiConverterSequenceTypeUserInputQuestion.write(value.questions, into: &buf)
+    public static func write(_ value: FaceData, into buf: inout [UInt8]) {
+        FfiConverterTypeFaceRole.write(value.role, into: &buf)
+        FfiConverterData.write(value.bytes, into: &buf)
     }
 }
 
@@ -5508,37 +5942,39 @@ public struct FfiConverterTypeInputRequest: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeInputRequest_lift(_ buf: RustBuffer) throws -> InputRequest {
-    return try FfiConverterTypeInputRequest.lift(buf)
+public func FfiConverterTypeFaceData_lift(_ buf: RustBuffer) throws -> FaceData {
+    return try FfiConverterTypeFaceData.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeInputRequest_lower(_ value: InputRequest) -> RustBuffer {
-    return FfiConverterTypeInputRequest.lower(value)
+public func FfiConverterTypeFaceData_lower(_ value: FaceData) -> RustBuffer {
+    return FfiConverterTypeFaceData.lower(value)
 }
 
 
 /**
- * A tappable link region (one per fragment; multi-line links repeat).
+ * An overflow fade: runs whose baseline falls inside the rect's vertical
+ * band are painted through an alpha ramp — the text itself fades, so it
+ * works over any background.
  */
-public struct LinkHit: Equatable, Hashable {
+public struct Fade: Equatable, Hashable {
     public var x: Float
     public var y: Float
     public var w: Float
     public var h: Float
-    public var url: String
+    public var edge: FadeEdge
     public var scroller: UInt32?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(x: Float, y: Float, w: Float, h: Float, url: String, scroller: UInt32?) {
+    public init(x: Float, y: Float, w: Float, h: Float, edge: FadeEdge, scroller: UInt32?) {
         self.x = x
         self.y = y
         self.w = w
         self.h = h
-        self.url = url
+        self.edge = edge
         self.scroller = scroller
     }
 
@@ -5548,31 +5984,31 @@ public struct LinkHit: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension LinkHit: Sendable {}
+extension Fade: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeLinkHit: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> LinkHit {
+public struct FfiConverterTypeFade: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Fade {
         return
-            try LinkHit(
+            try Fade(
                 x: FfiConverterFloat.read(from: &buf), 
                 y: FfiConverterFloat.read(from: &buf), 
                 w: FfiConverterFloat.read(from: &buf), 
                 h: FfiConverterFloat.read(from: &buf), 
-                url: FfiConverterString.read(from: &buf), 
+                edge: FfiConverterTypeFadeEdge.read(from: &buf), 
                 scroller: FfiConverterOptionUInt32.read(from: &buf)
         )
     }
 
-    public static func write(_ value: LinkHit, into buf: inout [UInt8]) {
+    public static func write(_ value: Fade, into buf: inout [UInt8]) {
         FfiConverterFloat.write(value.x, into: &buf)
         FfiConverterFloat.write(value.y, into: &buf)
         FfiConverterFloat.write(value.w, into: &buf)
         FfiConverterFloat.write(value.h, into: &buf)
-        FfiConverterString.write(value.url, into: &buf)
+        FfiConverterTypeFadeEdge.write(value.edge, into: &buf)
         FfiConverterOptionUInt32.write(value.scroller, into: &buf)
     }
 }
@@ -5581,57 +6017,30 @@ public struct FfiConverterTypeLinkHit: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeLinkHit_lift(_ buf: RustBuffer) throws -> LinkHit {
-    return try FfiConverterTypeLinkHit.lift(buf)
+public func FfiConverterTypeFade_lift(_ buf: RustBuffer) throws -> Fade {
+    return try FfiConverterTypeFade.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeLinkHit_lower(_ value: LinkHit) -> RustBuffer {
-    return FfiConverterTypeLinkHit.lower(value)
+public func FfiConverterTypeFade_lower(_ value: Fade) -> RustBuffer {
+    return FfiConverterTypeFade.lower(value)
 }
 
 
-public struct LiveStatus: Equatable, Hashable {
-    /**
-     * Display status (an in-flight send reads Working).
-     */
-    public var indicator: ChatIndicator
-    /**
-     * A turn is actually running on the host (sends queue/steer).
-     */
-    public var turnRunning: Bool
-    public var workingSinceMs: Int64?
-    /**
-     * The newest transcript entry is streaming.
-     */
-    public var streaming: Bool
-    /**
-     * Stop is meaningful.
-     */
-    public var canInterrupt: Bool
+/**
+ * A workspace file or folder for `@` mentions.
+ */
+public struct FileMatch: Equatable, Hashable {
+    public var path: String
+    public var isDir: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(
-        /**
-         * Display status (an in-flight send reads Working).
-         */indicator: ChatIndicator, 
-        /**
-         * A turn is actually running on the host (sends queue/steer).
-         */turnRunning: Bool, workingSinceMs: Int64?, 
-        /**
-         * The newest transcript entry is streaming.
-         */streaming: Bool, 
-        /**
-         * Stop is meaningful.
-         */canInterrupt: Bool) {
-        self.indicator = indicator
-        self.turnRunning = turnRunning
-        self.workingSinceMs = workingSinceMs
-        self.streaming = streaming
-        self.canInterrupt = canInterrupt
+    public init(path: String, isDir: Bool) {
+        self.path = path
+        self.isDir = isDir
     }
 
     
@@ -5640,30 +6049,24 @@ public struct LiveStatus: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension LiveStatus: Sendable {}
+extension FileMatch: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeLiveStatus: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> LiveStatus {
+public struct FfiConverterTypeFileMatch: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FileMatch {
         return
-            try LiveStatus(
-                indicator: FfiConverterTypeChatIndicator.read(from: &buf), 
-                turnRunning: FfiConverterBool.read(from: &buf), 
-                workingSinceMs: FfiConverterOptionInt64.read(from: &buf), 
-                streaming: FfiConverterBool.read(from: &buf), 
-                canInterrupt: FfiConverterBool.read(from: &buf)
+            try FileMatch(
+                path: FfiConverterString.read(from: &buf), 
+                isDir: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: LiveStatus, into buf: inout [UInt8]) {
-        FfiConverterTypeChatIndicator.write(value.indicator, into: &buf)
-        FfiConverterBool.write(value.turnRunning, into: &buf)
-        FfiConverterOptionInt64.write(value.workingSinceMs, into: &buf)
-        FfiConverterBool.write(value.streaming, into: &buf)
-        FfiConverterBool.write(value.canInterrupt, into: &buf)
+    public static func write(_ value: FileMatch, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.path, into: &buf)
+        FfiConverterBool.write(value.isDir, into: &buf)
     }
 }
 
@@ -5671,47 +6074,29 @@ public struct FfiConverterTypeLiveStatus: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeLiveStatus_lift(_ buf: RustBuffer) throws -> LiveStatus {
-    return try FfiConverterTypeLiveStatus.lift(buf)
+public func FfiConverterTypeFileMatch_lift(_ buf: RustBuffer) throws -> FileMatch {
+    return try FfiConverterTypeFileMatch.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeLiveStatus_lower(_ value: LiveStatus) -> RustBuffer {
-    return FfiConverterTypeLiveStatus.lower(value)
+public func FfiConverterTypeFileMatch_lower(_ value: FileMatch) -> RustBuffer {
+    return FfiConverterTypeFileMatch.lower(value)
 }
 
 
-public struct ModelInfo: Equatable, Hashable {
-    public var id: String
-    public var label: String
-    public var description: String?
-    /**
-     * Wire effort values; empty = no effort ladder.
-     */
-    public var reasoningLevels: [String]
-    public var options: [ModelOption]
-    /**
-     * The picker's default effort for this model.
-     */
-    public var defaultReasoning: String?
+public struct FolderEntry: Equatable, Hashable {
+    public var name: String
+    public var isDir: Bool
+    public var isRepo: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, label: String, description: String?, 
-        /**
-         * Wire effort values; empty = no effort ladder.
-         */reasoningLevels: [String], options: [ModelOption], 
-        /**
-         * The picker's default effort for this model.
-         */defaultReasoning: String?) {
-        self.id = id
-        self.label = label
-        self.description = description
-        self.reasoningLevels = reasoningLevels
-        self.options = options
-        self.defaultReasoning = defaultReasoning
+    public init(name: String, isDir: Bool, isRepo: Bool) {
+        self.name = name
+        self.isDir = isDir
+        self.isRepo = isRepo
     }
 
     
@@ -5720,32 +6105,26 @@ public struct ModelInfo: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ModelInfo: Sendable {}
+extension FolderEntry: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeModelInfo: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ModelInfo {
+public struct FfiConverterTypeFolderEntry: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FolderEntry {
         return
-            try ModelInfo(
-                id: FfiConverterString.read(from: &buf), 
-                label: FfiConverterString.read(from: &buf), 
-                description: FfiConverterOptionString.read(from: &buf), 
-                reasoningLevels: FfiConverterSequenceString.read(from: &buf), 
-                options: FfiConverterSequenceTypeModelOption.read(from: &buf), 
-                defaultReasoning: FfiConverterOptionString.read(from: &buf)
+            try FolderEntry(
+                name: FfiConverterString.read(from: &buf), 
+                isDir: FfiConverterBool.read(from: &buf), 
+                isRepo: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ModelInfo, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.label, into: &buf)
-        FfiConverterOptionString.write(value.description, into: &buf)
-        FfiConverterSequenceString.write(value.reasoningLevels, into: &buf)
-        FfiConverterSequenceTypeModelOption.write(value.options, into: &buf)
-        FfiConverterOptionString.write(value.defaultReasoning, into: &buf)
+    public static func write(_ value: FolderEntry, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterBool.write(value.isDir, into: &buf)
+        FfiConverterBool.write(value.isRepo, into: &buf)
     }
 }
 
@@ -5753,31 +6132,29 @@ public struct FfiConverterTypeModelInfo: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeModelInfo_lift(_ buf: RustBuffer) throws -> ModelInfo {
-    return try FfiConverterTypeModelInfo.lift(buf)
+public func FfiConverterTypeFolderEntry_lift(_ buf: RustBuffer) throws -> FolderEntry {
+    return try FfiConverterTypeFolderEntry.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeModelInfo_lower(_ value: ModelInfo) -> RustBuffer {
-    return FfiConverterTypeModelInfo.lower(value)
+public func FfiConverterTypeFolderEntry_lower(_ value: FolderEntry) -> RustBuffer {
+    return FfiConverterTypeFolderEntry.lower(value)
 }
 
 
-public struct ModelOption: Equatable, Hashable {
-    public var id: String
-    public var label: String
-    public var choices: [ModelOptionChoice]
-    public var defaultChoice: String
+public struct FolderListing: Equatable, Hashable {
+    public var path: String
+    public var entries: [FolderEntry]
+    public var truncated: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, label: String, choices: [ModelOptionChoice], defaultChoice: String) {
-        self.id = id
-        self.label = label
-        self.choices = choices
-        self.defaultChoice = defaultChoice
+    public init(path: String, entries: [FolderEntry], truncated: Bool) {
+        self.path = path
+        self.entries = entries
+        self.truncated = truncated
     }
 
     
@@ -5786,28 +6163,26 @@ public struct ModelOption: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ModelOption: Sendable {}
+extension FolderListing: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeModelOption: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ModelOption {
+public struct FfiConverterTypeFolderListing: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FolderListing {
         return
-            try ModelOption(
-                id: FfiConverterString.read(from: &buf), 
-                label: FfiConverterString.read(from: &buf), 
-                choices: FfiConverterSequenceTypeModelOptionChoice.read(from: &buf), 
-                defaultChoice: FfiConverterString.read(from: &buf)
+            try FolderListing(
+                path: FfiConverterString.read(from: &buf), 
+                entries: FfiConverterSequenceTypeFolderEntry.read(from: &buf), 
+                truncated: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ModelOption, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.label, into: &buf)
-        FfiConverterSequenceTypeModelOptionChoice.write(value.choices, into: &buf)
-        FfiConverterString.write(value.defaultChoice, into: &buf)
+    public static func write(_ value: FolderListing, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.path, into: &buf)
+        FfiConverterSequenceTypeFolderEntry.write(value.entries, into: &buf)
+        FfiConverterBool.write(value.truncated, into: &buf)
     }
 }
 
@@ -5815,27 +6190,50 @@ public struct FfiConverterTypeModelOption: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeModelOption_lift(_ buf: RustBuffer) throws -> ModelOption {
-    return try FfiConverterTypeModelOption.lift(buf)
+public func FfiConverterTypeFolderListing_lift(_ buf: RustBuffer) throws -> FolderListing {
+    return try FfiConverterTypeFolderListing.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeModelOption_lower(_ value: ModelOption) -> RustBuffer {
-    return FfiConverterTypeModelOption.lower(value)
+public func FfiConverterTypeFolderListing_lower(_ value: FolderListing) -> RustBuffer {
+    return FfiConverterTypeFolderListing.lower(value)
 }
 
 
-public struct ModelOptionChoice: Equatable, Hashable {
-    public var id: String
-    public var label: String
+/**
+ * The Threads page — the desktop sidebar order.
+ */
+public struct FrontPage: Equatable, Hashable {
+    /**
+     * Shared manual pin order.
+     */
+    public var pinned: [SessionRow]
+    /**
+     * User sections ("folders"), each in recency order.
+     */
+    public var sections: [SectionView]
+    /**
+     * Everything else, by recency.
+     */
+    public var recent: [SessionRow]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, label: String) {
-        self.id = id
-        self.label = label
+    public init(
+        /**
+         * Shared manual pin order.
+         */pinned: [SessionRow], 
+        /**
+         * User sections ("folders"), each in recency order.
+         */sections: [SectionView], 
+        /**
+         * Everything else, by recency.
+         */recent: [SessionRow]) {
+        self.pinned = pinned
+        self.sections = sections
+        self.recent = recent
     }
 
     
@@ -5844,24 +6242,26 @@ public struct ModelOptionChoice: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ModelOptionChoice: Sendable {}
+extension FrontPage: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeModelOptionChoice: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ModelOptionChoice {
+public struct FfiConverterTypeFrontPage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FrontPage {
         return
-            try ModelOptionChoice(
-                id: FfiConverterString.read(from: &buf), 
-                label: FfiConverterString.read(from: &buf)
+            try FrontPage(
+                pinned: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
+                sections: FfiConverterSequenceTypeSectionView.read(from: &buf), 
+                recent: FfiConverterSequenceTypeSessionRow.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ModelOptionChoice, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.label, into: &buf)
+    public static func write(_ value: FrontPage, into buf: inout [UInt8]) {
+        FfiConverterSequenceTypeSessionRow.write(value.pinned, into: &buf)
+        FfiConverterSequenceTypeSectionView.write(value.sections, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.recent, into: &buf)
     }
 }
 
@@ -5869,45 +6269,59 @@ public struct FfiConverterTypeModelOptionChoice: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeModelOptionChoice_lift(_ buf: RustBuffer) throws -> ModelOptionChoice {
-    return try FfiConverterTypeModelOptionChoice.lift(buf)
+public func FfiConverterTypeFrontPage_lift(_ buf: RustBuffer) throws -> FrontPage {
+    return try FfiConverterTypeFrontPage.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeModelOptionChoice_lower(_ value: ModelOptionChoice) -> RustBuffer {
-    return FfiConverterTypeModelOptionChoice.lower(value)
+public func FfiConverterTypeFrontPage_lower(_ value: FrontPage) -> RustBuffer {
+    return FfiConverterTypeFrontPage.lower(value)
 }
 
 
-public struct NewSession: Equatable, Hashable {
-    public var target: SessionTarget
-    public var config: ChatConfig?
+public struct HarnessInfo: Equatable, Hashable {
+    public var id: String
+    public var label: String
+    public var supportsSteering: Bool?
     /**
-     * Branch stamped from the first frame (picked ref).
+     * `step-boundary` / `turn-boundary`.
      */
-    public var branch: String?
+    public var steeringMode: String?
+    public var reasoningLevels: [String]
+    public var installed: Bool
+    public var enabled: Bool?
     /**
-     * Checkout override (an existing worktree's path).
+     * Installed and not disabled on the device.
      */
-    public var cwd: String?
-    public var title: String?
+    public var offered: Bool
+    /**
+     * Steers mid-turn (unknown until a live catalog).
+     */
+    public var midTurnSteering: Bool?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(target: SessionTarget, config: ChatConfig?, 
+    public init(id: String, label: String, supportsSteering: Bool?, 
         /**
-         * Branch stamped from the first frame (picked ref).
-         */branch: String?, 
+         * `step-boundary` / `turn-boundary`.
+         */steeringMode: String?, reasoningLevels: [String], installed: Bool, enabled: Bool?, 
         /**
-         * Checkout override (an existing worktree's path).
-         */cwd: String?, title: String?) {
-        self.target = target
-        self.config = config
-        self.branch = branch
-        self.cwd = cwd
-        self.title = title
+         * Installed and not disabled on the device.
+         */offered: Bool, 
+        /**
+         * Steers mid-turn (unknown until a live catalog).
+         */midTurnSteering: Bool?) {
+        self.id = id
+        self.label = label
+        self.supportsSteering = supportsSteering
+        self.steeringMode = steeringMode
+        self.reasoningLevels = reasoningLevels
+        self.installed = installed
+        self.enabled = enabled
+        self.offered = offered
+        self.midTurnSteering = midTurnSteering
     }
 
     
@@ -5916,30 +6330,38 @@ public struct NewSession: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension NewSession: Sendable {}
+extension HarnessInfo: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeNewSession: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NewSession {
+public struct FfiConverterTypeHarnessInfo: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HarnessInfo {
         return
-            try NewSession(
-                target: FfiConverterTypeSessionTarget.read(from: &buf), 
-                config: FfiConverterOptionTypeChatConfig.read(from: &buf), 
-                branch: FfiConverterOptionString.read(from: &buf), 
-                cwd: FfiConverterOptionString.read(from: &buf), 
-                title: FfiConverterOptionString.read(from: &buf)
+            try HarnessInfo(
+                id: FfiConverterString.read(from: &buf), 
+                label: FfiConverterString.read(from: &buf), 
+                supportsSteering: FfiConverterOptionBool.read(from: &buf), 
+                steeringMode: FfiConverterOptionString.read(from: &buf), 
+                reasoningLevels: FfiConverterSequenceString.read(from: &buf), 
+                installed: FfiConverterBool.read(from: &buf), 
+                enabled: FfiConverterOptionBool.read(from: &buf), 
+                offered: FfiConverterBool.read(from: &buf), 
+                midTurnSteering: FfiConverterOptionBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: NewSession, into buf: inout [UInt8]) {
-        FfiConverterTypeSessionTarget.write(value.target, into: &buf)
-        FfiConverterOptionTypeChatConfig.write(value.config, into: &buf)
-        FfiConverterOptionString.write(value.branch, into: &buf)
-        FfiConverterOptionString.write(value.cwd, into: &buf)
-        FfiConverterOptionString.write(value.title, into: &buf)
+    public static func write(_ value: HarnessInfo, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.label, into: &buf)
+        FfiConverterOptionBool.write(value.supportsSteering, into: &buf)
+        FfiConverterOptionString.write(value.steeringMode, into: &buf)
+        FfiConverterSequenceString.write(value.reasoningLevels, into: &buf)
+        FfiConverterBool.write(value.installed, into: &buf)
+        FfiConverterOptionBool.write(value.enabled, into: &buf)
+        FfiConverterBool.write(value.offered, into: &buf)
+        FfiConverterOptionBool.write(value.midTurnSteering, into: &buf)
     }
 }
 
@@ -5947,57 +6369,85 @@ public struct FfiConverterTypeNewSession: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeNewSession_lift(_ buf: RustBuffer) throws -> NewSession {
-    return try FfiConverterTypeNewSession.lift(buf)
+public func FfiConverterTypeHarnessInfo_lift(_ buf: RustBuffer) throws -> HarnessInfo {
+    return try FfiConverterTypeHarnessInfo.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeNewSession_lower(_ value: NewSession) -> RustBuffer {
-    return FfiConverterTypeNewSession.lower(value)
+public func FfiConverterTypeHarnessInfo_lower(_ value: HarnessInfo) -> RustBuffer {
+    return FfiConverterTypeHarnessInfo.lower(value)
 }
 
 
-public struct OutgoingAttachment: Equatable, Hashable {
-    public var name: String
-    public var mimeType: String
-    public var data: Data
-
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(name: String, mimeType: String, data: Data) {
-        self.name = name
-        self.mimeType = mimeType
-        self.data = data
-    }
-
-    
-
+public struct HostCapabilities: Equatable, Hashable {
+    public var messageQueue: Bool
+    public var queueActions: Bool
+    public var queueAttachments: Bool
+    public var cleanAttachmentText: Bool
+    public var queueEditLease: Bool
+    /**
+     * Host ≥ 0.2.12: attachments ride `pending://` refs.
+     */
+    public var queuedAttachments: Bool
+    /**
+     * The chat's harness steers mid-turn (unknown until a live catalog).
+     */
+    public var midTurnSteering: Bool?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(messageQueue: Bool, queueActions: Bool, queueAttachments: Bool, cleanAttachmentText: Bool, queueEditLease: Bool, 
+        /**
+         * Host ≥ 0.2.12: attachments ride `pending://` refs.
+         */queuedAttachments: Bool, 
+        /**
+         * The chat's harness steers mid-turn (unknown until a live catalog).
+         */midTurnSteering: Bool?) {
+        self.messageQueue = messageQueue
+        self.queueActions = queueActions
+        self.queueAttachments = queueAttachments
+        self.cleanAttachmentText = cleanAttachmentText
+        self.queueEditLease = queueEditLease
+        self.queuedAttachments = queuedAttachments
+        self.midTurnSteering = midTurnSteering
+    }
+
+    
+
     
 }
 
 #if compiler(>=6)
-extension OutgoingAttachment: Sendable {}
+extension HostCapabilities: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeOutgoingAttachment: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OutgoingAttachment {
+public struct FfiConverterTypeHostCapabilities: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HostCapabilities {
         return
-            try OutgoingAttachment(
-                name: FfiConverterString.read(from: &buf), 
-                mimeType: FfiConverterString.read(from: &buf), 
-                data: FfiConverterData.read(from: &buf)
+            try HostCapabilities(
+                messageQueue: FfiConverterBool.read(from: &buf), 
+                queueActions: FfiConverterBool.read(from: &buf), 
+                queueAttachments: FfiConverterBool.read(from: &buf), 
+                cleanAttachmentText: FfiConverterBool.read(from: &buf), 
+                queueEditLease: FfiConverterBool.read(from: &buf), 
+                queuedAttachments: FfiConverterBool.read(from: &buf), 
+                midTurnSteering: FfiConverterOptionBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: OutgoingAttachment, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterString.write(value.mimeType, into: &buf)
-        FfiConverterData.write(value.data, into: &buf)
+    public static func write(_ value: HostCapabilities, into buf: inout [UInt8]) {
+        FfiConverterBool.write(value.messageQueue, into: &buf)
+        FfiConverterBool.write(value.queueActions, into: &buf)
+        FfiConverterBool.write(value.queueAttachments, into: &buf)
+        FfiConverterBool.write(value.cleanAttachmentText, into: &buf)
+        FfiConverterBool.write(value.queueEditLease, into: &buf)
+        FfiConverterBool.write(value.queuedAttachments, into: &buf)
+        FfiConverterOptionBool.write(value.midTurnSteering, into: &buf)
     }
 }
 
@@ -6005,33 +6455,31 @@ public struct FfiConverterTypeOutgoingAttachment: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeOutgoingAttachment_lift(_ buf: RustBuffer) throws -> OutgoingAttachment {
-    return try FfiConverterTypeOutgoingAttachment.lift(buf)
+public func FfiConverterTypeHostCapabilities_lift(_ buf: RustBuffer) throws -> HostCapabilities {
+    return try FfiConverterTypeHostCapabilities.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeOutgoingAttachment_lower(_ value: OutgoingAttachment) -> RustBuffer {
-    return FfiConverterTypeOutgoingAttachment.lower(value)
+public func FfiConverterTypeHostCapabilities_lower(_ value: HostCapabilities) -> RustBuffer {
+    return FfiConverterTypeHostCapabilities.lower(value)
 }
 
 
-public struct ParsedUserMessage: Equatable, Hashable {
-    /**
-     * Visible prompt (trailer + Appshot context stripped).
-     */
-    public var text: String
-    public var images: [UserImage]
+public struct HostInfo: Equatable, Hashable {
+    public var deviceId: String
+    public var name: String?
+    public var online: Bool
+    public var capabilities: HostCapabilities
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(
-        /**
-         * Visible prompt (trailer + Appshot context stripped).
-         */text: String, images: [UserImage]) {
-        self.text = text
-        self.images = images
+    public init(deviceId: String, name: String?, online: Bool, capabilities: HostCapabilities) {
+        self.deviceId = deviceId
+        self.name = name
+        self.online = online
+        self.capabilities = capabilities
     }
 
     
@@ -6040,24 +6488,28 @@ public struct ParsedUserMessage: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ParsedUserMessage: Sendable {}
+extension HostInfo: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeParsedUserMessage: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ParsedUserMessage {
+public struct FfiConverterTypeHostInfo: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HostInfo {
         return
-            try ParsedUserMessage(
-                text: FfiConverterString.read(from: &buf), 
-                images: FfiConverterSequenceTypeUserImage.read(from: &buf)
+            try HostInfo(
+                deviceId: FfiConverterString.read(from: &buf), 
+                name: FfiConverterOptionString.read(from: &buf), 
+                online: FfiConverterBool.read(from: &buf), 
+                capabilities: FfiConverterTypeHostCapabilities.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ParsedUserMessage, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.text, into: &buf)
-        FfiConverterSequenceTypeUserImage.write(value.images, into: &buf)
+    public static func write(_ value: HostInfo, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.deviceId, into: &buf)
+        FfiConverterOptionString.write(value.name, into: &buf)
+        FfiConverterBool.write(value.online, into: &buf)
+        FfiConverterTypeHostCapabilities.write(value.capabilities, into: &buf)
     }
 }
 
@@ -6065,49 +6517,29 @@ public struct FfiConverterTypeParsedUserMessage: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeParsedUserMessage_lift(_ buf: RustBuffer) throws -> ParsedUserMessage {
-    return try FfiConverterTypeParsedUserMessage.lift(buf)
+public func FfiConverterTypeHostInfo_lift(_ buf: RustBuffer) throws -> HostInfo {
+    return try FfiConverterTypeHostInfo.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeParsedUserMessage_lower(_ value: ParsedUserMessage) -> RustBuffer {
-    return FfiConverterTypeParsedUserMessage.lower(value)
+public func FfiConverterTypeHostInfo_lower(_ value: HostInfo) -> RustBuffer {
+    return FfiConverterTypeHostInfo.lower(value)
 }
 
 
-public struct PendingSend: Equatable, Hashable {
-    /**
-     * Client-minted id (the host's user entry reuses it).
-     */
-    public var messageId: String
-    /**
-     * Raw content (attachment trailer included).
-     */
-    public var text: String
-    public var visibleText: String
-    public var images: [String]
-    public var kind: PendingKind
-    public var sentAtMs: Int64
-    public var state: SendState
+public struct InputRequest: Equatable, Hashable {
+    public var entryId: String
+    public var requestId: String
+    public var questions: [UserInputQuestion]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(
-        /**
-         * Client-minted id (the host's user entry reuses it).
-         */messageId: String, 
-        /**
-         * Raw content (attachment trailer included).
-         */text: String, visibleText: String, images: [String], kind: PendingKind, sentAtMs: Int64, state: SendState) {
-        self.messageId = messageId
-        self.text = text
-        self.visibleText = visibleText
-        self.images = images
-        self.kind = kind
-        self.sentAtMs = sentAtMs
-        self.state = state
+    public init(entryId: String, requestId: String, questions: [UserInputQuestion]) {
+        self.entryId = entryId
+        self.requestId = requestId
+        self.questions = questions
     }
 
     
@@ -6116,34 +6548,26 @@ public struct PendingSend: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension PendingSend: Sendable {}
+extension InputRequest: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypePendingSend: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PendingSend {
+public struct FfiConverterTypeInputRequest: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> InputRequest {
         return
-            try PendingSend(
-                messageId: FfiConverterString.read(from: &buf), 
-                text: FfiConverterString.read(from: &buf), 
-                visibleText: FfiConverterString.read(from: &buf), 
-                images: FfiConverterSequenceString.read(from: &buf), 
-                kind: FfiConverterTypePendingKind.read(from: &buf), 
-                sentAtMs: FfiConverterInt64.read(from: &buf), 
-                state: FfiConverterTypeSendState.read(from: &buf)
+            try InputRequest(
+                entryId: FfiConverterString.read(from: &buf), 
+                requestId: FfiConverterString.read(from: &buf), 
+                questions: FfiConverterSequenceTypeUserInputQuestion.read(from: &buf)
         )
     }
 
-    public static func write(_ value: PendingSend, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.messageId, into: &buf)
-        FfiConverterString.write(value.text, into: &buf)
-        FfiConverterString.write(value.visibleText, into: &buf)
-        FfiConverterSequenceString.write(value.images, into: &buf)
-        FfiConverterTypePendingKind.write(value.kind, into: &buf)
-        FfiConverterInt64.write(value.sentAtMs, into: &buf)
-        FfiConverterTypeSendState.write(value.state, into: &buf)
+    public static func write(_ value: InputRequest, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.entryId, into: &buf)
+        FfiConverterString.write(value.requestId, into: &buf)
+        FfiConverterSequenceTypeUserInputQuestion.write(value.questions, into: &buf)
     }
 }
 
@@ -6151,35 +6575,38 @@ public struct FfiConverterTypePendingSend: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePendingSend_lift(_ buf: RustBuffer) throws -> PendingSend {
-    return try FfiConverterTypePendingSend.lift(buf)
+public func FfiConverterTypeInputRequest_lift(_ buf: RustBuffer) throws -> InputRequest {
+    return try FfiConverterTypeInputRequest.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePendingSend_lower(_ value: PendingSend) -> RustBuffer {
-    return FfiConverterTypePendingSend.lower(value)
+public func FfiConverterTypeInputRequest_lower(_ value: InputRequest) -> RustBuffer {
+    return FfiConverterTypeInputRequest.lower(value)
 }
 
 
-public struct ProjectRef: Equatable, Hashable {
-    public var id: String
-    public var name: String
-    /**
-     * Stable palette slot (0..PROJECT_COLOR_COUNT).
-     */
-    public var colorIndex: UInt32
+/**
+ * A tappable link region (one per fragment; multi-line links repeat).
+ */
+public struct LinkHit: Equatable, Hashable {
+    public var x: Float
+    public var y: Float
+    public var w: Float
+    public var h: Float
+    public var url: String
+    public var scroller: UInt32?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, name: String, 
-        /**
-         * Stable palette slot (0..PROJECT_COLOR_COUNT).
-         */colorIndex: UInt32) {
-        self.id = id
-        self.name = name
-        self.colorIndex = colorIndex
+    public init(x: Float, y: Float, w: Float, h: Float, url: String, scroller: UInt32?) {
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.url = url
+        self.scroller = scroller
     }
 
     
@@ -6188,102 +6615,90 @@ public struct ProjectRef: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ProjectRef: Sendable {}
+extension LinkHit: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeProjectRef: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProjectRef {
+public struct FfiConverterTypeLinkHit: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> LinkHit {
         return
-            try ProjectRef(
-                id: FfiConverterString.read(from: &buf), 
-                name: FfiConverterString.read(from: &buf), 
-                colorIndex: FfiConverterUInt32.read(from: &buf)
+            try LinkHit(
+                x: FfiConverterFloat.read(from: &buf), 
+                y: FfiConverterFloat.read(from: &buf), 
+                w: FfiConverterFloat.read(from: &buf), 
+                h: FfiConverterFloat.read(from: &buf), 
+                url: FfiConverterString.read(from: &buf), 
+                scroller: FfiConverterOptionUInt32.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ProjectRef, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterUInt32.write(value.colorIndex, into: &buf)
-    }
-}
-
-
-#if swift(>=5.8)
+    public static func write(_ value: LinkHit, into buf: inout [UInt8]) {
+        FfiConverterFloat.write(value.x, into: &buf)
+        FfiConverterFloat.write(value.y, into: &buf)
+        FfiConverterFloat.write(value.w, into: &buf)
+        FfiConverterFloat.write(value.h, into: &buf)
+        FfiConverterString.write(value.url, into: &buf)
+        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeProjectRef_lift(_ buf: RustBuffer) throws -> ProjectRef {
-    return try FfiConverterTypeProjectRef.lift(buf)
+public func FfiConverterTypeLinkHit_lift(_ buf: RustBuffer) throws -> LinkHit {
+    return try FfiConverterTypeLinkHit.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeProjectRef_lower(_ value: ProjectRef) -> RustBuffer {
-    return FfiConverterTypeProjectRef.lower(value)
+public func FfiConverterTypeLinkHit_lower(_ value: LinkHit) -> RustBuffer {
+    return FfiConverterTypeLinkHit.lower(value)
 }
 
 
-public struct ProjectView: Equatable, Hashable {
-    public var id: String
-    public var name: String
-    public var path: String
-    public var colorIndex: UInt32
-    public var deviceId: String
-    public var deviceName: String?
-    public var deviceOnline: Bool
-    public var gitDetected: Bool
-    public var createdAtMs: Int64
+public struct LiveStatus: Equatable, Hashable {
     /**
-     * Shared by every checkout of one repository, on any device.
+     * Display status (an in-flight send reads Working).
      */
-    public var groupKey: String
+    public var indicator: ChatIndicator
     /**
-     * The repository group's name, shared like `color_index`.
+     * A turn is actually running on the host (sends queue/steer).
      */
-    public var groupName: String
+    public var turnRunning: Bool
+    public var workingSinceMs: Int64?
     /**
-     * Most urgent indicator among its active sessions.
+     * The newest transcript entry is streaming.
      */
-    public var indicator: ChatIndicator
-    public var unseenCount: UInt32
+    public var streaming: Bool
     /**
-     * Active sessions, recency order.
+     * Stop is meaningful.
      */
-    public var sessions: [SessionRow]
+    public var canInterrupt: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, name: String, path: String, colorIndex: UInt32, deviceId: String, deviceName: String?, deviceOnline: Bool, gitDetected: Bool, createdAtMs: Int64, 
+    public init(
         /**
-         * Shared by every checkout of one repository, on any device.
-         */groupKey: String, 
+         * Display status (an in-flight send reads Working).
+         */indicator: ChatIndicator, 
         /**
-         * The repository group's name, shared like `color_index`.
-         */groupName: String, 
+         * A turn is actually running on the host (sends queue/steer).
+         */turnRunning: Bool, workingSinceMs: Int64?, 
         /**
-         * Most urgent indicator among its active sessions.
-         */indicator: ChatIndicator, unseenCount: UInt32, 
+         * The newest transcript entry is streaming.
+         */streaming: Bool, 
         /**
-         * Active sessions, recency order.
-         */sessions: [SessionRow]) {
-        self.id = id
-        self.name = name
-        self.path = path
-        self.colorIndex = colorIndex
-        self.deviceId = deviceId
-        self.deviceName = deviceName
-        self.deviceOnline = deviceOnline
-        self.gitDetected = gitDetected
-        self.createdAtMs = createdAtMs
-        self.groupKey = groupKey
-        self.groupName = groupName
+         * Stop is meaningful.
+         */canInterrupt: Bool) {
         self.indicator = indicator
-        self.unseenCount = unseenCount
-        self.sessions = sessions
+        self.turnRunning = turnRunning
+        self.workingSinceMs = workingSinceMs
+        self.streaming = streaming
+        self.canInterrupt = canInterrupt
     }
 
     
@@ -6292,48 +6707,30 @@ public struct ProjectView: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ProjectView: Sendable {}
+extension LiveStatus: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeProjectView: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProjectView {
+public struct FfiConverterTypeLiveStatus: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> LiveStatus {
         return
-            try ProjectView(
-                id: FfiConverterString.read(from: &buf), 
-                name: FfiConverterString.read(from: &buf), 
-                path: FfiConverterString.read(from: &buf), 
-                colorIndex: FfiConverterUInt32.read(from: &buf), 
-                deviceId: FfiConverterString.read(from: &buf), 
-                deviceName: FfiConverterOptionString.read(from: &buf), 
-                deviceOnline: FfiConverterBool.read(from: &buf), 
-                gitDetected: FfiConverterBool.read(from: &buf), 
-                createdAtMs: FfiConverterInt64.read(from: &buf), 
-                groupKey: FfiConverterString.read(from: &buf), 
-                groupName: FfiConverterString.read(from: &buf), 
+            try LiveStatus(
                 indicator: FfiConverterTypeChatIndicator.read(from: &buf), 
-                unseenCount: FfiConverterUInt32.read(from: &buf), 
-                sessions: FfiConverterSequenceTypeSessionRow.read(from: &buf)
+                turnRunning: FfiConverterBool.read(from: &buf), 
+                workingSinceMs: FfiConverterOptionInt64.read(from: &buf), 
+                streaming: FfiConverterBool.read(from: &buf), 
+                canInterrupt: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: ProjectView, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterString.write(value.path, into: &buf)
-        FfiConverterUInt32.write(value.colorIndex, into: &buf)
-        FfiConverterString.write(value.deviceId, into: &buf)
-        FfiConverterOptionString.write(value.deviceName, into: &buf)
-        FfiConverterBool.write(value.deviceOnline, into: &buf)
-        FfiConverterBool.write(value.gitDetected, into: &buf)
-        FfiConverterInt64.write(value.createdAtMs, into: &buf)
-        FfiConverterString.write(value.groupKey, into: &buf)
-        FfiConverterString.write(value.groupName, into: &buf)
+    public static func write(_ value: LiveStatus, into buf: inout [UInt8]) {
         FfiConverterTypeChatIndicator.write(value.indicator, into: &buf)
-        FfiConverterUInt32.write(value.unseenCount, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.sessions, into: &buf)
+        FfiConverterBool.write(value.turnRunning, into: &buf)
+        FfiConverterOptionInt64.write(value.workingSinceMs, into: &buf)
+        FfiConverterBool.write(value.streaming, into: &buf)
+        FfiConverterBool.write(value.canInterrupt, into: &buf)
     }
 }
 
@@ -6341,37 +6738,47 @@ public struct FfiConverterTypeProjectView: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeProjectView_lift(_ buf: RustBuffer) throws -> ProjectView {
-    return try FfiConverterTypeProjectView.lift(buf)
+public func FfiConverterTypeLiveStatus_lift(_ buf: RustBuffer) throws -> LiveStatus {
+    return try FfiConverterTypeLiveStatus.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeProjectView_lower(_ value: ProjectView) -> RustBuffer {
-    return FfiConverterTypeProjectView.lower(value)
+public func FfiConverterTypeLiveStatus_lower(_ value: LiveStatus) -> RustBuffer {
+    return FfiConverterTypeLiveStatus.lower(value)
 }
 
 
-public struct PullRequest: Equatable, Hashable {
-    public var provider: String
-    public var number: UInt64
-    public var title: String
-    public var url: String
-    public var state: PullRequestState
-    public var baseRef: String
-    public var headRef: String
+public struct ModelInfo: Equatable, Hashable {
+    public var id: String
+    public var label: String
+    public var description: String?
+    /**
+     * Wire effort values; empty = no effort ladder.
+     */
+    public var reasoningLevels: [String]
+    public var options: [ModelOption]
+    /**
+     * The picker's default effort for this model.
+     */
+    public var defaultReasoning: String?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(provider: String, number: UInt64, title: String, url: String, state: PullRequestState, baseRef: String, headRef: String) {
-        self.provider = provider
-        self.number = number
-        self.title = title
-        self.url = url
-        self.state = state
-        self.baseRef = baseRef
-        self.headRef = headRef
+    public init(id: String, label: String, description: String?, 
+        /**
+         * Wire effort values; empty = no effort ladder.
+         */reasoningLevels: [String], options: [ModelOption], 
+        /**
+         * The picker's default effort for this model.
+         */defaultReasoning: String?) {
+        self.id = id
+        self.label = label
+        self.description = description
+        self.reasoningLevels = reasoningLevels
+        self.options = options
+        self.defaultReasoning = defaultReasoning
     }
 
     
@@ -6380,34 +6787,32 @@ public struct PullRequest: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension PullRequest: Sendable {}
+extension ModelInfo: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypePullRequest: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PullRequest {
+public struct FfiConverterTypeModelInfo: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ModelInfo {
         return
-            try PullRequest(
-                provider: FfiConverterString.read(from: &buf), 
-                number: FfiConverterUInt64.read(from: &buf), 
-                title: FfiConverterString.read(from: &buf), 
-                url: FfiConverterString.read(from: &buf), 
-                state: FfiConverterTypePullRequestState.read(from: &buf), 
-                baseRef: FfiConverterString.read(from: &buf), 
-                headRef: FfiConverterString.read(from: &buf)
+            try ModelInfo(
+                id: FfiConverterString.read(from: &buf), 
+                label: FfiConverterString.read(from: &buf), 
+                description: FfiConverterOptionString.read(from: &buf), 
+                reasoningLevels: FfiConverterSequenceString.read(from: &buf), 
+                options: FfiConverterSequenceTypeModelOption.read(from: &buf), 
+                defaultReasoning: FfiConverterOptionString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: PullRequest, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.provider, into: &buf)
-        FfiConverterUInt64.write(value.number, into: &buf)
-        FfiConverterString.write(value.title, into: &buf)
-        FfiConverterString.write(value.url, into: &buf)
-        FfiConverterTypePullRequestState.write(value.state, into: &buf)
-        FfiConverterString.write(value.baseRef, into: &buf)
-        FfiConverterString.write(value.headRef, into: &buf)
+    public static func write(_ value: ModelInfo, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.label, into: &buf)
+        FfiConverterOptionString.write(value.description, into: &buf)
+        FfiConverterSequenceString.write(value.reasoningLevels, into: &buf)
+        FfiConverterSequenceTypeModelOption.write(value.options, into: &buf)
+        FfiConverterOptionString.write(value.defaultReasoning, into: &buf)
     }
 }
 
@@ -6415,29 +6820,31 @@ public struct FfiConverterTypePullRequest: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePullRequest_lift(_ buf: RustBuffer) throws -> PullRequest {
-    return try FfiConverterTypePullRequest.lift(buf)
+public func FfiConverterTypeModelInfo_lift(_ buf: RustBuffer) throws -> ModelInfo {
+    return try FfiConverterTypeModelInfo.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePullRequest_lower(_ value: PullRequest) -> RustBuffer {
-    return FfiConverterTypePullRequest.lower(value)
+public func FfiConverterTypeModelInfo_lower(_ value: ModelInfo) -> RustBuffer {
+    return FfiConverterTypeModelInfo.lower(value)
 }
 
 
-public struct PullRequestGroups: Equatable, Hashable {
-    public var `open`: [SessionRow]
-    public var merged: [SessionRow]
-    public var closed: [SessionRow]
+public struct ModelOption: Equatable, Hashable {
+    public var id: String
+    public var label: String
+    public var choices: [ModelOptionChoice]
+    public var defaultChoice: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(`open`: [SessionRow], merged: [SessionRow], closed: [SessionRow]) {
-        self.`open` = `open`
-        self.merged = merged
-        self.closed = closed
+    public init(id: String, label: String, choices: [ModelOptionChoice], defaultChoice: String) {
+        self.id = id
+        self.label = label
+        self.choices = choices
+        self.defaultChoice = defaultChoice
     }
 
     
@@ -6446,26 +6853,28 @@ public struct PullRequestGroups: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension PullRequestGroups: Sendable {}
+extension ModelOption: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypePullRequestGroups: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PullRequestGroups {
+public struct FfiConverterTypeModelOption: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ModelOption {
         return
-            try PullRequestGroups(
-                open: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
-                merged: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
-                closed: FfiConverterSequenceTypeSessionRow.read(from: &buf)
+            try ModelOption(
+                id: FfiConverterString.read(from: &buf), 
+                label: FfiConverterString.read(from: &buf), 
+                choices: FfiConverterSequenceTypeModelOptionChoice.read(from: &buf), 
+                defaultChoice: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: PullRequestGroups, into buf: inout [UInt8]) {
-        FfiConverterSequenceTypeSessionRow.write(value.`open`, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.merged, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.closed, into: &buf)
+    public static func write(_ value: ModelOption, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.label, into: &buf)
+        FfiConverterSequenceTypeModelOptionChoice.write(value.choices, into: &buf)
+        FfiConverterString.write(value.defaultChoice, into: &buf)
     }
 }
 
@@ -6473,32 +6882,27 @@ public struct FfiConverterTypePullRequestGroups: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePullRequestGroups_lift(_ buf: RustBuffer) throws -> PullRequestGroups {
-    return try FfiConverterTypePullRequestGroups.lift(buf)
+public func FfiConverterTypeModelOption_lift(_ buf: RustBuffer) throws -> ModelOption {
+    return try FfiConverterTypeModelOption.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePullRequestGroups_lower(_ value: PullRequestGroups) -> RustBuffer {
-    return FfiConverterTypePullRequestGroups.lower(value)
+public func FfiConverterTypeModelOption_lower(_ value: ModelOption) -> RustBuffer {
+    return FfiConverterTypeModelOption.lower(value)
 }
 
 
-/**
- * Which session notifications this device wants.
- */
-public struct PushPrefs: Equatable, Hashable {
-    public var done: Bool
-    public var input: Bool
-    public var failed: Bool
+public struct ModelOptionChoice: Equatable, Hashable {
+    public var id: String
+    public var label: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(done: Bool, input: Bool, failed: Bool) {
-        self.done = done
-        self.input = input
-        self.failed = failed
+    public init(id: String, label: String) {
+        self.id = id
+        self.label = label
     }
 
     
@@ -6507,26 +6911,24 @@ public struct PushPrefs: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension PushPrefs: Sendable {}
+extension ModelOptionChoice: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypePushPrefs: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PushPrefs {
+public struct FfiConverterTypeModelOptionChoice: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ModelOptionChoice {
         return
-            try PushPrefs(
-                done: FfiConverterBool.read(from: &buf), 
-                input: FfiConverterBool.read(from: &buf), 
-                failed: FfiConverterBool.read(from: &buf)
+            try ModelOptionChoice(
+                id: FfiConverterString.read(from: &buf), 
+                label: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: PushPrefs, into buf: inout [UInt8]) {
-        FfiConverterBool.write(value.done, into: &buf)
-        FfiConverterBool.write(value.input, into: &buf)
-        FfiConverterBool.write(value.failed, into: &buf)
+    public static func write(_ value: ModelOptionChoice, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.label, into: &buf)
     }
 }
 
@@ -6534,39 +6936,45 @@ public struct FfiConverterTypePushPrefs: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePushPrefs_lift(_ buf: RustBuffer) throws -> PushPrefs {
-    return try FfiConverterTypePushPrefs.lift(buf)
+public func FfiConverterTypeModelOptionChoice_lift(_ buf: RustBuffer) throws -> ModelOptionChoice {
+    return try FfiConverterTypeModelOptionChoice.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePushPrefs_lower(_ value: PushPrefs) -> RustBuffer {
-    return FfiConverterTypePushPrefs.lower(value)
+public func FfiConverterTypeModelOptionChoice_lower(_ value: ModelOptionChoice) -> RustBuffer {
+    return FfiConverterTypeModelOptionChoice.lower(value)
 }
 
 
-public struct QueueEditLease: Equatable, Hashable {
-    public var rowId: String
-    public var leaseId: String
+public struct NewSession: Equatable, Hashable {
+    public var target: SessionTarget
+    public var config: ChatConfig?
     /**
-     * Row text at lease time.
+     * Branch stamped from the first frame (picked ref).
      */
-    public var text: String
-    public var baseTextHash: String
-    public var expiresAtMs: Int64
+    public var branch: String?
+    /**
+     * Checkout override (an existing worktree's path).
+     */
+    public var cwd: String?
+    public var title: String?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(rowId: String, leaseId: String, 
+    public init(target: SessionTarget, config: ChatConfig?, 
         /**
-         * Row text at lease time.
-         */text: String, baseTextHash: String, expiresAtMs: Int64) {
-        self.rowId = rowId
-        self.leaseId = leaseId
-        self.text = text
-        self.baseTextHash = baseTextHash
-        self.expiresAtMs = expiresAtMs
+         * Branch stamped from the first frame (picked ref).
+         */branch: String?, 
+        /**
+         * Checkout override (an existing worktree's path).
+         */cwd: String?, title: String?) {
+        self.target = target
+        self.config = config
+        self.branch = branch
+        self.cwd = cwd
+        self.title = title
     }
 
     
@@ -6575,30 +6983,30 @@ public struct QueueEditLease: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension QueueEditLease: Sendable {}
+extension NewSession: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeQueueEditLease: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditLease {
+public struct FfiConverterTypeNewSession: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NewSession {
         return
-            try QueueEditLease(
-                rowId: FfiConverterString.read(from: &buf), 
-                leaseId: FfiConverterString.read(from: &buf), 
-                text: FfiConverterString.read(from: &buf), 
-                baseTextHash: FfiConverterString.read(from: &buf), 
-                expiresAtMs: FfiConverterInt64.read(from: &buf)
+            try NewSession(
+                target: FfiConverterTypeSessionTarget.read(from: &buf), 
+                config: FfiConverterOptionTypeChatConfig.read(from: &buf), 
+                branch: FfiConverterOptionString.read(from: &buf), 
+                cwd: FfiConverterOptionString.read(from: &buf), 
+                title: FfiConverterOptionString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: QueueEditLease, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.rowId, into: &buf)
-        FfiConverterString.write(value.leaseId, into: &buf)
-        FfiConverterString.write(value.text, into: &buf)
-        FfiConverterString.write(value.baseTextHash, into: &buf)
-        FfiConverterInt64.write(value.expiresAtMs, into: &buf)
+    public static func write(_ value: NewSession, into buf: inout [UInt8]) {
+        FfiConverterTypeSessionTarget.write(value.target, into: &buf)
+        FfiConverterOptionTypeChatConfig.write(value.config, into: &buf)
+        FfiConverterOptionString.write(value.branch, into: &buf)
+        FfiConverterOptionString.write(value.cwd, into: &buf)
+        FfiConverterOptionString.write(value.title, into: &buf)
     }
 }
 
@@ -6606,63 +7014,35 @@ public struct FfiConverterTypeQueueEditLease: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditLease_lift(_ buf: RustBuffer) throws -> QueueEditLease {
-    return try FfiConverterTypeQueueEditLease.lift(buf)
+public func FfiConverterTypeNewSession_lift(_ buf: RustBuffer) throws -> NewSession {
+    return try FfiConverterTypeNewSession.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditLease_lower(_ value: QueueEditLease) -> RustBuffer {
-    return FfiConverterTypeQueueEditLease.lower(value)
+public func FfiConverterTypeNewSession_lower(_ value: NewSession) -> RustBuffer {
+    return FfiConverterTypeNewSession.lower(value)
 }
 
 
-public struct QueueItem: Equatable, Hashable {
-    public var id: String
-    /**
-     * Raw row text (what the host will send).
-     */
-    public var text: String
-    /**
-     * User-visible text (trailer/Appshot context stripped).
-     */
-    public var visibleText: String
-    public var attachments: [String]
-    public var holdForTurnEnd: Bool
-    public var issuedBy: String
-    public var fromThisDevice: Bool
-    public var issuedAtMs: Int64
-    public var editedAtMs: Int64?
-    public var gate: QueueGate?
+public struct OrbFrame: Equatable, Hashable {
     /**
-     * A Send-now / Remove is awaiting the host's acknowledgement.
+     * Edge length of the artwork box, in logical points.
      */
-    public var actionPending: Bool
+    public var size: Float
+    public var lines: [Float]
+    public var dots: [Float]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, 
-        /**
-         * Raw row text (what the host will send).
-         */text: String, 
-        /**
-         * User-visible text (trailer/Appshot context stripped).
-         */visibleText: String, attachments: [String], holdForTurnEnd: Bool, issuedBy: String, fromThisDevice: Bool, issuedAtMs: Int64, editedAtMs: Int64?, gate: QueueGate?, 
+    public init(
         /**
-         * A Send-now / Remove is awaiting the host's acknowledgement.
-         */actionPending: Bool) {
-        self.id = id
-        self.text = text
-        self.visibleText = visibleText
-        self.attachments = attachments
-        self.holdForTurnEnd = holdForTurnEnd
-        self.issuedBy = issuedBy
-        self.fromThisDevice = fromThisDevice
-        self.issuedAtMs = issuedAtMs
-        self.editedAtMs = editedAtMs
-        self.gate = gate
-        self.actionPending = actionPending
+         * Edge length of the artwork box, in logical points.
+         */size: Float, lines: [Float], dots: [Float]) {
+        self.size = size
+        self.lines = lines
+        self.dots = dots
     }
 
     
@@ -6671,42 +7051,26 @@ public struct QueueItem: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension QueueItem: Sendable {}
+extension OrbFrame: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeQueueItem: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueItem {
+public struct FfiConverterTypeOrbFrame: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OrbFrame {
         return
-            try QueueItem(
-                id: FfiConverterString.read(from: &buf), 
-                text: FfiConverterString.read(from: &buf), 
-                visibleText: FfiConverterString.read(from: &buf), 
-                attachments: FfiConverterSequenceString.read(from: &buf), 
-                holdForTurnEnd: FfiConverterBool.read(from: &buf), 
-                issuedBy: FfiConverterString.read(from: &buf), 
-                fromThisDevice: FfiConverterBool.read(from: &buf), 
-                issuedAtMs: FfiConverterInt64.read(from: &buf), 
-                editedAtMs: FfiConverterOptionInt64.read(from: &buf), 
-                gate: FfiConverterOptionTypeQueueGate.read(from: &buf), 
-                actionPending: FfiConverterBool.read(from: &buf)
+            try OrbFrame(
+                size: FfiConverterFloat.read(from: &buf), 
+                lines: FfiConverterSequenceFloat.read(from: &buf), 
+                dots: FfiConverterSequenceFloat.read(from: &buf)
         )
     }
 
-    public static func write(_ value: QueueItem, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.text, into: &buf)
-        FfiConverterString.write(value.visibleText, into: &buf)
-        FfiConverterSequenceString.write(value.attachments, into: &buf)
-        FfiConverterBool.write(value.holdForTurnEnd, into: &buf)
-        FfiConverterString.write(value.issuedBy, into: &buf)
-        FfiConverterBool.write(value.fromThisDevice, into: &buf)
-        FfiConverterInt64.write(value.issuedAtMs, into: &buf)
-        FfiConverterOptionInt64.write(value.editedAtMs, into: &buf)
-        FfiConverterOptionTypeQueueGate.write(value.gate, into: &buf)
-        FfiConverterBool.write(value.actionPending, into: &buf)
+    public static func write(_ value: OrbFrame, into buf: inout [UInt8]) {
+        FfiConverterFloat.write(value.size, into: &buf)
+        FfiConverterSequenceFloat.write(value.lines, into: &buf)
+        FfiConverterSequenceFloat.write(value.dots, into: &buf)
     }
 }
 
@@ -6714,41 +7078,29 @@ public struct FfiConverterTypeQueueItem: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueItem_lift(_ buf: RustBuffer) throws -> QueueItem {
-    return try FfiConverterTypeQueueItem.lift(buf)
+public func FfiConverterTypeOrbFrame_lift(_ buf: RustBuffer) throws -> OrbFrame {
+    return try FfiConverterTypeOrbFrame.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueItem_lower(_ value: QueueItem) -> RustBuffer {
-    return FfiConverterTypeQueueItem.lower(value)
+public func FfiConverterTypeOrbFrame_lower(_ value: OrbFrame) -> RustBuffer {
+    return FfiConverterTypeOrbFrame.lower(value)
 }
 
 
-public struct RepoRef: Equatable, Hashable {
+public struct OutgoingAttachment: Equatable, Hashable {
     public var name: String
-    /**
-     * Checked out in the repo's main folder right now.
-     */
-    public var current: Bool
-    /**
-     * Linked worktree this branch is checked out in, if any.
-     */
-    public var worktreePath: String?
+    public var mimeType: String
+    public var data: Data
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(name: String, 
-        /**
-         * Checked out in the repo's main folder right now.
-         */current: Bool, 
-        /**
-         * Linked worktree this branch is checked out in, if any.
-         */worktreePath: String?) {
+    public init(name: String, mimeType: String, data: Data) {
         self.name = name
-        self.current = current
-        self.worktreePath = worktreePath
+        self.mimeType = mimeType
+        self.data = data
     }
 
     
@@ -6757,26 +7109,26 @@ public struct RepoRef: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension RepoRef: Sendable {}
+extension OutgoingAttachment: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeRepoRef: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RepoRef {
+public struct FfiConverterTypeOutgoingAttachment: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OutgoingAttachment {
         return
-            try RepoRef(
+            try OutgoingAttachment(
                 name: FfiConverterString.read(from: &buf), 
-                current: FfiConverterBool.read(from: &buf), 
-                worktreePath: FfiConverterOptionString.read(from: &buf)
+                mimeType: FfiConverterString.read(from: &buf), 
+                data: FfiConverterData.read(from: &buf)
         )
     }
 
-    public static func write(_ value: RepoRef, into buf: inout [UInt8]) {
+    public static func write(_ value: OutgoingAttachment, into buf: inout [UInt8]) {
         FfiConverterString.write(value.name, into: &buf)
-        FfiConverterBool.write(value.current, into: &buf)
-        FfiConverterOptionString.write(value.worktreePath, into: &buf)
+        FfiConverterString.write(value.mimeType, into: &buf)
+        FfiConverterData.write(value.data, into: &buf)
     }
 }
 
@@ -6784,35 +7136,33 @@ public struct FfiConverterTypeRepoRef: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRepoRef_lift(_ buf: RustBuffer) throws -> RepoRef {
-    return try FfiConverterTypeRepoRef.lift(buf)
+public func FfiConverterTypeOutgoingAttachment_lift(_ buf: RustBuffer) throws -> OutgoingAttachment {
+    return try FfiConverterTypeOutgoingAttachment.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRepoRef_lower(_ value: RepoRef) -> RustBuffer {
-    return FfiConverterTypeRepoRef.lower(value)
+public func FfiConverterTypeOutgoingAttachment_lower(_ value: OutgoingAttachment) -> RustBuffer {
+    return FfiConverterTypeOutgoingAttachment.lower(value)
 }
 
 
-public struct RoomState: Equatable, Hashable {
-    public var connected: Bool
-    public var retryAtMs: Int64?
+public struct ParsedUserMessage: Equatable, Hashable {
     /**
-     * Graced degradation for this chat.
+     * Visible prompt (trailer + Appshot context stripped).
      */
-    public var degraded: Bool
+    public var text: String
+    public var images: [UserImage]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(connected: Bool, retryAtMs: Int64?, 
+    public init(
         /**
-         * Graced degradation for this chat.
-         */degraded: Bool) {
-        self.connected = connected
-        self.retryAtMs = retryAtMs
-        self.degraded = degraded
+         * Visible prompt (trailer + Appshot context stripped).
+         */text: String, images: [UserImage]) {
+        self.text = text
+        self.images = images
     }
 
     
@@ -6821,26 +7171,24 @@ public struct RoomState: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension RoomState: Sendable {}
+extension ParsedUserMessage: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeRoomState: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RoomState {
+public struct FfiConverterTypeParsedUserMessage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ParsedUserMessage {
         return
-            try RoomState(
-                connected: FfiConverterBool.read(from: &buf), 
-                retryAtMs: FfiConverterOptionInt64.read(from: &buf), 
-                degraded: FfiConverterBool.read(from: &buf)
+            try ParsedUserMessage(
+                text: FfiConverterString.read(from: &buf), 
+                images: FfiConverterSequenceTypeUserImage.read(from: &buf)
         )
     }
 
-    public static func write(_ value: RoomState, into buf: inout [UInt8]) {
-        FfiConverterBool.write(value.connected, into: &buf)
-        FfiConverterOptionInt64.write(value.retryAtMs, into: &buf)
-        FfiConverterBool.write(value.degraded, into: &buf)
+    public static func write(_ value: ParsedUserMessage, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterSequenceTypeUserImage.write(value.images, into: &buf)
     }
 }
 
@@ -6848,56 +7196,49 @@ public struct FfiConverterTypeRoomState: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRoomState_lift(_ buf: RustBuffer) throws -> RoomState {
-    return try FfiConverterTypeRoomState.lift(buf)
+public func FfiConverterTypeParsedUserMessage_lift(_ buf: RustBuffer) throws -> ParsedUserMessage {
+    return try FfiConverterTypeParsedUserMessage.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRoomState_lower(_ value: RoomState) -> RustBuffer {
-    return FfiConverterTypeRoomState.lower(value)
+public func FfiConverterTypeParsedUserMessage_lower(_ value: ParsedUserMessage) -> RustBuffer {
+    return FfiConverterTypeParsedUserMessage.lower(value)
 }
 
 
-/**
- * Everything needed to paint a row at its current width.
- */
-public struct RowDisplay: Equatable, Hashable {
-    public var key: UInt64
-    public var version: UInt64
-    public var width: Float
-    public var height: Float
-    public var text: String
-    public var runs: [TextRun]
-    public var boxes: [BoxPrim]
-    public var links: [LinkHit]
-    public var scrollers: [Scroller]
-    public var widgets: [Widget]
-    public var fades: [Fade]
+public struct PendingSend: Equatable, Hashable {
     /**
-     * Plain text for copy / accessibility.
+     * Client-minted id (the host's user entry reuses it).
      */
-    public var copyText: String
+    public var messageId: String
+    /**
+     * Raw content (attachment trailer included).
+     */
+    public var text: String
+    public var visibleText: String
+    public var images: [String]
+    public var kind: PendingKind
+    public var sentAtMs: Int64
+    public var state: SendState
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(key: UInt64, version: UInt64, width: Float, height: Float, text: String, runs: [TextRun], boxes: [BoxPrim], links: [LinkHit], scrollers: [Scroller], widgets: [Widget], fades: [Fade], 
+    public init(
         /**
-         * Plain text for copy / accessibility.
-         */copyText: String) {
-        self.key = key
-        self.version = version
-        self.width = width
-        self.height = height
+         * Client-minted id (the host's user entry reuses it).
+         */messageId: String, 
+        /**
+         * Raw content (attachment trailer included).
+         */text: String, visibleText: String, images: [String], kind: PendingKind, sentAtMs: Int64, state: SendState) {
+        self.messageId = messageId
         self.text = text
-        self.runs = runs
-        self.boxes = boxes
-        self.links = links
-        self.scrollers = scrollers
-        self.widgets = widgets
-        self.fades = fades
-        self.copyText = copyText
+        self.visibleText = visibleText
+        self.images = images
+        self.kind = kind
+        self.sentAtMs = sentAtMs
+        self.state = state
     }
 
     
@@ -6906,44 +7247,34 @@ public struct RowDisplay: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension RowDisplay: Sendable {}
+extension PendingSend: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeRowDisplay: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RowDisplay {
+public struct FfiConverterTypePendingSend: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PendingSend {
         return
-            try RowDisplay(
-                key: FfiConverterUInt64.read(from: &buf), 
-                version: FfiConverterUInt64.read(from: &buf), 
-                width: FfiConverterFloat.read(from: &buf), 
-                height: FfiConverterFloat.read(from: &buf), 
+            try PendingSend(
+                messageId: FfiConverterString.read(from: &buf), 
                 text: FfiConverterString.read(from: &buf), 
-                runs: FfiConverterSequenceTypeTextRun.read(from: &buf), 
-                boxes: FfiConverterSequenceTypeBoxPrim.read(from: &buf), 
-                links: FfiConverterSequenceTypeLinkHit.read(from: &buf), 
-                scrollers: FfiConverterSequenceTypeScroller.read(from: &buf), 
-                widgets: FfiConverterSequenceTypeWidget.read(from: &buf), 
-                fades: FfiConverterSequenceTypeFade.read(from: &buf), 
-                copyText: FfiConverterString.read(from: &buf)
+                visibleText: FfiConverterString.read(from: &buf), 
+                images: FfiConverterSequenceString.read(from: &buf), 
+                kind: FfiConverterTypePendingKind.read(from: &buf), 
+                sentAtMs: FfiConverterInt64.read(from: &buf), 
+                state: FfiConverterTypeSendState.read(from: &buf)
         )
     }
 
-    public static func write(_ value: RowDisplay, into buf: inout [UInt8]) {
-        FfiConverterUInt64.write(value.key, into: &buf)
-        FfiConverterUInt64.write(value.version, into: &buf)
-        FfiConverterFloat.write(value.width, into: &buf)
-        FfiConverterFloat.write(value.height, into: &buf)
+    public static func write(_ value: PendingSend, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.messageId, into: &buf)
         FfiConverterString.write(value.text, into: &buf)
-        FfiConverterSequenceTypeTextRun.write(value.runs, into: &buf)
-        FfiConverterSequenceTypeBoxPrim.write(value.boxes, into: &buf)
-        FfiConverterSequenceTypeLinkHit.write(value.links, into: &buf)
-        FfiConverterSequenceTypeScroller.write(value.scrollers, into: &buf)
-        FfiConverterSequenceTypeWidget.write(value.widgets, into: &buf)
-        FfiConverterSequenceTypeFade.write(value.fades, into: &buf)
-        FfiConverterString.write(value.copyText, into: &buf)
+        FfiConverterString.write(value.visibleText, into: &buf)
+        FfiConverterSequenceString.write(value.images, into: &buf)
+        FfiConverterTypePendingKind.write(value.kind, into: &buf)
+        FfiConverterInt64.write(value.sentAtMs, into: &buf)
+        FfiConverterTypeSendState.write(value.state, into: &buf)
     }
 }
 
@@ -6951,44 +7282,35 @@ public struct FfiConverterTypeRowDisplay: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRowDisplay_lift(_ buf: RustBuffer) throws -> RowDisplay {
-    return try FfiConverterTypeRowDisplay.lift(buf)
+public func FfiConverterTypePendingSend_lift(_ buf: RustBuffer) throws -> PendingSend {
+    return try FfiConverterTypePendingSend.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRowDisplay_lower(_ value: RowDisplay) -> RustBuffer {
-    return FfiConverterTypeRowDisplay.lower(value)
+public func FfiConverterTypePendingSend_lower(_ value: PendingSend) -> RustBuffer {
+    return FfiConverterTypePendingSend.lower(value)
 }
 
 
-/**
- * A row's position in a frame.
- */
-public struct RowPlacement: Equatable, Hashable {
-    public var index: UInt32
-    public var key: UInt64
+public struct ProjectRef: Equatable, Hashable {
+    public var id: String
+    public var name: String
     /**
-     * Changes whenever the row's painted content may change (not its width).
+     * Stable palette slot (0..PROJECT_COLOR_COUNT).
      */
-    public var version: UInt64
-    public var y: Float
-    public var height: Float
-    public var kind: RowKind
+    public var colorIndex: UInt32
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(index: UInt32, key: UInt64, 
+    public init(id: String, name: String, 
         /**
-         * Changes whenever the row's painted content may change (not its width).
-         */version: UInt64, y: Float, height: Float, kind: RowKind) {
-        self.index = index
-        self.key = key
-        self.version = version
-        self.y = y
-        self.height = height
-        self.kind = kind
+         * Stable palette slot (0..PROJECT_COLOR_COUNT).
+         */colorIndex: UInt32) {
+        self.id = id
+        self.name = name
+        self.colorIndex = colorIndex
     }
 
     
@@ -6997,32 +7319,26 @@ public struct RowPlacement: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension RowPlacement: Sendable {}
+extension ProjectRef: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeRowPlacement: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RowPlacement {
+public struct FfiConverterTypeProjectRef: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProjectRef {
         return
-            try RowPlacement(
-                index: FfiConverterUInt32.read(from: &buf), 
-                key: FfiConverterUInt64.read(from: &buf), 
-                version: FfiConverterUInt64.read(from: &buf), 
-                y: FfiConverterFloat.read(from: &buf), 
-                height: FfiConverterFloat.read(from: &buf), 
-                kind: FfiConverterTypeRowKind.read(from: &buf)
+            try ProjectRef(
+                id: FfiConverterString.read(from: &buf), 
+                name: FfiConverterString.read(from: &buf), 
+                colorIndex: FfiConverterUInt32.read(from: &buf)
         )
     }
 
-    public static func write(_ value: RowPlacement, into buf: inout [UInt8]) {
-        FfiConverterUInt32.write(value.index, into: &buf)
-        FfiConverterUInt64.write(value.key, into: &buf)
-        FfiConverterUInt64.write(value.version, into: &buf)
-        FfiConverterFloat.write(value.y, into: &buf)
-        FfiConverterFloat.write(value.height, into: &buf)
-        FfiConverterTypeRowKind.write(value.kind, into: &buf)
+    public static func write(_ value: ProjectRef, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterUInt32.write(value.colorIndex, into: &buf)
     }
 }
 
@@ -7030,70 +7346,125 @@ public struct FfiConverterTypeRowPlacement: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRowPlacement_lift(_ buf: RustBuffer) throws -> RowPlacement {
-    return try FfiConverterTypeRowPlacement.lift(buf)
+public func FfiConverterTypeProjectRef_lift(_ buf: RustBuffer) throws -> ProjectRef {
+    return try FfiConverterTypeProjectRef.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRowPlacement_lower(_ value: RowPlacement) -> RustBuffer {
-    return FfiConverterTypeRowPlacement.lower(value)
+public func FfiConverterTypeProjectRef_lower(_ value: ProjectRef) -> RustBuffer {
+    return FfiConverterTypeProjectRef.lower(value)
 }
 
 
-/**
- * A horizontally scrolling viewport (code blocks, wide tables). Primitives
- * that reference it are positioned in its content coordinates, whose origin
- * is the viewport's top-left.
- */
-public struct Scroller: Equatable, Hashable {
-    public var x: Float
-    public var y: Float
-    public var w: Float
-    public var h: Float
-    public var contentWidth: Float
-
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(x: Float, y: Float, w: Float, h: Float, contentWidth: Float) {
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.contentWidth = contentWidth
-    }
-
-    
-
-    
-}
-
-#if compiler(>=6)
-extension Scroller: Sendable {}
-#endif
+public struct ProjectView: Equatable, Hashable {
+    public var id: String
+    public var name: String
+    public var path: String
+    public var colorIndex: UInt32
+    public var deviceId: String
+    public var deviceName: String?
+    public var deviceOnline: Bool
+    public var gitDetected: Bool
+    public var createdAtMs: Int64
+    /**
+     * Shared by every checkout of one repository, on any device.
+     */
+    public var groupKey: String
+    /**
+     * The repository group's name, shared like `color_index`.
+     */
+    public var groupName: String
+    /**
+     * Most urgent indicator among its active sessions.
+     */
+    public var indicator: ChatIndicator
+    public var unseenCount: UInt32
+    /**
+     * Active sessions, recency order.
+     */
+    public var sessions: [SessionRow]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(id: String, name: String, path: String, colorIndex: UInt32, deviceId: String, deviceName: String?, deviceOnline: Bool, gitDetected: Bool, createdAtMs: Int64, 
+        /**
+         * Shared by every checkout of one repository, on any device.
+         */groupKey: String, 
+        /**
+         * The repository group's name, shared like `color_index`.
+         */groupName: String, 
+        /**
+         * Most urgent indicator among its active sessions.
+         */indicator: ChatIndicator, unseenCount: UInt32, 
+        /**
+         * Active sessions, recency order.
+         */sessions: [SessionRow]) {
+        self.id = id
+        self.name = name
+        self.path = path
+        self.colorIndex = colorIndex
+        self.deviceId = deviceId
+        self.deviceName = deviceName
+        self.deviceOnline = deviceOnline
+        self.gitDetected = gitDetected
+        self.createdAtMs = createdAtMs
+        self.groupKey = groupKey
+        self.groupName = groupName
+        self.indicator = indicator
+        self.unseenCount = unseenCount
+        self.sessions = sessions
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension ProjectView: Sendable {}
+#endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeScroller: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Scroller {
+public struct FfiConverterTypeProjectView: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProjectView {
         return
-            try Scroller(
-                x: FfiConverterFloat.read(from: &buf), 
-                y: FfiConverterFloat.read(from: &buf), 
-                w: FfiConverterFloat.read(from: &buf), 
-                h: FfiConverterFloat.read(from: &buf), 
-                contentWidth: FfiConverterFloat.read(from: &buf)
+            try ProjectView(
+                id: FfiConverterString.read(from: &buf), 
+                name: FfiConverterString.read(from: &buf), 
+                path: FfiConverterString.read(from: &buf), 
+                colorIndex: FfiConverterUInt32.read(from: &buf), 
+                deviceId: FfiConverterString.read(from: &buf), 
+                deviceName: FfiConverterOptionString.read(from: &buf), 
+                deviceOnline: FfiConverterBool.read(from: &buf), 
+                gitDetected: FfiConverterBool.read(from: &buf), 
+                createdAtMs: FfiConverterInt64.read(from: &buf), 
+                groupKey: FfiConverterString.read(from: &buf), 
+                groupName: FfiConverterString.read(from: &buf), 
+                indicator: FfiConverterTypeChatIndicator.read(from: &buf), 
+                unseenCount: FfiConverterUInt32.read(from: &buf), 
+                sessions: FfiConverterSequenceTypeSessionRow.read(from: &buf)
         )
     }
 
-    public static func write(_ value: Scroller, into buf: inout [UInt8]) {
-        FfiConverterFloat.write(value.x, into: &buf)
-        FfiConverterFloat.write(value.y, into: &buf)
-        FfiConverterFloat.write(value.w, into: &buf)
-        FfiConverterFloat.write(value.h, into: &buf)
-        FfiConverterFloat.write(value.contentWidth, into: &buf)
+    public static func write(_ value: ProjectView, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterString.write(value.path, into: &buf)
+        FfiConverterUInt32.write(value.colorIndex, into: &buf)
+        FfiConverterString.write(value.deviceId, into: &buf)
+        FfiConverterOptionString.write(value.deviceName, into: &buf)
+        FfiConverterBool.write(value.deviceOnline, into: &buf)
+        FfiConverterBool.write(value.gitDetected, into: &buf)
+        FfiConverterInt64.write(value.createdAtMs, into: &buf)
+        FfiConverterString.write(value.groupKey, into: &buf)
+        FfiConverterString.write(value.groupName, into: &buf)
+        FfiConverterTypeChatIndicator.write(value.indicator, into: &buf)
+        FfiConverterUInt32.write(value.unseenCount, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.sessions, into: &buf)
     }
 }
 
@@ -7101,35 +7472,37 @@ public struct FfiConverterTypeScroller: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeScroller_lift(_ buf: RustBuffer) throws -> Scroller {
-    return try FfiConverterTypeScroller.lift(buf)
+public func FfiConverterTypeProjectView_lift(_ buf: RustBuffer) throws -> ProjectView {
+    return try FfiConverterTypeProjectView.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeScroller_lower(_ value: Scroller) -> RustBuffer {
-    return FfiConverterTypeScroller.lower(value)
+public func FfiConverterTypeProjectView_lower(_ value: ProjectView) -> RustBuffer {
+    return FfiConverterTypeProjectView.lower(value)
 }
 
 
-public struct SearchHit: Equatable, Hashable {
-    public var session: SessionRow
-    public var score: UInt32
-    /**
-     * The strongest field that matched.
-     */
-    public var field: SearchField
+public struct PullRequest: Equatable, Hashable {
+    public var provider: String
+    public var number: UInt64
+    public var title: String
+    public var url: String
+    public var state: PullRequestState
+    public var baseRef: String
+    public var headRef: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(session: SessionRow, score: UInt32, 
-        /**
-         * The strongest field that matched.
-         */field: SearchField) {
-        self.session = session
-        self.score = score
-        self.field = field
+    public init(provider: String, number: UInt64, title: String, url: String, state: PullRequestState, baseRef: String, headRef: String) {
+        self.provider = provider
+        self.number = number
+        self.title = title
+        self.url = url
+        self.state = state
+        self.baseRef = baseRef
+        self.headRef = headRef
     }
 
     
@@ -7138,26 +7511,34 @@ public struct SearchHit: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SearchHit: Sendable {}
+extension PullRequest: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSearchHit: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SearchHit {
+public struct FfiConverterTypePullRequest: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PullRequest {
         return
-            try SearchHit(
-                session: FfiConverterTypeSessionRow.read(from: &buf), 
-                score: FfiConverterUInt32.read(from: &buf), 
-                field: FfiConverterTypeSearchField.read(from: &buf)
+            try PullRequest(
+                provider: FfiConverterString.read(from: &buf), 
+                number: FfiConverterUInt64.read(from: &buf), 
+                title: FfiConverterString.read(from: &buf), 
+                url: FfiConverterString.read(from: &buf), 
+                state: FfiConverterTypePullRequestState.read(from: &buf), 
+                baseRef: FfiConverterString.read(from: &buf), 
+                headRef: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: SearchHit, into buf: inout [UInt8]) {
-        FfiConverterTypeSessionRow.write(value.session, into: &buf)
-        FfiConverterUInt32.write(value.score, into: &buf)
-        FfiConverterTypeSearchField.write(value.field, into: &buf)
+    public static func write(_ value: PullRequest, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.provider, into: &buf)
+        FfiConverterUInt64.write(value.number, into: &buf)
+        FfiConverterString.write(value.title, into: &buf)
+        FfiConverterString.write(value.url, into: &buf)
+        FfiConverterTypePullRequestState.write(value.state, into: &buf)
+        FfiConverterString.write(value.baseRef, into: &buf)
+        FfiConverterString.write(value.headRef, into: &buf)
     }
 }
 
@@ -7165,37 +7546,29 @@ public struct FfiConverterTypeSearchHit: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSearchHit_lift(_ buf: RustBuffer) throws -> SearchHit {
-    return try FfiConverterTypeSearchHit.lift(buf)
+public func FfiConverterTypePullRequest_lift(_ buf: RustBuffer) throws -> PullRequest {
+    return try FfiConverterTypePullRequest.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSearchHit_lower(_ value: SearchHit) -> RustBuffer {
-    return FfiConverterTypeSearchHit.lower(value)
+public func FfiConverterTypePullRequest_lower(_ value: PullRequest) -> RustBuffer {
+    return FfiConverterTypePullRequest.lower(value)
 }
 
 
-public struct SectionView: Equatable, Hashable {
-    public var id: String
-    public var name: String
-    public var collapsed: Bool
-    /**
-     * Recency order (pinned sessions excluded).
-     */
-    public var sessions: [SessionRow]
+public struct PullRequestGroups: Equatable, Hashable {
+    public var `open`: [SessionRow]
+    public var merged: [SessionRow]
+    public var closed: [SessionRow]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, name: String, collapsed: Bool, 
-        /**
-         * Recency order (pinned sessions excluded).
-         */sessions: [SessionRow]) {
-        self.id = id
-        self.name = name
-        self.collapsed = collapsed
-        self.sessions = sessions
+    public init(`open`: [SessionRow], merged: [SessionRow], closed: [SessionRow]) {
+        self.`open` = `open`
+        self.merged = merged
+        self.closed = closed
     }
 
     
@@ -7204,28 +7577,26 @@ public struct SectionView: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SectionView: Sendable {}
+extension PullRequestGroups: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSectionView: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SectionView {
+public struct FfiConverterTypePullRequestGroups: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PullRequestGroups {
         return
-            try SectionView(
-                id: FfiConverterString.read(from: &buf), 
-                name: FfiConverterString.read(from: &buf), 
-                collapsed: FfiConverterBool.read(from: &buf), 
-                sessions: FfiConverterSequenceTypeSessionRow.read(from: &buf)
+            try PullRequestGroups(
+                open: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
+                merged: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
+                closed: FfiConverterSequenceTypeSessionRow.read(from: &buf)
         )
     }
 
-    public static func write(_ value: SectionView, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterBool.write(value.collapsed, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.sessions, into: &buf)
+    public static func write(_ value: PullRequestGroups, into buf: inout [UInt8]) {
+        FfiConverterSequenceTypeSessionRow.write(value.`open`, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.merged, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.closed, into: &buf)
     }
 }
 
@@ -7233,37 +7604,32 @@ public struct FfiConverterTypeSectionView: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSectionView_lift(_ buf: RustBuffer) throws -> SectionView {
-    return try FfiConverterTypeSectionView.lift(buf)
+public func FfiConverterTypePullRequestGroups_lift(_ buf: RustBuffer) throws -> PullRequestGroups {
+    return try FfiConverterTypePullRequestGroups.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSectionView_lower(_ value: SectionView) -> RustBuffer {
-    return FfiConverterTypeSectionView.lower(value)
+public func FfiConverterTypePullRequestGroups_lower(_ value: PullRequestGroups) -> RustBuffer {
+    return FfiConverterTypePullRequestGroups.lower(value)
 }
 
 
-public struct SendRequest: Equatable, Hashable {
-    public var text: String
-    public var attachments: [OutgoingAttachment]
-    /**
-     * Isolated host worktree for this run (new-session "New worktree").
-     */
-    public var worktree: WorktreeSpec?
-    public var busy: BusyPolicy
-
-    // Default memberwise initializers are never public by default, so we
-    // declare one manually.
-    public init(text: String, attachments: [OutgoingAttachment], 
-        /**
-         * Isolated host worktree for this run (new-session "New worktree").
-         */worktree: WorktreeSpec?, busy: BusyPolicy) {
-        self.text = text
-        self.attachments = attachments
-        self.worktree = worktree
-        self.busy = busy
+/**
+ * Which session notifications this device wants.
+ */
+public struct PushPrefs: Equatable, Hashable {
+    public var done: Bool
+    public var input: Bool
+    public var failed: Bool
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(done: Bool, input: Bool, failed: Bool) {
+        self.done = done
+        self.input = input
+        self.failed = failed
     }
 
     
@@ -7272,28 +7638,26 @@ public struct SendRequest: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SendRequest: Sendable {}
+extension PushPrefs: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSendRequest: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SendRequest {
+public struct FfiConverterTypePushPrefs: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PushPrefs {
         return
-            try SendRequest(
-                text: FfiConverterString.read(from: &buf), 
-                attachments: FfiConverterSequenceTypeOutgoingAttachment.read(from: &buf), 
-                worktree: FfiConverterOptionTypeWorktreeSpec.read(from: &buf), 
-                busy: FfiConverterTypeBusyPolicy.read(from: &buf)
+            try PushPrefs(
+                done: FfiConverterBool.read(from: &buf), 
+                input: FfiConverterBool.read(from: &buf), 
+                failed: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: SendRequest, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.text, into: &buf)
-        FfiConverterSequenceTypeOutgoingAttachment.write(value.attachments, into: &buf)
-        FfiConverterOptionTypeWorktreeSpec.write(value.worktree, into: &buf)
-        FfiConverterTypeBusyPolicy.write(value.busy, into: &buf)
+    public static func write(_ value: PushPrefs, into buf: inout [UInt8]) {
+        FfiConverterBool.write(value.done, into: &buf)
+        FfiConverterBool.write(value.input, into: &buf)
+        FfiConverterBool.write(value.failed, into: &buf)
     }
 }
 
@@ -7301,152 +7665,39 @@ public struct FfiConverterTypeSendRequest: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSendRequest_lift(_ buf: RustBuffer) throws -> SendRequest {
-    return try FfiConverterTypeSendRequest.lift(buf)
+public func FfiConverterTypePushPrefs_lift(_ buf: RustBuffer) throws -> PushPrefs {
+    return try FfiConverterTypePushPrefs.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSendRequest_lower(_ value: SendRequest) -> RustBuffer {
-    return FfiConverterTypeSendRequest.lower(value)
+public func FfiConverterTypePushPrefs_lower(_ value: PushPrefs) -> RustBuffer {
+    return FfiConverterTypePushPrefs.lower(value)
 }
 
 
-/**
- * One session row, as every list renders it.
- */
-public struct SessionRow: Equatable, Hashable {
-    public var id: String
-    /**
-     * Content hash — equal ⇒ nothing to redraw.
-     */
-    public var revision: UInt64
-    /**
-     * Display title ("New session" when untitled).
-     */
-    public var title: String
-    public var hasTitle: Bool
-    public var preview: String?
-    /**
-     * `None` = projectless (host's home folder).
-     */
-    public var project: ProjectRef?
-    public var deviceId: String
-    public var deviceName: String?
-    public var deviceOnline: Bool
-    /**
-     * Wire harness id (`claude-code`).
-     */
-    public var harness: String?
-    public var harnessLabel: String?
-    public var model: String?
-    public var modelLabel: String?
-    /**
-     * Wire effort (`xhigh`).
-     */
-    public var reasoning: String?
-    public var branch: String?
-    public var cwd: String?
-    /**
-     * Staleness-gated (45s) live status; an in-flight send reads Working.
-     */
-    public var indicator: ChatIndicator
-    /**
-     * Host-reported status only (no local-send override).
-     */
-    public var hostIndicator: ChatIndicator
-    /**
-     * Run start of the live turn while Working/AwaitingInput.
-     */
-    public var workingSinceMs: Int64?
-    public var lastActivityMs: Int64
-    /**
-     * `now` / `34m` / `4h` / `2d` at derive time.
-     */
-    public var timeLabel: String
-    public var createdAtMs: Int64
-    public var unseen: Bool
-    public var archived: Bool
-    public var pinned: Bool
-    public var sectionId: String?
-    public var pullRequest: PullRequest?
-    /**
-     * Oldest unadopted send from this device (open sessions only).
-     */
-    public var sendState: SendState?
-    public var parentChatId: String?
+public struct QueueEditLease: Equatable, Hashable {
+    public var rowId: String
+    public var leaseId: String
     /**
-     * 2 = chat2; 1 = legacy (not dialable).
+     * Row text at lease time.
      */
-    public var roomGen: UInt32
+    public var text: String
+    public var baseTextHash: String
+    public var expiresAtMs: Int64
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, 
-        /**
-         * Content hash — equal ⇒ nothing to redraw.
-         */revision: UInt64, 
-        /**
-         * Display title ("New session" when untitled).
-         */title: String, hasTitle: Bool, preview: String?, 
-        /**
-         * `None` = projectless (host's home folder).
-         */project: ProjectRef?, deviceId: String, deviceName: String?, deviceOnline: Bool, 
-        /**
-         * Wire harness id (`claude-code`).
-         */harness: String?, harnessLabel: String?, model: String?, modelLabel: String?, 
-        /**
-         * Wire effort (`xhigh`).
-         */reasoning: String?, branch: String?, cwd: String?, 
-        /**
-         * Staleness-gated (45s) live status; an in-flight send reads Working.
-         */indicator: ChatIndicator, 
-        /**
-         * Host-reported status only (no local-send override).
-         */hostIndicator: ChatIndicator, 
-        /**
-         * Run start of the live turn while Working/AwaitingInput.
-         */workingSinceMs: Int64?, lastActivityMs: Int64, 
-        /**
-         * `now` / `34m` / `4h` / `2d` at derive time.
-         */timeLabel: String, createdAtMs: Int64, unseen: Bool, archived: Bool, pinned: Bool, sectionId: String?, pullRequest: PullRequest?, 
-        /**
-         * Oldest unadopted send from this device (open sessions only).
-         */sendState: SendState?, parentChatId: String?, 
+    public init(rowId: String, leaseId: String, 
         /**
-         * 2 = chat2; 1 = legacy (not dialable).
-         */roomGen: UInt32) {
-        self.id = id
-        self.revision = revision
-        self.title = title
-        self.hasTitle = hasTitle
-        self.preview = preview
-        self.project = project
-        self.deviceId = deviceId
-        self.deviceName = deviceName
-        self.deviceOnline = deviceOnline
-        self.harness = harness
-        self.harnessLabel = harnessLabel
-        self.model = model
-        self.modelLabel = modelLabel
-        self.reasoning = reasoning
-        self.branch = branch
-        self.cwd = cwd
-        self.indicator = indicator
-        self.hostIndicator = hostIndicator
-        self.workingSinceMs = workingSinceMs
-        self.lastActivityMs = lastActivityMs
-        self.timeLabel = timeLabel
-        self.createdAtMs = createdAtMs
-        self.unseen = unseen
-        self.archived = archived
-        self.pinned = pinned
-        self.sectionId = sectionId
-        self.pullRequest = pullRequest
-        self.sendState = sendState
-        self.parentChatId = parentChatId
-        self.roomGen = roomGen
+         * Row text at lease time.
+         */text: String, baseTextHash: String, expiresAtMs: Int64) {
+        self.rowId = rowId
+        self.leaseId = leaseId
+        self.text = text
+        self.baseTextHash = baseTextHash
+        self.expiresAtMs = expiresAtMs
     }
 
     
@@ -7455,80 +7706,30 @@ public struct SessionRow: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SessionRow: Sendable {}
+extension QueueEditLease: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSessionRow: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SessionRow {
+public struct FfiConverterTypeQueueEditLease: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditLease {
         return
-            try SessionRow(
-                id: FfiConverterString.read(from: &buf), 
-                revision: FfiConverterUInt64.read(from: &buf), 
-                title: FfiConverterString.read(from: &buf), 
-                hasTitle: FfiConverterBool.read(from: &buf), 
-                preview: FfiConverterOptionString.read(from: &buf), 
-                project: FfiConverterOptionTypeProjectRef.read(from: &buf), 
-                deviceId: FfiConverterString.read(from: &buf), 
-                deviceName: FfiConverterOptionString.read(from: &buf), 
-                deviceOnline: FfiConverterBool.read(from: &buf), 
-                harness: FfiConverterOptionString.read(from: &buf), 
-                harnessLabel: FfiConverterOptionString.read(from: &buf), 
-                model: FfiConverterOptionString.read(from: &buf), 
-                modelLabel: FfiConverterOptionString.read(from: &buf), 
-                reasoning: FfiConverterOptionString.read(from: &buf), 
-                branch: FfiConverterOptionString.read(from: &buf), 
-                cwd: FfiConverterOptionString.read(from: &buf), 
-                indicator: FfiConverterTypeChatIndicator.read(from: &buf), 
-                hostIndicator: FfiConverterTypeChatIndicator.read(from: &buf), 
-                workingSinceMs: FfiConverterOptionInt64.read(from: &buf), 
-                lastActivityMs: FfiConverterInt64.read(from: &buf), 
-                timeLabel: FfiConverterString.read(from: &buf), 
-                createdAtMs: FfiConverterInt64.read(from: &buf), 
-                unseen: FfiConverterBool.read(from: &buf), 
-                archived: FfiConverterBool.read(from: &buf), 
-                pinned: FfiConverterBool.read(from: &buf), 
-                sectionId: FfiConverterOptionString.read(from: &buf), 
-                pullRequest: FfiConverterOptionTypePullRequest.read(from: &buf), 
-                sendState: FfiConverterOptionTypeSendState.read(from: &buf), 
-                parentChatId: FfiConverterOptionString.read(from: &buf), 
-                roomGen: FfiConverterUInt32.read(from: &buf)
+            try QueueEditLease(
+                rowId: FfiConverterString.read(from: &buf), 
+                leaseId: FfiConverterString.read(from: &buf), 
+                text: FfiConverterString.read(from: &buf), 
+                baseTextHash: FfiConverterString.read(from: &buf), 
+                expiresAtMs: FfiConverterInt64.read(from: &buf)
         )
     }
 
-    public static func write(_ value: SessionRow, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterUInt64.write(value.revision, into: &buf)
-        FfiConverterString.write(value.title, into: &buf)
-        FfiConverterBool.write(value.hasTitle, into: &buf)
-        FfiConverterOptionString.write(value.preview, into: &buf)
-        FfiConverterOptionTypeProjectRef.write(value.project, into: &buf)
-        FfiConverterString.write(value.deviceId, into: &buf)
-        FfiConverterOptionString.write(value.deviceName, into: &buf)
-        FfiConverterBool.write(value.deviceOnline, into: &buf)
-        FfiConverterOptionString.write(value.harness, into: &buf)
-        FfiConverterOptionString.write(value.harnessLabel, into: &buf)
-        FfiConverterOptionString.write(value.model, into: &buf)
-        FfiConverterOptionString.write(value.modelLabel, into: &buf)
-        FfiConverterOptionString.write(value.reasoning, into: &buf)
-        FfiConverterOptionString.write(value.branch, into: &buf)
-        FfiConverterOptionString.write(value.cwd, into: &buf)
-        FfiConverterTypeChatIndicator.write(value.indicator, into: &buf)
-        FfiConverterTypeChatIndicator.write(value.hostIndicator, into: &buf)
-        FfiConverterOptionInt64.write(value.workingSinceMs, into: &buf)
-        FfiConverterInt64.write(value.lastActivityMs, into: &buf)
-        FfiConverterString.write(value.timeLabel, into: &buf)
-        FfiConverterInt64.write(value.createdAtMs, into: &buf)
-        FfiConverterBool.write(value.unseen, into: &buf)
-        FfiConverterBool.write(value.archived, into: &buf)
-        FfiConverterBool.write(value.pinned, into: &buf)
-        FfiConverterOptionString.write(value.sectionId, into: &buf)
-        FfiConverterOptionTypePullRequest.write(value.pullRequest, into: &buf)
-        FfiConverterOptionTypeSendState.write(value.sendState, into: &buf)
-        FfiConverterOptionString.write(value.parentChatId, into: &buf)
-        FfiConverterUInt32.write(value.roomGen, into: &buf)
+    public static func write(_ value: QueueEditLease, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.rowId, into: &buf)
+        FfiConverterString.write(value.leaseId, into: &buf)
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterString.write(value.baseTextHash, into: &buf)
+        FfiConverterInt64.write(value.expiresAtMs, into: &buf)
     }
 }
 
@@ -7536,34 +7737,63 @@ public struct FfiConverterTypeSessionRow: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSessionRow_lift(_ buf: RustBuffer) throws -> SessionRow {
-    return try FfiConverterTypeSessionRow.lift(buf)
+public func FfiConverterTypeQueueEditLease_lift(_ buf: RustBuffer) throws -> QueueEditLease {
+    return try FfiConverterTypeQueueEditLease.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSessionRow_lower(_ value: SessionRow) -> RustBuffer {
-    return FfiConverterTypeSessionRow.lower(value)
+public func FfiConverterTypeQueueEditLease_lower(_ value: QueueEditLease) -> RustBuffer {
+    return FfiConverterTypeQueueEditLease.lower(value)
 }
 
 
-/**
- * A style the platform must be able to draw: `id` → (face, size).
- */
-public struct StyleDesc: Equatable, Hashable {
-    public var id: UInt16
-    public var face: FaceRole
-    public var size: Float
-    public var ligatures: Bool
+public struct QueueItem: Equatable, Hashable {
+    public var id: String
+    /**
+     * Raw row text (what the host will send).
+     */
+    public var text: String
+    /**
+     * User-visible text (trailer/Appshot context stripped).
+     */
+    public var visibleText: String
+    public var attachments: [String]
+    public var holdForTurnEnd: Bool
+    public var issuedBy: String
+    public var fromThisDevice: Bool
+    public var issuedAtMs: Int64
+    public var editedAtMs: Int64?
+    public var gate: QueueGate?
+    /**
+     * A Send-now / Remove is awaiting the host's acknowledgement.
+     */
+    public var actionPending: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: UInt16, face: FaceRole, size: Float, ligatures: Bool) {
+    public init(id: String, 
+        /**
+         * Raw row text (what the host will send).
+         */text: String, 
+        /**
+         * User-visible text (trailer/Appshot context stripped).
+         */visibleText: String, attachments: [String], holdForTurnEnd: Bool, issuedBy: String, fromThisDevice: Bool, issuedAtMs: Int64, editedAtMs: Int64?, gate: QueueGate?, 
+        /**
+         * A Send-now / Remove is awaiting the host's acknowledgement.
+         */actionPending: Bool) {
         self.id = id
-        self.face = face
-        self.size = size
-        self.ligatures = ligatures
+        self.text = text
+        self.visibleText = visibleText
+        self.attachments = attachments
+        self.holdForTurnEnd = holdForTurnEnd
+        self.issuedBy = issuedBy
+        self.fromThisDevice = fromThisDevice
+        self.issuedAtMs = issuedAtMs
+        self.editedAtMs = editedAtMs
+        self.gate = gate
+        self.actionPending = actionPending
     }
 
     
@@ -7572,28 +7802,42 @@ public struct StyleDesc: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension StyleDesc: Sendable {}
+extension QueueItem: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeStyleDesc: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StyleDesc {
+public struct FfiConverterTypeQueueItem: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueItem {
         return
-            try StyleDesc(
-                id: FfiConverterUInt16.read(from: &buf), 
-                face: FfiConverterTypeFaceRole.read(from: &buf), 
-                size: FfiConverterFloat.read(from: &buf), 
-                ligatures: FfiConverterBool.read(from: &buf)
+            try QueueItem(
+                id: FfiConverterString.read(from: &buf), 
+                text: FfiConverterString.read(from: &buf), 
+                visibleText: FfiConverterString.read(from: &buf), 
+                attachments: FfiConverterSequenceString.read(from: &buf), 
+                holdForTurnEnd: FfiConverterBool.read(from: &buf), 
+                issuedBy: FfiConverterString.read(from: &buf), 
+                fromThisDevice: FfiConverterBool.read(from: &buf), 
+                issuedAtMs: FfiConverterInt64.read(from: &buf), 
+                editedAtMs: FfiConverterOptionInt64.read(from: &buf), 
+                gate: FfiConverterOptionTypeQueueGate.read(from: &buf), 
+                actionPending: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: StyleDesc, into buf: inout [UInt8]) {
-        FfiConverterUInt16.write(value.id, into: &buf)
-        FfiConverterTypeFaceRole.write(value.face, into: &buf)
-        FfiConverterFloat.write(value.size, into: &buf)
-        FfiConverterBool.write(value.ligatures, into: &buf)
+    public static func write(_ value: QueueItem, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterString.write(value.visibleText, into: &buf)
+        FfiConverterSequenceString.write(value.attachments, into: &buf)
+        FfiConverterBool.write(value.holdForTurnEnd, into: &buf)
+        FfiConverterString.write(value.issuedBy, into: &buf)
+        FfiConverterBool.write(value.fromThisDevice, into: &buf)
+        FfiConverterInt64.write(value.issuedAtMs, into: &buf)
+        FfiConverterOptionInt64.write(value.editedAtMs, into: &buf)
+        FfiConverterOptionTypeQueueGate.write(value.gate, into: &buf)
+        FfiConverterBool.write(value.actionPending, into: &buf)
     }
 }
 
@@ -7601,67 +7845,41 @@ public struct FfiConverterTypeStyleDesc: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeStyleDesc_lift(_ buf: RustBuffer) throws -> StyleDesc {
-    return try FfiConverterTypeStyleDesc.lift(buf)
+public func FfiConverterTypeQueueItem_lift(_ buf: RustBuffer) throws -> QueueItem {
+    return try FfiConverterTypeQueueItem.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeStyleDesc_lower(_ value: StyleDesc) -> RustBuffer {
-    return FfiConverterTypeStyleDesc.lower(value)
+public func FfiConverterTypeQueueItem_lower(_ value: QueueItem) -> RustBuffer {
+    return FfiConverterTypeQueueItem.lower(value)
 }
 
 
-/**
- * One positioned piece of text: `text[start..start+len]` (UTF-16) drawn with
- * `style` so its origin sits at (`x`, `baseline`).
- */
-public struct TextRun: Equatable, Hashable {
-    public var start: UInt32
-    public var len: UInt32
-    public var x: Float
-    public var baseline: Float
-    /**
-     * Rust-measured advance — painters may use it for selection/hit rects.
-     */
-    public var width: Float
-    public var style: UInt16
-    public var color: ColorRole
-    public var decoration: Decoration
+public struct RepoRef: Equatable, Hashable {
+    public var name: String
     /**
-     * Index into [`RowDisplay::scrollers`] when the run scrolls horizontally.
+     * Checked out in the repo's main folder right now.
      */
-    public var scroller: UInt32?
+    public var current: Bool
     /**
-     * Fade-in start in ms since the row's layout epoch (streaming veil);
-     * `None` = fully visible.
+     * Linked worktree this branch is checked out in, if any.
      */
-    public var revealMs: UInt32?
+    public var worktreePath: String?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(start: UInt32, len: UInt32, x: Float, baseline: Float, 
-        /**
-         * Rust-measured advance — painters may use it for selection/hit rects.
-         */width: Float, style: UInt16, color: ColorRole, decoration: Decoration, 
+    public init(name: String, 
         /**
-         * Index into [`RowDisplay::scrollers`] when the run scrolls horizontally.
-         */scroller: UInt32?, 
+         * Checked out in the repo's main folder right now.
+         */current: Bool, 
         /**
-         * Fade-in start in ms since the row's layout epoch (streaming veil);
-         * `None` = fully visible.
-         */revealMs: UInt32?) {
-        self.start = start
-        self.len = len
-        self.x = x
-        self.baseline = baseline
-        self.width = width
-        self.style = style
-        self.color = color
-        self.decoration = decoration
-        self.scroller = scroller
-        self.revealMs = revealMs
+         * Linked worktree this branch is checked out in, if any.
+         */worktreePath: String?) {
+        self.name = name
+        self.current = current
+        self.worktreePath = worktreePath
     }
 
     
@@ -7670,40 +7888,26 @@ public struct TextRun: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension TextRun: Sendable {}
+extension RepoRef: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeTextRun: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TextRun {
+public struct FfiConverterTypeRepoRef: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RepoRef {
         return
-            try TextRun(
-                start: FfiConverterUInt32.read(from: &buf), 
-                len: FfiConverterUInt32.read(from: &buf), 
-                x: FfiConverterFloat.read(from: &buf), 
-                baseline: FfiConverterFloat.read(from: &buf), 
-                width: FfiConverterFloat.read(from: &buf), 
-                style: FfiConverterUInt16.read(from: &buf), 
-                color: FfiConverterTypeColorRole.read(from: &buf), 
-                decoration: FfiConverterTypeDecoration.read(from: &buf), 
-                scroller: FfiConverterOptionUInt32.read(from: &buf), 
-                revealMs: FfiConverterOptionUInt32.read(from: &buf)
+            try RepoRef(
+                name: FfiConverterString.read(from: &buf), 
+                current: FfiConverterBool.read(from: &buf), 
+                worktreePath: FfiConverterOptionString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: TextRun, into buf: inout [UInt8]) {
-        FfiConverterUInt32.write(value.start, into: &buf)
-        FfiConverterUInt32.write(value.len, into: &buf)
-        FfiConverterFloat.write(value.x, into: &buf)
-        FfiConverterFloat.write(value.baseline, into: &buf)
-        FfiConverterFloat.write(value.width, into: &buf)
-        FfiConverterUInt16.write(value.style, into: &buf)
-        FfiConverterTypeColorRole.write(value.color, into: &buf)
-        FfiConverterTypeDecoration.write(value.decoration, into: &buf)
-        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
-        FfiConverterOptionUInt32.write(value.revealMs, into: &buf)
+    public static func write(_ value: RepoRef, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterBool.write(value.current, into: &buf)
+        FfiConverterOptionString.write(value.worktreePath, into: &buf)
     }
 }
 
@@ -7711,61 +7915,35 @@ public struct FfiConverterTypeTextRun: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeTextRun_lift(_ buf: RustBuffer) throws -> TextRun {
-    return try FfiConverterTypeTextRun.lift(buf)
+public func FfiConverterTypeRepoRef_lift(_ buf: RustBuffer) throws -> RepoRef {
+    return try FfiConverterTypeRepoRef.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeTextRun_lower(_ value: TextRun) -> RustBuffer {
-    return FfiConverterTypeTextRun.lower(value)
+public func FfiConverterTypeRepoRef_lower(_ value: RepoRef) -> RustBuffer {
+    return FfiConverterTypeRepoRef.lower(value)
 }
 
 
-/**
- * Transcript-level facts the platform needs without the rows (loader vs
- * empty state, scroll-to-bottom affordances, the working pill).
- */
-public struct TranscriptStatus: Equatable, Hashable {
-    public var revision: UInt64
-    /**
-     * Content present (false = show a loader, not an empty chat).
-     */
-    public var hydrated: Bool
-    /**
-     * Host-written entries.
-     */
-    public var entryCount: UInt32
-    public var pendingCount: UInt32
-    public var streaming: Bool
-    public var working: Bool
-    public var workingSinceMs: Int64?
+public struct RoomState: Equatable, Hashable {
+    public var connected: Bool
+    public var retryAtMs: Int64?
     /**
-     * Id of the newest entry (host or echo).
+     * Graced degradation for this chat.
      */
-    public var lastEntryId: String?
+    public var degraded: Bool
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(revision: UInt64, 
+    public init(connected: Bool, retryAtMs: Int64?, 
         /**
-         * Content present (false = show a loader, not an empty chat).
-         */hydrated: Bool, 
-        /**
-         * Host-written entries.
-         */entryCount: UInt32, pendingCount: UInt32, streaming: Bool, working: Bool, workingSinceMs: Int64?, 
-        /**
-         * Id of the newest entry (host or echo).
-         */lastEntryId: String?) {
-        self.revision = revision
-        self.hydrated = hydrated
-        self.entryCount = entryCount
-        self.pendingCount = pendingCount
-        self.streaming = streaming
-        self.working = working
-        self.workingSinceMs = workingSinceMs
-        self.lastEntryId = lastEntryId
+         * Graced degradation for this chat.
+         */degraded: Bool) {
+        self.connected = connected
+        self.retryAtMs = retryAtMs
+        self.degraded = degraded
     }
 
     
@@ -7774,36 +7952,26 @@ public struct TranscriptStatus: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension TranscriptStatus: Sendable {}
+extension RoomState: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeTranscriptStatus: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TranscriptStatus {
+public struct FfiConverterTypeRoomState: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RoomState {
         return
-            try TranscriptStatus(
-                revision: FfiConverterUInt64.read(from: &buf), 
-                hydrated: FfiConverterBool.read(from: &buf), 
-                entryCount: FfiConverterUInt32.read(from: &buf), 
-                pendingCount: FfiConverterUInt32.read(from: &buf), 
-                streaming: FfiConverterBool.read(from: &buf), 
-                working: FfiConverterBool.read(from: &buf), 
-                workingSinceMs: FfiConverterOptionInt64.read(from: &buf), 
-                lastEntryId: FfiConverterOptionString.read(from: &buf)
+            try RoomState(
+                connected: FfiConverterBool.read(from: &buf), 
+                retryAtMs: FfiConverterOptionInt64.read(from: &buf), 
+                degraded: FfiConverterBool.read(from: &buf)
         )
     }
 
-    public static func write(_ value: TranscriptStatus, into buf: inout [UInt8]) {
-        FfiConverterUInt64.write(value.revision, into: &buf)
-        FfiConverterBool.write(value.hydrated, into: &buf)
-        FfiConverterUInt32.write(value.entryCount, into: &buf)
-        FfiConverterUInt32.write(value.pendingCount, into: &buf)
-        FfiConverterBool.write(value.streaming, into: &buf)
-        FfiConverterBool.write(value.working, into: &buf)
-        FfiConverterOptionInt64.write(value.workingSinceMs, into: &buf)
-        FfiConverterOptionString.write(value.lastEntryId, into: &buf)
+    public static func write(_ value: RoomState, into buf: inout [UInt8]) {
+        FfiConverterBool.write(value.connected, into: &buf)
+        FfiConverterOptionInt64.write(value.retryAtMs, into: &buf)
+        FfiConverterBool.write(value.degraded, into: &buf)
     }
 }
 
@@ -7811,35 +7979,56 @@ public struct FfiConverterTypeTranscriptStatus: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeTranscriptStatus_lift(_ buf: RustBuffer) throws -> TranscriptStatus {
-    return try FfiConverterTypeTranscriptStatus.lift(buf)
+public func FfiConverterTypeRoomState_lift(_ buf: RustBuffer) throws -> RoomState {
+    return try FfiConverterTypeRoomState.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeTranscriptStatus_lower(_ value: TranscriptStatus) -> RustBuffer {
-    return FfiConverterTypeTranscriptStatus.lower(value)
+public func FfiConverterTypeRoomState_lower(_ value: RoomState) -> RustBuffer {
+    return FfiConverterTypeRoomState.lower(value)
 }
 
 
-public struct UserImage: Equatable, Hashable {
+/**
+ * Everything needed to paint a row at its current width.
+ */
+public struct RowDisplay: Equatable, Hashable {
+    public var key: UInt64
+    public var version: UInt64
+    public var width: Float
+    public var height: Float
+    public var text: String
+    public var runs: [TextRun]
+    public var boxes: [BoxPrim]
+    public var links: [LinkHit]
+    public var scrollers: [Scroller]
+    public var widgets: [Widget]
+    public var fades: [Fade]
     /**
-     * Host path (or `pending://` ref) — read via `read_attachment`.
+     * Plain text for copy / accessibility.
      */
-    public var path: String
-    public var name: String
-    public var appshot: AppshotLabel?
+    public var copyText: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(
+    public init(key: UInt64, version: UInt64, width: Float, height: Float, text: String, runs: [TextRun], boxes: [BoxPrim], links: [LinkHit], scrollers: [Scroller], widgets: [Widget], fades: [Fade], 
         /**
-         * Host path (or `pending://` ref) — read via `read_attachment`.
-         */path: String, name: String, appshot: AppshotLabel?) {
-        self.path = path
-        self.name = name
-        self.appshot = appshot
+         * Plain text for copy / accessibility.
+         */copyText: String) {
+        self.key = key
+        self.version = version
+        self.width = width
+        self.height = height
+        self.text = text
+        self.runs = runs
+        self.boxes = boxes
+        self.links = links
+        self.scrollers = scrollers
+        self.widgets = widgets
+        self.fades = fades
+        self.copyText = copyText
     }
 
     
@@ -7848,26 +8037,44 @@ public struct UserImage: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension UserImage: Sendable {}
+extension RowDisplay: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeUserImage: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserImage {
+public struct FfiConverterTypeRowDisplay: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RowDisplay {
         return
-            try UserImage(
-                path: FfiConverterString.read(from: &buf), 
-                name: FfiConverterString.read(from: &buf), 
-                appshot: FfiConverterOptionTypeAppshotLabel.read(from: &buf)
+            try RowDisplay(
+                key: FfiConverterUInt64.read(from: &buf), 
+                version: FfiConverterUInt64.read(from: &buf), 
+                width: FfiConverterFloat.read(from: &buf), 
+                height: FfiConverterFloat.read(from: &buf), 
+                text: FfiConverterString.read(from: &buf), 
+                runs: FfiConverterSequenceTypeTextRun.read(from: &buf), 
+                boxes: FfiConverterSequenceTypeBoxPrim.read(from: &buf), 
+                links: FfiConverterSequenceTypeLinkHit.read(from: &buf), 
+                scrollers: FfiConverterSequenceTypeScroller.read(from: &buf), 
+                widgets: FfiConverterSequenceTypeWidget.read(from: &buf), 
+                fades: FfiConverterSequenceTypeFade.read(from: &buf), 
+                copyText: FfiConverterString.read(from: &buf)
         )
     }
 
-    public static func write(_ value: UserImage, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.path, into: &buf)
-        FfiConverterString.write(value.name, into: &buf)
-        FfiConverterOptionTypeAppshotLabel.write(value.appshot, into: &buf)
+    public static func write(_ value: RowDisplay, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.key, into: &buf)
+        FfiConverterUInt64.write(value.version, into: &buf)
+        FfiConverterFloat.write(value.width, into: &buf)
+        FfiConverterFloat.write(value.height, into: &buf)
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterSequenceTypeTextRun.write(value.runs, into: &buf)
+        FfiConverterSequenceTypeBoxPrim.write(value.boxes, into: &buf)
+        FfiConverterSequenceTypeLinkHit.write(value.links, into: &buf)
+        FfiConverterSequenceTypeScroller.write(value.scrollers, into: &buf)
+        FfiConverterSequenceTypeWidget.write(value.widgets, into: &buf)
+        FfiConverterSequenceTypeFade.write(value.fades, into: &buf)
+        FfiConverterString.write(value.copyText, into: &buf)
     }
 }
 
@@ -7875,33 +8082,44 @@ public struct FfiConverterTypeUserImage: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeUserImage_lift(_ buf: RustBuffer) throws -> UserImage {
-    return try FfiConverterTypeUserImage.lift(buf)
+public func FfiConverterTypeRowDisplay_lift(_ buf: RustBuffer) throws -> RowDisplay {
+    return try FfiConverterTypeRowDisplay.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeUserImage_lower(_ value: UserImage) -> RustBuffer {
-    return FfiConverterTypeUserImage.lower(value)
+public func FfiConverterTypeRowDisplay_lower(_ value: RowDisplay) -> RustBuffer {
+    return FfiConverterTypeRowDisplay.lower(value)
 }
 
 
-public struct UserInputAnswer: Equatable, Hashable {
-    public var questionId: String
+/**
+ * A row's position in a frame.
+ */
+public struct RowPlacement: Equatable, Hashable {
+    public var index: UInt32
+    public var key: UInt64
     /**
-     * Picked option labels (or free text as a single label).
+     * Changes whenever the row's painted content may change (not its width).
      */
-    public var labels: [String]
+    public var version: UInt64
+    public var y: Float
+    public var height: Float
+    public var kind: RowKind
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(questionId: String, 
+    public init(index: UInt32, key: UInt64, 
         /**
-         * Picked option labels (or free text as a single label).
-         */labels: [String]) {
-        self.questionId = questionId
-        self.labels = labels
+         * Changes whenever the row's painted content may change (not its width).
+         */version: UInt64, y: Float, height: Float, kind: RowKind) {
+        self.index = index
+        self.key = key
+        self.version = version
+        self.y = y
+        self.height = height
+        self.kind = kind
     }
 
     
@@ -7910,24 +8128,32 @@ public struct UserInputAnswer: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension UserInputAnswer: Sendable {}
+extension RowPlacement: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeUserInputAnswer: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserInputAnswer {
+public struct FfiConverterTypeRowPlacement: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RowPlacement {
         return
-            try UserInputAnswer(
-                questionId: FfiConverterString.read(from: &buf), 
-                labels: FfiConverterSequenceString.read(from: &buf)
+            try RowPlacement(
+                index: FfiConverterUInt32.read(from: &buf), 
+                key: FfiConverterUInt64.read(from: &buf), 
+                version: FfiConverterUInt64.read(from: &buf), 
+                y: FfiConverterFloat.read(from: &buf), 
+                height: FfiConverterFloat.read(from: &buf), 
+                kind: FfiConverterTypeRowKind.read(from: &buf)
         )
     }
 
-    public static func write(_ value: UserInputAnswer, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.questionId, into: &buf)
-        FfiConverterSequenceString.write(value.labels, into: &buf)
+    public static func write(_ value: RowPlacement, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.index, into: &buf)
+        FfiConverterUInt64.write(value.key, into: &buf)
+        FfiConverterUInt64.write(value.version, into: &buf)
+        FfiConverterFloat.write(value.y, into: &buf)
+        FfiConverterFloat.write(value.height, into: &buf)
+        FfiConverterTypeRowKind.write(value.kind, into: &buf)
     }
 }
 
@@ -7935,37 +8161,38 @@ public struct FfiConverterTypeUserInputAnswer: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeUserInputAnswer_lift(_ buf: RustBuffer) throws -> UserInputAnswer {
-    return try FfiConverterTypeUserInputAnswer.lift(buf)
+public func FfiConverterTypeRowPlacement_lift(_ buf: RustBuffer) throws -> RowPlacement {
+    return try FfiConverterTypeRowPlacement.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeUserInputAnswer_lower(_ value: UserInputAnswer) -> RustBuffer {
-    return FfiConverterTypeUserInputAnswer.lower(value)
+public func FfiConverterTypeRowPlacement_lower(_ value: RowPlacement) -> RustBuffer {
+    return FfiConverterTypeRowPlacement.lower(value)
 }
 
 
-public struct UserInputQuestion: Equatable, Hashable {
-    public var id: String
-    public var header: String
-    public var question: String
-    public var options: [String]
-    public var multiSelect: Bool
-    public var prefill: String?
-    public var multiline: Bool
+/**
+ * A horizontally scrolling viewport (code blocks, wide tables). Primitives
+ * that reference it are positioned in its content coordinates, whose origin
+ * is the viewport's top-left.
+ */
+public struct Scroller: Equatable, Hashable {
+    public var x: Float
+    public var y: Float
+    public var w: Float
+    public var h: Float
+    public var contentWidth: Float
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: String, header: String, question: String, options: [String], multiSelect: Bool, prefill: String?, multiline: Bool) {
-        self.id = id
-        self.header = header
-        self.question = question
-        self.options = options
-        self.multiSelect = multiSelect
-        self.prefill = prefill
-        self.multiline = multiline
+    public init(x: Float, y: Float, w: Float, h: Float, contentWidth: Float) {
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.contentWidth = contentWidth
     }
 
     
@@ -7974,34 +8201,30 @@ public struct UserInputQuestion: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension UserInputQuestion: Sendable {}
+extension Scroller: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeUserInputQuestion: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserInputQuestion {
+public struct FfiConverterTypeScroller: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Scroller {
         return
-            try UserInputQuestion(
-                id: FfiConverterString.read(from: &buf), 
-                header: FfiConverterString.read(from: &buf), 
-                question: FfiConverterString.read(from: &buf), 
-                options: FfiConverterSequenceString.read(from: &buf), 
-                multiSelect: FfiConverterBool.read(from: &buf), 
-                prefill: FfiConverterOptionString.read(from: &buf), 
-                multiline: FfiConverterBool.read(from: &buf)
+            try Scroller(
+                x: FfiConverterFloat.read(from: &buf), 
+                y: FfiConverterFloat.read(from: &buf), 
+                w: FfiConverterFloat.read(from: &buf), 
+                h: FfiConverterFloat.read(from: &buf), 
+                contentWidth: FfiConverterFloat.read(from: &buf)
         )
     }
 
-    public static func write(_ value: UserInputQuestion, into buf: inout [UInt8]) {
-        FfiConverterString.write(value.id, into: &buf)
-        FfiConverterString.write(value.header, into: &buf)
-        FfiConverterString.write(value.question, into: &buf)
-        FfiConverterSequenceString.write(value.options, into: &buf)
-        FfiConverterBool.write(value.multiSelect, into: &buf)
-        FfiConverterOptionString.write(value.prefill, into: &buf)
-        FfiConverterBool.write(value.multiline, into: &buf)
+    public static func write(_ value: Scroller, into buf: inout [UInt8]) {
+        FfiConverterFloat.write(value.x, into: &buf)
+        FfiConverterFloat.write(value.y, into: &buf)
+        FfiConverterFloat.write(value.w, into: &buf)
+        FfiConverterFloat.write(value.h, into: &buf)
+        FfiConverterFloat.write(value.contentWidth, into: &buf)
     }
 }
 
@@ -8009,39 +8232,35 @@ public struct FfiConverterTypeUserInputQuestion: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeUserInputQuestion_lift(_ buf: RustBuffer) throws -> UserInputQuestion {
-    return try FfiConverterTypeUserInputQuestion.lift(buf)
+public func FfiConverterTypeScroller_lift(_ buf: RustBuffer) throws -> Scroller {
+    return try FfiConverterTypeScroller.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeUserInputQuestion_lower(_ value: UserInputQuestion) -> RustBuffer {
-    return FfiConverterTypeUserInputQuestion.lower(value)
+public func FfiConverterTypeScroller_lower(_ value: Scroller) -> RustBuffer {
+    return FfiConverterTypeScroller.lower(value)
 }
 
 
-public struct Widget: Equatable, Hashable {
-    public var id: UInt32
-    public var kind: WidgetKind
-    public var x: Float
-    public var y: Float
-    public var w: Float
-    public var h: Float
-    public var payload: String?
-    public var scroller: UInt32?
+public struct SearchHit: Equatable, Hashable {
+    public var session: SessionRow
+    public var score: UInt32
+    /**
+     * The strongest field that matched.
+     */
+    public var field: SearchField
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(id: UInt32, kind: WidgetKind, x: Float, y: Float, w: Float, h: Float, payload: String?, scroller: UInt32?) {
-        self.id = id
-        self.kind = kind
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.payload = payload
-        self.scroller = scroller
+    public init(session: SessionRow, score: UInt32, 
+        /**
+         * The strongest field that matched.
+         */field: SearchField) {
+        self.session = session
+        self.score = score
+        self.field = field
     }
 
     
@@ -8050,36 +8269,26 @@ public struct Widget: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension Widget: Sendable {}
+extension SearchHit: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeWidget: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Widget {
+public struct FfiConverterTypeSearchHit: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SearchHit {
         return
-            try Widget(
-                id: FfiConverterUInt32.read(from: &buf), 
-                kind: FfiConverterTypeWidgetKind.read(from: &buf), 
-                x: FfiConverterFloat.read(from: &buf), 
-                y: FfiConverterFloat.read(from: &buf), 
-                w: FfiConverterFloat.read(from: &buf), 
-                h: FfiConverterFloat.read(from: &buf), 
-                payload: FfiConverterOptionString.read(from: &buf), 
-                scroller: FfiConverterOptionUInt32.read(from: &buf)
+            try SearchHit(
+                session: FfiConverterTypeSessionRow.read(from: &buf), 
+                score: FfiConverterUInt32.read(from: &buf), 
+                field: FfiConverterTypeSearchField.read(from: &buf)
         )
     }
 
-    public static func write(_ value: Widget, into buf: inout [UInt8]) {
-        FfiConverterUInt32.write(value.id, into: &buf)
-        FfiConverterTypeWidgetKind.write(value.kind, into: &buf)
-        FfiConverterFloat.write(value.x, into: &buf)
-        FfiConverterFloat.write(value.y, into: &buf)
-        FfiConverterFloat.write(value.w, into: &buf)
-        FfiConverterFloat.write(value.h, into: &buf)
-        FfiConverterOptionString.write(value.payload, into: &buf)
-        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
+    public static func write(_ value: SearchHit, into buf: inout [UInt8]) {
+        FfiConverterTypeSessionRow.write(value.session, into: &buf)
+        FfiConverterUInt32.write(value.score, into: &buf)
+        FfiConverterTypeSearchField.write(value.field, into: &buf)
     }
 }
 
@@ -8087,70 +8296,37 @@ public struct FfiConverterTypeWidget: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeWidget_lift(_ buf: RustBuffer) throws -> Widget {
-    return try FfiConverterTypeWidget.lift(buf)
+public func FfiConverterTypeSearchHit_lift(_ buf: RustBuffer) throws -> SearchHit {
+    return try FfiConverterTypeSearchHit.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeWidget_lower(_ value: Widget) -> RustBuffer {
-    return FfiConverterTypeWidget.lower(value)
+public func FfiConverterTypeSearchHit_lower(_ value: SearchHit) -> RustBuffer {
+    return FfiConverterTypeSearchHit.lower(value)
 }
 
 
-/**
- * Everything the workspace screens render.
- */
-public struct WorkspaceSnapshot: Equatable, Hashable {
-    public var revision: UInt64
-    public var computedAtMs: Int64
-    /**
-     * Pin/section edits allowed (sidebar prefs known).
-     */
-    public var pinsReady: Bool
-    /**
-     * The registry reached this device at least once (or demo).
-     */
-    public var synced: Bool
-    public var front: FrontPage
-    /**
-     * Creation order.
-     */
-    public var projects: [ProjectView]
+public struct SectionView: Equatable, Hashable {
+    public var id: String
+    public var name: String
+    public var collapsed: Bool
     /**
-     * Active sessions without a project.
+     * Recency order (pinned sessions excluded).
      */
-    public var projectless: [SessionRow]
-    public var pullRequests: PullRequestGroups
-    public var archived: [SessionRow]
-    public var devices: [DeviceView]
+    public var sessions: [SessionRow]
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(revision: UInt64, computedAtMs: Int64, 
-        /**
-         * Pin/section edits allowed (sidebar prefs known).
-         */pinsReady: Bool, 
-        /**
-         * The registry reached this device at least once (or demo).
-         */synced: Bool, front: FrontPage, 
-        /**
-         * Creation order.
-         */projects: [ProjectView], 
+    public init(id: String, name: String, collapsed: Bool, 
         /**
-         * Active sessions without a project.
-         */projectless: [SessionRow], pullRequests: PullRequestGroups, archived: [SessionRow], devices: [DeviceView]) {
-        self.revision = revision
-        self.computedAtMs = computedAtMs
-        self.pinsReady = pinsReady
-        self.synced = synced
-        self.front = front
-        self.projects = projects
-        self.projectless = projectless
-        self.pullRequests = pullRequests
-        self.archived = archived
-        self.devices = devices
+         * Recency order (pinned sessions excluded).
+         */sessions: [SessionRow]) {
+        self.id = id
+        self.name = name
+        self.collapsed = collapsed
+        self.sessions = sessions
     }
 
     
@@ -8159,40 +8335,28 @@ public struct WorkspaceSnapshot: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension WorkspaceSnapshot: Sendable {}
+extension SectionView: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeWorkspaceSnapshot: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WorkspaceSnapshot {
+public struct FfiConverterTypeSectionView: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SectionView {
         return
-            try WorkspaceSnapshot(
-                revision: FfiConverterUInt64.read(from: &buf), 
-                computedAtMs: FfiConverterInt64.read(from: &buf), 
-                pinsReady: FfiConverterBool.read(from: &buf), 
-                synced: FfiConverterBool.read(from: &buf), 
-                front: FfiConverterTypeFrontPage.read(from: &buf), 
-                projects: FfiConverterSequenceTypeProjectView.read(from: &buf), 
-                projectless: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
-                pullRequests: FfiConverterTypePullRequestGroups.read(from: &buf), 
-                archived: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
-                devices: FfiConverterSequenceTypeDeviceView.read(from: &buf)
+            try SectionView(
+                id: FfiConverterString.read(from: &buf), 
+                name: FfiConverterString.read(from: &buf), 
+                collapsed: FfiConverterBool.read(from: &buf), 
+                sessions: FfiConverterSequenceTypeSessionRow.read(from: &buf)
         )
     }
 
-    public static func write(_ value: WorkspaceSnapshot, into buf: inout [UInt8]) {
-        FfiConverterUInt64.write(value.revision, into: &buf)
-        FfiConverterInt64.write(value.computedAtMs, into: &buf)
-        FfiConverterBool.write(value.pinsReady, into: &buf)
-        FfiConverterBool.write(value.synced, into: &buf)
-        FfiConverterTypeFrontPage.write(value.front, into: &buf)
-        FfiConverterSequenceTypeProjectView.write(value.projects, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.projectless, into: &buf)
-        FfiConverterTypePullRequestGroups.write(value.pullRequests, into: &buf)
-        FfiConverterSequenceTypeSessionRow.write(value.archived, into: &buf)
-        FfiConverterSequenceTypeDeviceView.write(value.devices, into: &buf)
+    public static func write(_ value: SectionView, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterBool.write(value.collapsed, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.sessions, into: &buf)
     }
 }
 
@@ -8200,41 +8364,37 @@ public struct FfiConverterTypeWorkspaceSnapshot: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeWorkspaceSnapshot_lift(_ buf: RustBuffer) throws -> WorkspaceSnapshot {
-    return try FfiConverterTypeWorkspaceSnapshot.lift(buf)
+public func FfiConverterTypeSectionView_lift(_ buf: RustBuffer) throws -> SectionView {
+    return try FfiConverterTypeSectionView.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeWorkspaceSnapshot_lower(_ value: WorkspaceSnapshot) -> RustBuffer {
-    return FfiConverterTypeWorkspaceSnapshot.lower(value)
+public func FfiConverterTypeSectionView_lower(_ value: SectionView) -> RustBuffer {
+    return FfiConverterTypeSectionView.lower(value)
 }
 
 
-public struct WorktreeSpec: Equatable, Hashable {
-    /**
-     * The repo to branch (the project's folder on the host).
-     */
-    public var repoPath: String
+public struct SendRequest: Equatable, Hashable {
+    public var text: String
+    public var attachments: [OutgoingAttachment]
     /**
-     * Base ref for the fresh `zeron/<name>` branch.
+     * Isolated host worktree for this run (new-session "New worktree").
      */
-    public var base: String
-    public var spaceId: String?
+    public var worktree: WorktreeSpec?
+    public var busy: BusyPolicy
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
-    public init(
-        /**
-         * The repo to branch (the project's folder on the host).
-         */repoPath: String, 
+    public init(text: String, attachments: [OutgoingAttachment], 
         /**
-         * Base ref for the fresh `zeron/<name>` branch.
-         */base: String, spaceId: String?) {
-        self.repoPath = repoPath
-        self.base = base
-        self.spaceId = spaceId
+         * Isolated host worktree for this run (new-session "New worktree").
+         */worktree: WorktreeSpec?, busy: BusyPolicy) {
+        self.text = text
+        self.attachments = attachments
+        self.worktree = worktree
+        self.busy = busy
     }
 
     
@@ -8243,23 +8403,1189 @@ public struct WorktreeSpec: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension WorktreeSpec: Sendable {}
+extension SendRequest: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeWorktreeSpec: FfiConverterRustBuffer {
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WorktreeSpec {
+public struct FfiConverterTypeSendRequest: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SendRequest {
         return
-            try WorktreeSpec(
-                repoPath: FfiConverterString.read(from: &buf), 
-                base: FfiConverterString.read(from: &buf), 
-                spaceId: FfiConverterOptionString.read(from: &buf)
+            try SendRequest(
+                text: FfiConverterString.read(from: &buf), 
+                attachments: FfiConverterSequenceTypeOutgoingAttachment.read(from: &buf), 
+                worktree: FfiConverterOptionTypeWorktreeSpec.read(from: &buf), 
+                busy: FfiConverterTypeBusyPolicy.read(from: &buf)
         )
     }
 
-    public static func write(_ value: WorktreeSpec, into buf: inout [UInt8]) {
+    public static func write(_ value: SendRequest, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.text, into: &buf)
+        FfiConverterSequenceTypeOutgoingAttachment.write(value.attachments, into: &buf)
+        FfiConverterOptionTypeWorktreeSpec.write(value.worktree, into: &buf)
+        FfiConverterTypeBusyPolicy.write(value.busy, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeSendRequest_lift(_ buf: RustBuffer) throws -> SendRequest {
+    return try FfiConverterTypeSendRequest.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeSendRequest_lower(_ value: SendRequest) -> RustBuffer {
+    return FfiConverterTypeSendRequest.lower(value)
+}
+
+
+/**
+ * One session row, as every list renders it.
+ */
+public struct SessionRow: Equatable, Hashable {
+    public var id: String
+    /**
+     * Content hash — equal ⇒ nothing to redraw.
+     */
+    public var revision: UInt64
+    /**
+     * Display title ("New session" when untitled).
+     */
+    public var title: String
+    public var hasTitle: Bool
+    public var preview: String?
+    /**
+     * `None` = projectless (host's home folder).
+     */
+    public var project: ProjectRef?
+    public var deviceId: String
+    public var deviceName: String?
+    public var deviceOnline: Bool
+    /**
+     * Wire harness id (`claude-code`).
+     */
+    public var harness: String?
+    public var harnessLabel: String?
+    public var model: String?
+    public var modelLabel: String?
+    /**
+     * Wire effort (`xhigh`).
+     */
+    public var reasoning: String?
+    public var branch: String?
+    public var cwd: String?
+    /**
+     * Staleness-gated (45s) live status; an in-flight send reads Working.
+     */
+    public var indicator: ChatIndicator
+    /**
+     * Host-reported status only (no local-send override).
+     */
+    public var hostIndicator: ChatIndicator
+    /**
+     * Run start of the live turn while Working/AwaitingInput.
+     */
+    public var workingSinceMs: Int64?
+    public var lastActivityMs: Int64
+    /**
+     * `now` / `34m` / `4h` / `2d` at derive time.
+     */
+    public var timeLabel: String
+    public var createdAtMs: Int64
+    public var unseen: Bool
+    public var archived: Bool
+    public var pinned: Bool
+    public var sectionId: String?
+    public var pullRequest: PullRequest?
+    /**
+     * Oldest unadopted send from this device (open sessions only).
+     */
+    public var sendState: SendState?
+    public var parentChatId: String?
+    /**
+     * 2 = chat2; 1 = legacy (not dialable).
+     */
+    public var roomGen: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(id: String, 
+        /**
+         * Content hash — equal ⇒ nothing to redraw.
+         */revision: UInt64, 
+        /**
+         * Display title ("New session" when untitled).
+         */title: String, hasTitle: Bool, preview: String?, 
+        /**
+         * `None` = projectless (host's home folder).
+         */project: ProjectRef?, deviceId: String, deviceName: String?, deviceOnline: Bool, 
+        /**
+         * Wire harness id (`claude-code`).
+         */harness: String?, harnessLabel: String?, model: String?, modelLabel: String?, 
+        /**
+         * Wire effort (`xhigh`).
+         */reasoning: String?, branch: String?, cwd: String?, 
+        /**
+         * Staleness-gated (45s) live status; an in-flight send reads Working.
+         */indicator: ChatIndicator, 
+        /**
+         * Host-reported status only (no local-send override).
+         */hostIndicator: ChatIndicator, 
+        /**
+         * Run start of the live turn while Working/AwaitingInput.
+         */workingSinceMs: Int64?, lastActivityMs: Int64, 
+        /**
+         * `now` / `34m` / `4h` / `2d` at derive time.
+         */timeLabel: String, createdAtMs: Int64, unseen: Bool, archived: Bool, pinned: Bool, sectionId: String?, pullRequest: PullRequest?, 
+        /**
+         * Oldest unadopted send from this device (open sessions only).
+         */sendState: SendState?, parentChatId: String?, 
+        /**
+         * 2 = chat2; 1 = legacy (not dialable).
+         */roomGen: UInt32) {
+        self.id = id
+        self.revision = revision
+        self.title = title
+        self.hasTitle = hasTitle
+        self.preview = preview
+        self.project = project
+        self.deviceId = deviceId
+        self.deviceName = deviceName
+        self.deviceOnline = deviceOnline
+        self.harness = harness
+        self.harnessLabel = harnessLabel
+        self.model = model
+        self.modelLabel = modelLabel
+        self.reasoning = reasoning
+        self.branch = branch
+        self.cwd = cwd
+        self.indicator = indicator
+        self.hostIndicator = hostIndicator
+        self.workingSinceMs = workingSinceMs
+        self.lastActivityMs = lastActivityMs
+        self.timeLabel = timeLabel
+        self.createdAtMs = createdAtMs
+        self.unseen = unseen
+        self.archived = archived
+        self.pinned = pinned
+        self.sectionId = sectionId
+        self.pullRequest = pullRequest
+        self.sendState = sendState
+        self.parentChatId = parentChatId
+        self.roomGen = roomGen
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension SessionRow: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeSessionRow: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SessionRow {
+        return
+            try SessionRow(
+                id: FfiConverterString.read(from: &buf), 
+                revision: FfiConverterUInt64.read(from: &buf), 
+                title: FfiConverterString.read(from: &buf), 
+                hasTitle: FfiConverterBool.read(from: &buf), 
+                preview: FfiConverterOptionString.read(from: &buf), 
+                project: FfiConverterOptionTypeProjectRef.read(from: &buf), 
+                deviceId: FfiConverterString.read(from: &buf), 
+                deviceName: FfiConverterOptionString.read(from: &buf), 
+                deviceOnline: FfiConverterBool.read(from: &buf), 
+                harness: FfiConverterOptionString.read(from: &buf), 
+                harnessLabel: FfiConverterOptionString.read(from: &buf), 
+                model: FfiConverterOptionString.read(from: &buf), 
+                modelLabel: FfiConverterOptionString.read(from: &buf), 
+                reasoning: FfiConverterOptionString.read(from: &buf), 
+                branch: FfiConverterOptionString.read(from: &buf), 
+                cwd: FfiConverterOptionString.read(from: &buf), 
+                indicator: FfiConverterTypeChatIndicator.read(from: &buf), 
+                hostIndicator: FfiConverterTypeChatIndicator.read(from: &buf), 
+                workingSinceMs: FfiConverterOptionInt64.read(from: &buf), 
+                lastActivityMs: FfiConverterInt64.read(from: &buf), 
+                timeLabel: FfiConverterString.read(from: &buf), 
+                createdAtMs: FfiConverterInt64.read(from: &buf), 
+                unseen: FfiConverterBool.read(from: &buf), 
+                archived: FfiConverterBool.read(from: &buf), 
+                pinned: FfiConverterBool.read(from: &buf), 
+                sectionId: FfiConverterOptionString.read(from: &buf), 
+                pullRequest: FfiConverterOptionTypePullRequest.read(from: &buf), 
+                sendState: FfiConverterOptionTypeSendState.read(from: &buf), 
+                parentChatId: FfiConverterOptionString.read(from: &buf), 
+                roomGen: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: SessionRow, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterUInt64.write(value.revision, into: &buf)
+        FfiConverterString.write(value.title, into: &buf)
+        FfiConverterBool.write(value.hasTitle, into: &buf)
+        FfiConverterOptionString.write(value.preview, into: &buf)
+        FfiConverterOptionTypeProjectRef.write(value.project, into: &buf)
+        FfiConverterString.write(value.deviceId, into: &buf)
+        FfiConverterOptionString.write(value.deviceName, into: &buf)
+        FfiConverterBool.write(value.deviceOnline, into: &buf)
+        FfiConverterOptionString.write(value.harness, into: &buf)
+        FfiConverterOptionString.write(value.harnessLabel, into: &buf)
+        FfiConverterOptionString.write(value.model, into: &buf)
+        FfiConverterOptionString.write(value.modelLabel, into: &buf)
+        FfiConverterOptionString.write(value.reasoning, into: &buf)
+        FfiConverterOptionString.write(value.branch, into: &buf)
+        FfiConverterOptionString.write(value.cwd, into: &buf)
+        FfiConverterTypeChatIndicator.write(value.indicator, into: &buf)
+        FfiConverterTypeChatIndicator.write(value.hostIndicator, into: &buf)
+        FfiConverterOptionInt64.write(value.workingSinceMs, into: &buf)
+        FfiConverterInt64.write(value.lastActivityMs, into: &buf)
+        FfiConverterString.write(value.timeLabel, into: &buf)
+        FfiConverterInt64.write(value.createdAtMs, into: &buf)
+        FfiConverterBool.write(value.unseen, into: &buf)
+        FfiConverterBool.write(value.archived, into: &buf)
+        FfiConverterBool.write(value.pinned, into: &buf)
+        FfiConverterOptionString.write(value.sectionId, into: &buf)
+        FfiConverterOptionTypePullRequest.write(value.pullRequest, into: &buf)
+        FfiConverterOptionTypeSendState.write(value.sendState, into: &buf)
+        FfiConverterOptionString.write(value.parentChatId, into: &buf)
+        FfiConverterUInt32.write(value.roomGen, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeSessionRow_lift(_ buf: RustBuffer) throws -> SessionRow {
+    return try FfiConverterTypeSessionRow.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeSessionRow_lower(_ value: SessionRow) -> RustBuffer {
+    return FfiConverterTypeSessionRow.lower(value)
+}
+
+
+/**
+ * A style the platform must be able to draw: `id` → (face, size).
+ */
+public struct StyleDesc: Equatable, Hashable {
+    public var id: UInt16
+    public var face: FaceRole
+    public var size: Float
+    public var ligatures: Bool
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(id: UInt16, face: FaceRole, size: Float, ligatures: Bool) {
+        self.id = id
+        self.face = face
+        self.size = size
+        self.ligatures = ligatures
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension StyleDesc: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeStyleDesc: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StyleDesc {
+        return
+            try StyleDesc(
+                id: FfiConverterUInt16.read(from: &buf), 
+                face: FfiConverterTypeFaceRole.read(from: &buf), 
+                size: FfiConverterFloat.read(from: &buf), 
+                ligatures: FfiConverterBool.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: StyleDesc, into buf: inout [UInt8]) {
+        FfiConverterUInt16.write(value.id, into: &buf)
+        FfiConverterTypeFaceRole.write(value.face, into: &buf)
+        FfiConverterFloat.write(value.size, into: &buf)
+        FfiConverterBool.write(value.ligatures, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeStyleDesc_lift(_ buf: RustBuffer) throws -> StyleDesc {
+    return try FfiConverterTypeStyleDesc.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeStyleDesc_lower(_ value: StyleDesc) -> RustBuffer {
+    return FfiConverterTypeStyleDesc.lower(value)
+}
+
+
+/**
+ * One positioned piece of text: `text[start..start+len]` (UTF-16) drawn with
+ * `style` so its origin sits at (`x`, `baseline`).
+ */
+public struct TextRun: Equatable, Hashable {
+    public var start: UInt32
+    public var len: UInt32
+    public var x: Float
+    public var baseline: Float
+    /**
+     * Rust-measured advance — painters may use it for selection/hit rects.
+     */
+    public var width: Float
+    public var style: UInt16
+    public var color: ColorRole
+    public var decoration: Decoration
+    /**
+     * Index into [`RowDisplay::scrollers`] when the run scrolls horizontally.
+     */
+    public var scroller: UInt32?
+    /**
+     * Fade-in start in ms since the row's layout epoch (streaming veil);
+     * `None` = fully visible.
+     */
+    public var revealMs: UInt32?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(start: UInt32, len: UInt32, x: Float, baseline: Float, 
+        /**
+         * Rust-measured advance — painters may use it for selection/hit rects.
+         */width: Float, style: UInt16, color: ColorRole, decoration: Decoration, 
+        /**
+         * Index into [`RowDisplay::scrollers`] when the run scrolls horizontally.
+         */scroller: UInt32?, 
+        /**
+         * Fade-in start in ms since the row's layout epoch (streaming veil);
+         * `None` = fully visible.
+         */revealMs: UInt32?) {
+        self.start = start
+        self.len = len
+        self.x = x
+        self.baseline = baseline
+        self.width = width
+        self.style = style
+        self.color = color
+        self.decoration = decoration
+        self.scroller = scroller
+        self.revealMs = revealMs
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension TextRun: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTextRun: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TextRun {
+        return
+            try TextRun(
+                start: FfiConverterUInt32.read(from: &buf), 
+                len: FfiConverterUInt32.read(from: &buf), 
+                x: FfiConverterFloat.read(from: &buf), 
+                baseline: FfiConverterFloat.read(from: &buf), 
+                width: FfiConverterFloat.read(from: &buf), 
+                style: FfiConverterUInt16.read(from: &buf), 
+                color: FfiConverterTypeColorRole.read(from: &buf), 
+                decoration: FfiConverterTypeDecoration.read(from: &buf), 
+                scroller: FfiConverterOptionUInt32.read(from: &buf), 
+                revealMs: FfiConverterOptionUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TextRun, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.start, into: &buf)
+        FfiConverterUInt32.write(value.len, into: &buf)
+        FfiConverterFloat.write(value.x, into: &buf)
+        FfiConverterFloat.write(value.baseline, into: &buf)
+        FfiConverterFloat.write(value.width, into: &buf)
+        FfiConverterUInt16.write(value.style, into: &buf)
+        FfiConverterTypeColorRole.write(value.color, into: &buf)
+        FfiConverterTypeDecoration.write(value.decoration, into: &buf)
+        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
+        FfiConverterOptionUInt32.write(value.revealMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTextRun_lift(_ buf: RustBuffer) throws -> TextRun {
+    return try FfiConverterTypeTextRun.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTextRun_lower(_ value: TextRun) -> RustBuffer {
+    return FfiConverterTypeTextRun.lower(value)
+}
+
+
+/**
+ * Transcript-level facts the platform needs without the rows (loader vs
+ * empty state, scroll-to-bottom affordances, the working pill).
+ */
+public struct TranscriptStatus: Equatable, Hashable {
+    public var revision: UInt64
+    /**
+     * Content present (false = show a loader, not an empty chat).
+     */
+    public var hydrated: Bool
+    /**
+     * Host-written entries.
+     */
+    public var entryCount: UInt32
+    public var pendingCount: UInt32
+    public var streaming: Bool
+    public var working: Bool
+    public var workingSinceMs: Int64?
+    /**
+     * Id of the newest entry (host or echo).
+     */
+    public var lastEntryId: String?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(revision: UInt64, 
+        /**
+         * Content present (false = show a loader, not an empty chat).
+         */hydrated: Bool, 
+        /**
+         * Host-written entries.
+         */entryCount: UInt32, pendingCount: UInt32, streaming: Bool, working: Bool, workingSinceMs: Int64?, 
+        /**
+         * Id of the newest entry (host or echo).
+         */lastEntryId: String?) {
+        self.revision = revision
+        self.hydrated = hydrated
+        self.entryCount = entryCount
+        self.pendingCount = pendingCount
+        self.streaming = streaming
+        self.working = working
+        self.workingSinceMs = workingSinceMs
+        self.lastEntryId = lastEntryId
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension TranscriptStatus: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTranscriptStatus: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TranscriptStatus {
+        return
+            try TranscriptStatus(
+                revision: FfiConverterUInt64.read(from: &buf), 
+                hydrated: FfiConverterBool.read(from: &buf), 
+                entryCount: FfiConverterUInt32.read(from: &buf), 
+                pendingCount: FfiConverterUInt32.read(from: &buf), 
+                streaming: FfiConverterBool.read(from: &buf), 
+                working: FfiConverterBool.read(from: &buf), 
+                workingSinceMs: FfiConverterOptionInt64.read(from: &buf), 
+                lastEntryId: FfiConverterOptionString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TranscriptStatus, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.revision, into: &buf)
+        FfiConverterBool.write(value.hydrated, into: &buf)
+        FfiConverterUInt32.write(value.entryCount, into: &buf)
+        FfiConverterUInt32.write(value.pendingCount, into: &buf)
+        FfiConverterBool.write(value.streaming, into: &buf)
+        FfiConverterBool.write(value.working, into: &buf)
+        FfiConverterOptionInt64.write(value.workingSinceMs, into: &buf)
+        FfiConverterOptionString.write(value.lastEntryId, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTranscriptStatus_lift(_ buf: RustBuffer) throws -> TranscriptStatus {
+    return try FfiConverterTypeTranscriptStatus.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTranscriptStatus_lower(_ value: TranscriptStatus) -> RustBuffer {
+    return FfiConverterTypeTranscriptStatus.lower(value)
+}
+
+
+public struct UserImage: Equatable, Hashable {
+    /**
+     * Host path (or `pending://` ref) — read via `read_attachment`.
+     */
+    public var path: String
+    public var name: String
+    public var appshot: AppshotLabel?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * Host path (or `pending://` ref) — read via `read_attachment`.
+         */path: String, name: String, appshot: AppshotLabel?) {
+        self.path = path
+        self.name = name
+        self.appshot = appshot
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension UserImage: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeUserImage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserImage {
+        return
+            try UserImage(
+                path: FfiConverterString.read(from: &buf), 
+                name: FfiConverterString.read(from: &buf), 
+                appshot: FfiConverterOptionTypeAppshotLabel.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: UserImage, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.path, into: &buf)
+        FfiConverterString.write(value.name, into: &buf)
+        FfiConverterOptionTypeAppshotLabel.write(value.appshot, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserImage_lift(_ buf: RustBuffer) throws -> UserImage {
+    return try FfiConverterTypeUserImage.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserImage_lower(_ value: UserImage) -> RustBuffer {
+    return FfiConverterTypeUserImage.lower(value)
+}
+
+
+public struct UserInputAnswer: Equatable, Hashable {
+    public var questionId: String
+    /**
+     * Picked option labels (or free text as a single label).
+     */
+    public var labels: [String]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(questionId: String, 
+        /**
+         * Picked option labels (or free text as a single label).
+         */labels: [String]) {
+        self.questionId = questionId
+        self.labels = labels
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension UserInputAnswer: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeUserInputAnswer: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserInputAnswer {
+        return
+            try UserInputAnswer(
+                questionId: FfiConverterString.read(from: &buf), 
+                labels: FfiConverterSequenceString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: UserInputAnswer, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.questionId, into: &buf)
+        FfiConverterSequenceString.write(value.labels, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserInputAnswer_lift(_ buf: RustBuffer) throws -> UserInputAnswer {
+    return try FfiConverterTypeUserInputAnswer.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserInputAnswer_lower(_ value: UserInputAnswer) -> RustBuffer {
+    return FfiConverterTypeUserInputAnswer.lower(value)
+}
+
+
+public struct UserInputQuestion: Equatable, Hashable {
+    public var id: String
+    public var header: String
+    public var question: String
+    public var options: [String]
+    public var multiSelect: Bool
+    public var prefill: String?
+    public var multiline: Bool
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(id: String, header: String, question: String, options: [String], multiSelect: Bool, prefill: String?, multiline: Bool) {
+        self.id = id
+        self.header = header
+        self.question = question
+        self.options = options
+        self.multiSelect = multiSelect
+        self.prefill = prefill
+        self.multiline = multiline
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension UserInputQuestion: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeUserInputQuestion: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserInputQuestion {
+        return
+            try UserInputQuestion(
+                id: FfiConverterString.read(from: &buf), 
+                header: FfiConverterString.read(from: &buf), 
+                question: FfiConverterString.read(from: &buf), 
+                options: FfiConverterSequenceString.read(from: &buf), 
+                multiSelect: FfiConverterBool.read(from: &buf), 
+                prefill: FfiConverterOptionString.read(from: &buf), 
+                multiline: FfiConverterBool.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: UserInputQuestion, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.id, into: &buf)
+        FfiConverterString.write(value.header, into: &buf)
+        FfiConverterString.write(value.question, into: &buf)
+        FfiConverterSequenceString.write(value.options, into: &buf)
+        FfiConverterBool.write(value.multiSelect, into: &buf)
+        FfiConverterOptionString.write(value.prefill, into: &buf)
+        FfiConverterBool.write(value.multiline, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserInputQuestion_lift(_ buf: RustBuffer) throws -> UserInputQuestion {
+    return try FfiConverterTypeUserInputQuestion.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserInputQuestion_lower(_ value: UserInputQuestion) -> RustBuffer {
+    return FfiConverterTypeUserInputQuestion.lower(value)
+}
+
+
+/**
+ * Everything a call screen shows. Ephemeral: never log or persist captions.
+ */
+public struct VoiceCallState: Equatable, Hashable {
+    public var phase: VoiceCallPhase
+    public var orb: VoiceOrb
+    /**
+     * Full id of the host's orchestrator chat (its canonical transcript).
+     */
+    public var chatId: String?
+    public var work: VoiceCallWork
+    public var muted: Bool
+    /**
+     * The assistant's voice is playing.
+     */
+    public var speaking: Bool
+    public var caption: String
+    /**
+     * Set once the caption is a final segment; live partials have none.
+     */
+    public var captionSpeaker: VoiceSpeaker?
+    /**
+     * The utterance the caption belongs to: a change is a new speaker turn.
+     */
+    public var captionItem: String?
+    /**
+     * Normalized 0…1 peaks (microphone is 0 while muted).
+     */
+    public var microphone: Float
+    public var speaker: Float
+    /**
+     * Styles the host offers, once it reports them.
+     */
+    public var voices: [String]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(phase: VoiceCallPhase, orb: VoiceOrb, 
+        /**
+         * Full id of the host's orchestrator chat (its canonical transcript).
+         */chatId: String?, work: VoiceCallWork, muted: Bool, 
+        /**
+         * The assistant's voice is playing.
+         */speaking: Bool, caption: String, 
+        /**
+         * Set once the caption is a final segment; live partials have none.
+         */captionSpeaker: VoiceSpeaker?, 
+        /**
+         * The utterance the caption belongs to: a change is a new speaker turn.
+         */captionItem: String?, 
+        /**
+         * Normalized 0…1 peaks (microphone is 0 while muted).
+         */microphone: Float, speaker: Float, 
+        /**
+         * Styles the host offers, once it reports them.
+         */voices: [String]) {
+        self.phase = phase
+        self.orb = orb
+        self.chatId = chatId
+        self.work = work
+        self.muted = muted
+        self.speaking = speaking
+        self.caption = caption
+        self.captionSpeaker = captionSpeaker
+        self.captionItem = captionItem
+        self.microphone = microphone
+        self.speaker = speaker
+        self.voices = voices
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension VoiceCallState: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeVoiceCallState: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceCallState {
+        return
+            try VoiceCallState(
+                phase: FfiConverterTypeVoiceCallPhase.read(from: &buf), 
+                orb: FfiConverterTypeVoiceOrb.read(from: &buf), 
+                chatId: FfiConverterOptionString.read(from: &buf), 
+                work: FfiConverterTypeVoiceCallWork.read(from: &buf), 
+                muted: FfiConverterBool.read(from: &buf), 
+                speaking: FfiConverterBool.read(from: &buf), 
+                caption: FfiConverterString.read(from: &buf), 
+                captionSpeaker: FfiConverterOptionTypeVoiceSpeaker.read(from: &buf), 
+                captionItem: FfiConverterOptionString.read(from: &buf), 
+                microphone: FfiConverterFloat.read(from: &buf), 
+                speaker: FfiConverterFloat.read(from: &buf), 
+                voices: FfiConverterSequenceString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: VoiceCallState, into buf: inout [UInt8]) {
+        FfiConverterTypeVoiceCallPhase.write(value.phase, into: &buf)
+        FfiConverterTypeVoiceOrb.write(value.orb, into: &buf)
+        FfiConverterOptionString.write(value.chatId, into: &buf)
+        FfiConverterTypeVoiceCallWork.write(value.work, into: &buf)
+        FfiConverterBool.write(value.muted, into: &buf)
+        FfiConverterBool.write(value.speaking, into: &buf)
+        FfiConverterString.write(value.caption, into: &buf)
+        FfiConverterOptionTypeVoiceSpeaker.write(value.captionSpeaker, into: &buf)
+        FfiConverterOptionString.write(value.captionItem, into: &buf)
+        FfiConverterFloat.write(value.microphone, into: &buf)
+        FfiConverterFloat.write(value.speaker, into: &buf)
+        FfiConverterSequenceString.write(value.voices, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeVoiceCallState_lift(_ buf: RustBuffer) throws -> VoiceCallState {
+    return try FfiConverterTypeVoiceCallState.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeVoiceCallState_lower(_ value: VoiceCallState) -> RustBuffer {
+    return FfiConverterTypeVoiceCallState.lower(value)
+}
+
+
+public struct VoiceMediaRequest: Equatable, Hashable {
+    public var requestId: UInt64
+    public var operation: VoiceMediaOperation
+    public var sdp: String?
+    public var muted: Bool
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(requestId: UInt64, operation: VoiceMediaOperation, sdp: String?, muted: Bool) {
+        self.requestId = requestId
+        self.operation = operation
+        self.sdp = sdp
+        self.muted = muted
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension VoiceMediaRequest: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeVoiceMediaRequest: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceMediaRequest {
+        return
+            try VoiceMediaRequest(
+                requestId: FfiConverterUInt64.read(from: &buf), 
+                operation: FfiConverterTypeVoiceMediaOperation.read(from: &buf), 
+                sdp: FfiConverterOptionString.read(from: &buf), 
+                muted: FfiConverterBool.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: VoiceMediaRequest, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.requestId, into: &buf)
+        FfiConverterTypeVoiceMediaOperation.write(value.operation, into: &buf)
+        FfiConverterOptionString.write(value.sdp, into: &buf)
+        FfiConverterBool.write(value.muted, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeVoiceMediaRequest_lift(_ buf: RustBuffer) throws -> VoiceMediaRequest {
+    return try FfiConverterTypeVoiceMediaRequest.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeVoiceMediaRequest_lower(_ value: VoiceMediaRequest) -> RustBuffer {
+    return FfiConverterTypeVoiceMediaRequest.lower(value)
+}
+
+
+public struct Widget: Equatable, Hashable {
+    public var id: UInt32
+    public var kind: WidgetKind
+    public var x: Float
+    public var y: Float
+    public var w: Float
+    public var h: Float
+    public var payload: String?
+    public var scroller: UInt32?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(id: UInt32, kind: WidgetKind, x: Float, y: Float, w: Float, h: Float, payload: String?, scroller: UInt32?) {
+        self.id = id
+        self.kind = kind
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.payload = payload
+        self.scroller = scroller
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension Widget: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWidget: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Widget {
+        return
+            try Widget(
+                id: FfiConverterUInt32.read(from: &buf), 
+                kind: FfiConverterTypeWidgetKind.read(from: &buf), 
+                x: FfiConverterFloat.read(from: &buf), 
+                y: FfiConverterFloat.read(from: &buf), 
+                w: FfiConverterFloat.read(from: &buf), 
+                h: FfiConverterFloat.read(from: &buf), 
+                payload: FfiConverterOptionString.read(from: &buf), 
+                scroller: FfiConverterOptionUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: Widget, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.id, into: &buf)
+        FfiConverterTypeWidgetKind.write(value.kind, into: &buf)
+        FfiConverterFloat.write(value.x, into: &buf)
+        FfiConverterFloat.write(value.y, into: &buf)
+        FfiConverterFloat.write(value.w, into: &buf)
+        FfiConverterFloat.write(value.h, into: &buf)
+        FfiConverterOptionString.write(value.payload, into: &buf)
+        FfiConverterOptionUInt32.write(value.scroller, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWidget_lift(_ buf: RustBuffer) throws -> Widget {
+    return try FfiConverterTypeWidget.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWidget_lower(_ value: Widget) -> RustBuffer {
+    return FfiConverterTypeWidget.lower(value)
+}
+
+
+/**
+ * Everything the workspace screens render.
+ */
+public struct WorkspaceSnapshot: Equatable, Hashable {
+    public var revision: UInt64
+    public var computedAtMs: Int64
+    /**
+     * Pin/section edits allowed (sidebar prefs known).
+     */
+    public var pinsReady: Bool
+    /**
+     * The registry reached this device at least once (or demo).
+     */
+    public var synced: Bool
+    public var front: FrontPage
+    /**
+     * Creation order.
+     */
+    public var projects: [ProjectView]
+    /**
+     * Active sessions without a project.
+     */
+    public var projectless: [SessionRow]
+    public var pullRequests: PullRequestGroups
+    public var archived: [SessionRow]
+    public var devices: [DeviceView]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(revision: UInt64, computedAtMs: Int64, 
+        /**
+         * Pin/section edits allowed (sidebar prefs known).
+         */pinsReady: Bool, 
+        /**
+         * The registry reached this device at least once (or demo).
+         */synced: Bool, front: FrontPage, 
+        /**
+         * Creation order.
+         */projects: [ProjectView], 
+        /**
+         * Active sessions without a project.
+         */projectless: [SessionRow], pullRequests: PullRequestGroups, archived: [SessionRow], devices: [DeviceView]) {
+        self.revision = revision
+        self.computedAtMs = computedAtMs
+        self.pinsReady = pinsReady
+        self.synced = synced
+        self.front = front
+        self.projects = projects
+        self.projectless = projectless
+        self.pullRequests = pullRequests
+        self.archived = archived
+        self.devices = devices
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension WorkspaceSnapshot: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWorkspaceSnapshot: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WorkspaceSnapshot {
+        return
+            try WorkspaceSnapshot(
+                revision: FfiConverterUInt64.read(from: &buf), 
+                computedAtMs: FfiConverterInt64.read(from: &buf), 
+                pinsReady: FfiConverterBool.read(from: &buf), 
+                synced: FfiConverterBool.read(from: &buf), 
+                front: FfiConverterTypeFrontPage.read(from: &buf), 
+                projects: FfiConverterSequenceTypeProjectView.read(from: &buf), 
+                projectless: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
+                pullRequests: FfiConverterTypePullRequestGroups.read(from: &buf), 
+                archived: FfiConverterSequenceTypeSessionRow.read(from: &buf), 
+                devices: FfiConverterSequenceTypeDeviceView.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: WorkspaceSnapshot, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.revision, into: &buf)
+        FfiConverterInt64.write(value.computedAtMs, into: &buf)
+        FfiConverterBool.write(value.pinsReady, into: &buf)
+        FfiConverterBool.write(value.synced, into: &buf)
+        FfiConverterTypeFrontPage.write(value.front, into: &buf)
+        FfiConverterSequenceTypeProjectView.write(value.projects, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.projectless, into: &buf)
+        FfiConverterTypePullRequestGroups.write(value.pullRequests, into: &buf)
+        FfiConverterSequenceTypeSessionRow.write(value.archived, into: &buf)
+        FfiConverterSequenceTypeDeviceView.write(value.devices, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWorkspaceSnapshot_lift(_ buf: RustBuffer) throws -> WorkspaceSnapshot {
+    return try FfiConverterTypeWorkspaceSnapshot.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWorkspaceSnapshot_lower(_ value: WorkspaceSnapshot) -> RustBuffer {
+    return FfiConverterTypeWorkspaceSnapshot.lower(value)
+}
+
+
+public struct WorktreeSpec: Equatable, Hashable {
+    /**
+     * The repo to branch (the project's folder on the host).
+     */
+    public var repoPath: String
+    /**
+     * Base ref for the fresh `zeron/<name>` branch.
+     */
+    public var base: String
+    public var spaceId: String?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * The repo to branch (the project's folder on the host).
+         */repoPath: String, 
+        /**
+         * Base ref for the fresh `zeron/<name>` branch.
+         */base: String, spaceId: String?) {
+        self.repoPath = repoPath
+        self.base = base
+        self.spaceId = spaceId
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension WorktreeSpec: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWorktreeSpec: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WorktreeSpec {
+        return
+            try WorktreeSpec(
+                repoPath: FfiConverterString.read(from: &buf), 
+                base: FfiConverterString.read(from: &buf), 
+                spaceId: FfiConverterOptionString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: WorktreeSpec, into buf: inout [UInt8]) {
         FfiConverterString.write(value.repoPath, into: &buf)
         FfiConverterString.write(value.base, into: &buf)
         FfiConverterOptionString.write(value.spaceId, into: &buf)
@@ -8270,25 +9596,871 @@ public struct FfiConverterTypeWorktreeSpec: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeWorktreeSpec_lift(_ buf: RustBuffer) throws -> WorktreeSpec {
-    return try FfiConverterTypeWorktreeSpec.lift(buf)
+public func FfiConverterTypeWorktreeSpec_lift(_ buf: RustBuffer) throws -> WorktreeSpec {
+    return try FfiConverterTypeWorktreeSpec.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWorktreeSpec_lower(_ value: WorktreeSpec) -> RustBuffer {
+    return FfiConverterTypeWorktreeSpec.lower(value)
+}
+
+
+
+public enum AuthCallback: Equatable, Hashable {
+    
+    case code(code: String, state: String?
+    )
+    case error(error: String, description: String?
+    )
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AuthCallback: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAuthCallback: FfiConverterRustBuffer {
+    typealias SwiftType = AuthCallback
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthCallback {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .code(code: try FfiConverterString.read(from: &buf), state: try FfiConverterOptionString.read(from: &buf)
+        )
+        
+        case 2: return .error(error: try FfiConverterString.read(from: &buf), description: try FfiConverterOptionString.read(from: &buf)
+        )
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AuthCallback, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case let .code(code,state):
+            writeInt(&buf, Int32(1))
+            FfiConverterString.write(code, into: &buf)
+            FfiConverterOptionString.write(state, into: &buf)
+            
+        
+        case let .error(error,description):
+            writeInt(&buf, Int32(2))
+            FfiConverterString.write(error, into: &buf)
+            FfiConverterOptionString.write(description, into: &buf)
+            
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAuthCallback_lift(_ buf: RustBuffer) throws -> AuthCallback {
+    return try FfiConverterTypeAuthCallback.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAuthCallback_lower(_ value: AuthCallback) -> RustBuffer {
+    return FfiConverterTypeAuthCallback.lower(value)
+}
+
+
+
+
+public enum BoxStyle: Equatable, Hashable {
+    
+    case fill
+    /**
+     * A hairline (1 device pixel) stroke on the rect's inside edge.
+     */
+    case hairline
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension BoxStyle: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeBoxStyle: FfiConverterRustBuffer {
+    typealias SwiftType = BoxStyle
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxStyle {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .fill
+        
+        case 2: return .hairline
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: BoxStyle, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .fill:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .hairline:
+            writeInt(&buf, Int32(2))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeBoxStyle_lift(_ buf: RustBuffer) throws -> BoxStyle {
+    return try FfiConverterTypeBoxStyle.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeBoxStyle_lower(_ value: BoxStyle) -> RustBuffer {
+    return FfiConverterTypeBoxStyle.lower(value)
+}
+
+
+
+
+public enum BusyPolicy: Equatable, Hashable {
+    
+    /**
+     * Park it on the shared queue until the turn ends (default).
+     */
+    case queue
+    /**
+     * Deliver mid-turn (steer).
+     */
+    case steer
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension BusyPolicy: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeBusyPolicy: FfiConverterRustBuffer {
+    typealias SwiftType = BusyPolicy
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BusyPolicy {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .queue
+        
+        case 2: return .steer
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: BusyPolicy, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .queue:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .steer:
+            writeInt(&buf, Int32(2))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeBusyPolicy_lift(_ buf: RustBuffer) throws -> BusyPolicy {
+    return try FfiConverterTypeBusyPolicy.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeBusyPolicy_lower(_ value: BusyPolicy) -> RustBuffer {
+    return FfiConverterTypeBusyPolicy.lower(value)
+}
+
+
+
+
+public enum ChatIndicator: Equatable, Hashable {
+    
+    case working
+    case awaitingInput
+    case errored
+    /**
+     * Finished but not seen yet on any device.
+     */
+    case completed
+    case idle
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension ChatIndicator: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeChatIndicator: FfiConverterRustBuffer {
+    typealias SwiftType = ChatIndicator
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChatIndicator {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .working
+        
+        case 2: return .awaitingInput
+        
+        case 3: return .errored
+        
+        case 4: return .completed
+        
+        case 5: return .idle
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: ChatIndicator, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .working:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .awaitingInput:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .errored:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .completed:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .idle:
+            writeInt(&buf, Int32(5))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeChatIndicator_lift(_ buf: RustBuffer) throws -> ChatIndicator {
+    return try FfiConverterTypeChatIndicator.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeChatIndicator_lower(_ value: ChatIndicator) -> RustBuffer {
+    return FfiConverterTypeChatIndicator.lower(value)
+}
+
+
+
+/**
+ * Coalesced change notification. Pull the new state after receiving one;
+ * delivered on a client thread — hop to the main thread and return fast.
+ */
+
+public enum ClientEvent: Equatable, Hashable {
+    
+    /**
+     * `workspace()` advanced.
+     */
+    case workspaceChanged(revision: UInt64
+    )
+    /**
+     * A session's transcript advanced (the layout engine consumes it in Rust;
+     * this is informational for the platform).
+     */
+    case sessionChanged(chatId: String, revision: UInt64
+    )
+    /**
+     * A session's `composer()` advanced.
+     */
+    case composerChanged(chatId: String, revision: UInt64
+    )
+    case connectivityChanged(connectivity: Connectivity
+    )
+    /**
+     * The WorkOS pair rotated — persist it now (the old refresh token is spent).
+     */
+    case authRefreshed(tokens: AuthTokens
+    )
+    /**
+     * The session can't be refreshed any more — sign out.
+     */
+    case authExpired(reason: String
+    )
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension ClientEvent: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeClientEvent: FfiConverterRustBuffer {
+    typealias SwiftType = ClientEvent
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ClientEvent {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .workspaceChanged(revision: try FfiConverterUInt64.read(from: &buf)
+        )
+        
+        case 2: return .sessionChanged(chatId: try FfiConverterString.read(from: &buf), revision: try FfiConverterUInt64.read(from: &buf)
+        )
+        
+        case 3: return .composerChanged(chatId: try FfiConverterString.read(from: &buf), revision: try FfiConverterUInt64.read(from: &buf)
+        )
+        
+        case 4: return .connectivityChanged(connectivity: try FfiConverterTypeConnectivity.read(from: &buf)
+        )
+        
+        case 5: return .authRefreshed(tokens: try FfiConverterTypeAuthTokens.read(from: &buf)
+        )
+        
+        case 6: return .authExpired(reason: try FfiConverterString.read(from: &buf)
+        )
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: ClientEvent, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case let .workspaceChanged(revision):
+            writeInt(&buf, Int32(1))
+            FfiConverterUInt64.write(revision, into: &buf)
+            
+        
+        case let .sessionChanged(chatId,revision):
+            writeInt(&buf, Int32(2))
+            FfiConverterString.write(chatId, into: &buf)
+            FfiConverterUInt64.write(revision, into: &buf)
+            
+        
+        case let .composerChanged(chatId,revision):
+            writeInt(&buf, Int32(3))
+            FfiConverterString.write(chatId, into: &buf)
+            FfiConverterUInt64.write(revision, into: &buf)
+            
+        
+        case let .connectivityChanged(connectivity):
+            writeInt(&buf, Int32(4))
+            FfiConverterTypeConnectivity.write(connectivity, into: &buf)
+            
+        
+        case let .authRefreshed(tokens):
+            writeInt(&buf, Int32(5))
+            FfiConverterTypeAuthTokens.write(tokens, into: &buf)
+            
+        
+        case let .authExpired(reason):
+            writeInt(&buf, Int32(6))
+            FfiConverterString.write(reason, into: &buf)
+            
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeClientEvent_lift(_ buf: RustBuffer) throws -> ClientEvent {
+    return try FfiConverterTypeClientEvent.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeClientEvent_lower(_ value: ClientEvent) -> RustBuffer {
+    return FfiConverterTypeClientEvent.lower(value)
+}
+
+
+
+/**
+ * Paint roles. The painter maps these to its palette (light/dark).
+ */
+
+public enum ColorRole: Equatable, Hashable {
+    
+    case text
+    case textSecondary
+    case textTertiary
+    case link
+    case accent
+    case danger
+    case success
+    case warning
+    case inlineCodeText
+    case inlineCodeBackground
+    case codeText
+    case codeBackground
+    case codeBorder
+    case quoteBar
+    case rule
+    case tableBorder
+    case tableHeaderBackground
+    case userBubble
+    case chipBackground
+    case syntaxKeyword
+    case syntaxString
+    case syntaxComment
+    case syntaxNumber
+    case syntaxFunction
+    case syntaxType
+    case syntaxConstant
+    case syntaxVariable
+    case syntaxProperty
+    case syntaxOperator
+    case syntaxPunctuation
+    case syntaxTag
+    case syntaxAttribute
+    case syntaxEscape
+    /**
+     * `text_faint`: detail bodies.
+     */
+    case textFaint
+    /**
+     * `text` @ 0.85: file badge names, agent card details.
+     */
+    case textSoft
+    /**
+     * `hairline(0.12)`: the activity rail.
+     */
+    case toolRail
+    /**
+     * `ink(0.06)`: file badge fill.
+     */
+    case toolBadge
+    /**
+     * File-icon well inside a badge.
+     */
+    case toolWell
+    /**
+     * `ink(0.03)` / `hairline(0.07)` / `ink(0.08)`: subagent cards and tiles.
+     */
+    case agentCard
+    case agentCardBorder
+    case agentTile
+    /**
+     * Diff rows: wash (0.055), accent bar (0.55), hunk header.
+     */
+    case diffAddWash
+    case diffDelWash
+    case diffAddBar
+    case diffDelBar
+    case diffHunk
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension ColorRole: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeColorRole: FfiConverterRustBuffer {
+    typealias SwiftType = ColorRole
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ColorRole {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .text
+        
+        case 2: return .textSecondary
+        
+        case 3: return .textTertiary
+        
+        case 4: return .link
+        
+        case 5: return .accent
+        
+        case 6: return .danger
+        
+        case 7: return .success
+        
+        case 8: return .warning
+        
+        case 9: return .inlineCodeText
+        
+        case 10: return .inlineCodeBackground
+        
+        case 11: return .codeText
+        
+        case 12: return .codeBackground
+        
+        case 13: return .codeBorder
+        
+        case 14: return .quoteBar
+        
+        case 15: return .rule
+        
+        case 16: return .tableBorder
+        
+        case 17: return .tableHeaderBackground
+        
+        case 18: return .userBubble
+        
+        case 19: return .chipBackground
+        
+        case 20: return .syntaxKeyword
+        
+        case 21: return .syntaxString
+        
+        case 22: return .syntaxComment
+        
+        case 23: return .syntaxNumber
+        
+        case 24: return .syntaxFunction
+        
+        case 25: return .syntaxType
+        
+        case 26: return .syntaxConstant
+        
+        case 27: return .syntaxVariable
+        
+        case 28: return .syntaxProperty
+        
+        case 29: return .syntaxOperator
+        
+        case 30: return .syntaxPunctuation
+        
+        case 31: return .syntaxTag
+        
+        case 32: return .syntaxAttribute
+        
+        case 33: return .syntaxEscape
+        
+        case 34: return .textFaint
+        
+        case 35: return .textSoft
+        
+        case 36: return .toolRail
+        
+        case 37: return .toolBadge
+        
+        case 38: return .toolWell
+        
+        case 39: return .agentCard
+        
+        case 40: return .agentCardBorder
+        
+        case 41: return .agentTile
+        
+        case 42: return .diffAddWash
+        
+        case 43: return .diffDelWash
+        
+        case 44: return .diffAddBar
+        
+        case 45: return .diffDelBar
+        
+        case 46: return .diffHunk
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: ColorRole, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .text:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .textSecondary:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .textTertiary:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .link:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .accent:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .danger:
+            writeInt(&buf, Int32(6))
+        
+        
+        case .success:
+            writeInt(&buf, Int32(7))
+        
+        
+        case .warning:
+            writeInt(&buf, Int32(8))
+        
+        
+        case .inlineCodeText:
+            writeInt(&buf, Int32(9))
+        
+        
+        case .inlineCodeBackground:
+            writeInt(&buf, Int32(10))
+        
+        
+        case .codeText:
+            writeInt(&buf, Int32(11))
+        
+        
+        case .codeBackground:
+            writeInt(&buf, Int32(12))
+        
+        
+        case .codeBorder:
+            writeInt(&buf, Int32(13))
+        
+        
+        case .quoteBar:
+            writeInt(&buf, Int32(14))
+        
+        
+        case .rule:
+            writeInt(&buf, Int32(15))
+        
+        
+        case .tableBorder:
+            writeInt(&buf, Int32(16))
+        
+        
+        case .tableHeaderBackground:
+            writeInt(&buf, Int32(17))
+        
+        
+        case .userBubble:
+            writeInt(&buf, Int32(18))
+        
+        
+        case .chipBackground:
+            writeInt(&buf, Int32(19))
+        
+        
+        case .syntaxKeyword:
+            writeInt(&buf, Int32(20))
+        
+        
+        case .syntaxString:
+            writeInt(&buf, Int32(21))
+        
+        
+        case .syntaxComment:
+            writeInt(&buf, Int32(22))
+        
+        
+        case .syntaxNumber:
+            writeInt(&buf, Int32(23))
+        
+        
+        case .syntaxFunction:
+            writeInt(&buf, Int32(24))
+        
+        
+        case .syntaxType:
+            writeInt(&buf, Int32(25))
+        
+        
+        case .syntaxConstant:
+            writeInt(&buf, Int32(26))
+        
+        
+        case .syntaxVariable:
+            writeInt(&buf, Int32(27))
+        
+        
+        case .syntaxProperty:
+            writeInt(&buf, Int32(28))
+        
+        
+        case .syntaxOperator:
+            writeInt(&buf, Int32(29))
+        
+        
+        case .syntaxPunctuation:
+            writeInt(&buf, Int32(30))
+        
+        
+        case .syntaxTag:
+            writeInt(&buf, Int32(31))
+        
+        
+        case .syntaxAttribute:
+            writeInt(&buf, Int32(32))
+        
+        
+        case .syntaxEscape:
+            writeInt(&buf, Int32(33))
+        
+        
+        case .textFaint:
+            writeInt(&buf, Int32(34))
+        
+        
+        case .textSoft:
+            writeInt(&buf, Int32(35))
+        
+        
+        case .toolRail:
+            writeInt(&buf, Int32(36))
+        
+        
+        case .toolBadge:
+            writeInt(&buf, Int32(37))
+        
+        
+        case .toolWell:
+            writeInt(&buf, Int32(38))
+        
+        
+        case .agentCard:
+            writeInt(&buf, Int32(39))
+        
+        
+        case .agentCardBorder:
+            writeInt(&buf, Int32(40))
+        
+        
+        case .agentTile:
+            writeInt(&buf, Int32(41))
+        
+        
+        case .diffAddWash:
+            writeInt(&buf, Int32(42))
+        
+        
+        case .diffDelWash:
+            writeInt(&buf, Int32(43))
+        
+        
+        case .diffAddBar:
+            writeInt(&buf, Int32(44))
+        
+        
+        case .diffDelBar:
+            writeInt(&buf, Int32(45))
+        
+        
+        case .diffHunk:
+            writeInt(&buf, Int32(46))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeColorRole_lift(_ buf: RustBuffer) throws -> ColorRole {
+    return try FfiConverterTypeColorRole.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeWorktreeSpec_lower(_ value: WorktreeSpec) -> RustBuffer {
-    return FfiConverterTypeWorktreeSpec.lower(value)
+public func FfiConverterTypeColorRole_lower(_ value: ColorRole) -> RustBuffer {
+    return FfiConverterTypeColorRole.lower(value)
 }
 
 
 
-public enum AuthCallback: Equatable, Hashable {
+
+public enum ConnectivityState: Equatable, Hashable {
     
-    case code(code: String, state: String?
-    )
-    case error(error: String, description: String?
-    )
+    /**
+     * Demo / no edge transports — hide the pill.
+     */
+    case disabled
+    /**
+     * No network path (graced): sends are saved locally.
+     */
+    case offline
+    /**
+     * The registry room is down (graced).
+     */
+    case reconnecting
+    case connected
 
 
 
@@ -8297,44 +10469,50 @@ public enum AuthCallback: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension AuthCallback: Sendable {}
+extension ConnectivityState: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeAuthCallback: FfiConverterRustBuffer {
-    typealias SwiftType = AuthCallback
+public struct FfiConverterTypeConnectivityState: FfiConverterRustBuffer {
+    typealias SwiftType = ConnectivityState
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthCallback {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConnectivityState {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .code(code: try FfiConverterString.read(from: &buf), state: try FfiConverterOptionString.read(from: &buf)
-        )
+        case 1: return .disabled
         
-        case 2: return .error(error: try FfiConverterString.read(from: &buf), description: try FfiConverterOptionString.read(from: &buf)
-        )
+        case 2: return .offline
+        
+        case 3: return .reconnecting
+        
+        case 4: return .connected
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: AuthCallback, into buf: inout [UInt8]) {
+    public static func write(_ value: ConnectivityState, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .code(code,state):
+        case .disabled:
             writeInt(&buf, Int32(1))
-            FfiConverterString.write(code, into: &buf)
-            FfiConverterOptionString.write(state, into: &buf)
-            
         
-        case let .error(error,description):
+        
+        case .offline:
             writeInt(&buf, Int32(2))
-            FfiConverterString.write(error, into: &buf)
-            FfiConverterOptionString.write(description, into: &buf)
-            
+        
+        
+        case .reconnecting:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .connected:
+            writeInt(&buf, Int32(4))
+        
         }
     }
 }
@@ -8343,67 +10521,179 @@ public struct FfiConverterTypeAuthCallback: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthCallback_lift(_ buf: RustBuffer) throws -> AuthCallback {
-    return try FfiConverterTypeAuthCallback.lift(buf)
+public func FfiConverterTypeConnectivityState_lift(_ buf: RustBuffer) throws -> ConnectivityState {
+    return try FfiConverterTypeConnectivityState.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeAuthCallback_lower(_ value: AuthCallback) -> RustBuffer {
-    return FfiConverterTypeAuthCallback.lower(value)
+public func FfiConverterTypeConnectivityState_lower(_ value: ConnectivityState) -> RustBuffer {
+    return FfiConverterTypeConnectivityState.lower(value)
 }
 
 
 
+public 
+enum CoreError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
 
-public enum BoxStyle: Equatable, Hashable {
     
-    case fill
+    
+    case NotFound(message: String
+    )
+    case InvalidArgument(message: String
+    )
     /**
-     * A hairline (1 device pixel) stroke on the rect's inside edge.
+     * The host device could not be reached over the relay.
      */
-    case hairline
-
-
+    case HostUnavailable(message: String
+    )
+    case Unsupported(message: String
+    )
+    /**
+     * The host answered with an error (bad request, git failure, …).
+     */
+    case HostError(message: String
+    )
+    case Network(message: String
+    )
+    /**
+     * Credentials rejected. Irrecoverable cases also raise `AuthExpired`.
+     */
+    case Auth(message: String
+    )
+    case Storage(message: String
+    )
+    case NotImplemented(message: String
+    )
+    case Closed
+    case Internal(message: String
+    )
 
+    
 
+    
 
+    
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+    
 }
 
 #if compiler(>=6)
-extension BoxStyle: Sendable {}
+extension CoreError: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeBoxStyle: FfiConverterRustBuffer {
-    typealias SwiftType = BoxStyle
+public struct FfiConverterTypeCoreError: FfiConverterRustBuffer {
+    typealias SwiftType = CoreError
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxStyle {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CoreError {
         let variant: Int32 = try readInt(&buf)
         switch variant {
+
         
-        case 1: return .fill
-        
-        case 2: return .hairline
+
         
-        default: throw UniffiInternalError.unexpectedEnumCase
+        case 1: return .NotFound(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 2: return .InvalidArgument(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 3: return .HostUnavailable(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 4: return .Unsupported(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 5: return .HostError(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 6: return .Network(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 7: return .Auth(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 8: return .Storage(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 9: return .NotImplemented(
+            message: try FfiConverterString.read(from: &buf)
+            )
+        case 10: return .Closed
+        case 11: return .Internal(
+            message: try FfiConverterString.read(from: &buf)
+            )
+
+         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: BoxStyle, into buf: inout [UInt8]) {
+    public static func write(_ value: CoreError, into buf: inout [UInt8]) {
         switch value {
+
+        
+
         
         
-        case .fill:
+        case let .NotFound(message):
             writeInt(&buf, Int32(1))
+            FfiConverterString.write(message, into: &buf)
+            
         
-        
-        case .hairline:
+        case let .InvalidArgument(message):
             writeInt(&buf, Int32(2))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case let .HostUnavailable(message):
+            writeInt(&buf, Int32(3))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case let .Unsupported(message):
+            writeInt(&buf, Int32(4))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case let .HostError(message):
+            writeInt(&buf, Int32(5))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case let .Network(message):
+            writeInt(&buf, Int32(6))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case let .Auth(message):
+            writeInt(&buf, Int32(7))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case let .Storage(message):
+            writeInt(&buf, Int32(8))
+            FfiConverterString.write(message, into: &buf)
+            
         
+        case let .NotImplemented(message):
+            writeInt(&buf, Int32(9))
+            FfiConverterString.write(message, into: &buf)
+            
+        
+        case .Closed:
+            writeInt(&buf, Int32(10))
+        
+        
+        case let .Internal(message):
+            writeInt(&buf, Int32(11))
+            FfiConverterString.write(message, into: &buf)
+            
         }
     }
 }
@@ -8412,30 +10702,39 @@ public struct FfiConverterTypeBoxStyle: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeBoxStyle_lift(_ buf: RustBuffer) throws -> BoxStyle {
-    return try FfiConverterTypeBoxStyle.lift(buf)
+public func FfiConverterTypeCoreError_lift(_ buf: RustBuffer) throws -> CoreError {
+    return try FfiConverterTypeCoreError.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeBoxStyle_lower(_ value: BoxStyle) -> RustBuffer {
-    return FfiConverterTypeBoxStyle.lower(value)
+public func FfiConverterTypeCoreError_lower(_ value: CoreError) -> RustBuffer {
+    return FfiConverterTypeCoreError.lower(value)
 }
 
 
+/**
+ * How the client authenticates against the edge.
+ */
 
-
-public enum BusyPolicy: Equatable, Hashable {
+public enum Credentials: Equatable, Hashable {
     
     /**
-     * Park it on the shared queue until the turn ends (default).
+     * WorkOS session scoped to `org_id`.
      */
-    case queue
+    case workOs(userId: String, orgId: String, tokens: AuthTokens
+    )
     /**
-     * Deliver mid-turn (steer).
+     * `AUTH_MODE=dev` edge: the bearer is `userId@orgId`.
      */
-    case steer
+    case dev(userId: String, orgId: String
+    )
+    /**
+     * Fully offline dataset with a simulated host.
+     */
+    case demo(options: DemoOptions
+    )
 
 
 
@@ -8444,38 +10743,53 @@ public enum BusyPolicy: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension BusyPolicy: Sendable {}
+extension Credentials: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeBusyPolicy: FfiConverterRustBuffer {
-    typealias SwiftType = BusyPolicy
+public struct FfiConverterTypeCredentials: FfiConverterRustBuffer {
+    typealias SwiftType = Credentials
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BusyPolicy {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Credentials {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .queue
+        case 1: return .workOs(userId: try FfiConverterString.read(from: &buf), orgId: try FfiConverterString.read(from: &buf), tokens: try FfiConverterTypeAuthTokens.read(from: &buf)
+        )
         
-        case 2: return .steer
+        case 2: return .dev(userId: try FfiConverterString.read(from: &buf), orgId: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 3: return .demo(options: try FfiConverterTypeDemoOptions.read(from: &buf)
+        )
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: BusyPolicy, into buf: inout [UInt8]) {
+    public static func write(_ value: Credentials, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .queue:
+        case let .workOs(userId,orgId,tokens):
             writeInt(&buf, Int32(1))
+            FfiConverterString.write(userId, into: &buf)
+            FfiConverterString.write(orgId, into: &buf)
+            FfiConverterTypeAuthTokens.write(tokens, into: &buf)
+            
         
-        
-        case .steer:
+        case let .dev(userId,orgId):
             writeInt(&buf, Int32(2))
+            FfiConverterString.write(userId, into: &buf)
+            FfiConverterString.write(orgId, into: &buf)
+            
         
+        case let .demo(options):
+            writeInt(&buf, Int32(3))
+            FfiConverterTypeDemoOptions.write(options, into: &buf)
+            
         }
     }
 }
@@ -8484,30 +10798,28 @@ public struct FfiConverterTypeBusyPolicy: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeBusyPolicy_lift(_ buf: RustBuffer) throws -> BusyPolicy {
-    return try FfiConverterTypeBusyPolicy.lift(buf)
+public func FfiConverterTypeCredentials_lift(_ buf: RustBuffer) throws -> Credentials {
+    return try FfiConverterTypeCredentials.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeBusyPolicy_lower(_ value: BusyPolicy) -> RustBuffer {
-    return FfiConverterTypeBusyPolicy.lower(value)
+public func FfiConverterTypeCredentials_lower(_ value: Credentials) -> RustBuffer {
+    return FfiConverterTypeCredentials.lower(value)
 }
 
 
 
+/**
+ * Text decorations, painted relative to the run's baseline.
+ */
 
-public enum ChatIndicator: Equatable, Hashable {
+public enum Decoration: Equatable, Hashable {
     
-    case working
-    case awaitingInput
-    case errored
-    /**
-     * Finished but not seen yet on any device.
-     */
-    case completed
-    case idle
+    case none
+    case underline
+    case strikethrough
 
 
 
@@ -8516,56 +10828,44 @@ public enum ChatIndicator: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ChatIndicator: Sendable {}
+extension Decoration: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeChatIndicator: FfiConverterRustBuffer {
-    typealias SwiftType = ChatIndicator
+public struct FfiConverterTypeDecoration: FfiConverterRustBuffer {
+    typealias SwiftType = Decoration
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChatIndicator {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Decoration {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .working
-        
-        case 2: return .awaitingInput
-        
-        case 3: return .errored
+        case 1: return .none
         
-        case 4: return .completed
+        case 2: return .underline
         
-        case 5: return .idle
+        case 3: return .strikethrough
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: ChatIndicator, into buf: inout [UInt8]) {
+    public static func write(_ value: Decoration, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .working:
+        case .none:
             writeInt(&buf, Int32(1))
         
         
-        case .awaitingInput:
+        case .underline:
             writeInt(&buf, Int32(2))
         
         
-        case .errored:
+        case .strikethrough:
             writeInt(&buf, Int32(3))
         
-        
-        case .completed:
-            writeInt(&buf, Int32(4))
-        
-        
-        case .idle:
-            writeInt(&buf, Int32(5))
-        
         }
     }
 }
@@ -8574,54 +10874,34 @@ public struct FfiConverterTypeChatIndicator: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeChatIndicator_lift(_ buf: RustBuffer) throws -> ChatIndicator {
-    return try FfiConverterTypeChatIndicator.lift(buf)
+public func FfiConverterTypeDecoration_lift(_ buf: RustBuffer) throws -> Decoration {
+    return try FfiConverterTypeDecoration.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeChatIndicator_lower(_ value: ChatIndicator) -> RustBuffer {
-    return FfiConverterTypeChatIndicator.lower(value)
+public func FfiConverterTypeDecoration_lower(_ value: Decoration) -> RustBuffer {
+    return FfiConverterTypeDecoration.lower(value)
 }
 
 
 
-/**
- * Coalesced change notification. Pull the new state after receiving one;
- * delivered on a client thread — hop to the main thread and return fast.
- */
 
-public enum ClientEvent: Equatable, Hashable {
+public enum DemoFixture: Equatable, Hashable {
     
     /**
-     * `workspace()` advanced.
-     */
-    case workspaceChanged(revision: UInt64
-    )
-    /**
-     * A session's transcript advanced (the layout engine consumes it in Rust;
-     * this is informational for the platform).
-     */
-    case sessionChanged(chatId: String, revision: UInt64
-    )
-    /**
-     * A session's `composer()` advanced.
+     * Devices, projects, pinned + sectioned sessions, PRs in every state.
      */
-    case composerChanged(chatId: String, revision: UInt64
-    )
-    case connectivityChanged(connectivity: Connectivity
-    )
+    case standard
     /**
-     * The WorkOS pair rotated — persist it now (the old refresh token is spent).
+     * No projects and no sessions (empty states).
      */
-    case authRefreshed(tokens: AuthTokens
-    )
+    case noProjects
     /**
-     * The session can't be refreshed any more — sign out.
+     * Only this phone — no execution hosts.
      */
-    case authExpired(reason: String
-    )
+    case iosOnly
 
 
 
@@ -8630,76 +10910,44 @@ public enum ClientEvent: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ClientEvent: Sendable {}
+extension DemoFixture: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeClientEvent: FfiConverterRustBuffer {
-    typealias SwiftType = ClientEvent
+public struct FfiConverterTypeDemoFixture: FfiConverterRustBuffer {
+    typealias SwiftType = DemoFixture
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ClientEvent {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DemoFixture {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .workspaceChanged(revision: try FfiConverterUInt64.read(from: &buf)
-        )
-        
-        case 2: return .sessionChanged(chatId: try FfiConverterString.read(from: &buf), revision: try FfiConverterUInt64.read(from: &buf)
-        )
-        
-        case 3: return .composerChanged(chatId: try FfiConverterString.read(from: &buf), revision: try FfiConverterUInt64.read(from: &buf)
-        )
-        
-        case 4: return .connectivityChanged(connectivity: try FfiConverterTypeConnectivity.read(from: &buf)
-        )
+        case 1: return .standard
         
-        case 5: return .authRefreshed(tokens: try FfiConverterTypeAuthTokens.read(from: &buf)
-        )
+        case 2: return .noProjects
         
-        case 6: return .authExpired(reason: try FfiConverterString.read(from: &buf)
-        )
+        case 3: return .iosOnly
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: ClientEvent, into buf: inout [UInt8]) {
+    public static func write(_ value: DemoFixture, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .workspaceChanged(revision):
+        case .standard:
             writeInt(&buf, Int32(1))
-            FfiConverterUInt64.write(revision, into: &buf)
-            
         
-        case let .sessionChanged(chatId,revision):
-            writeInt(&buf, Int32(2))
-            FfiConverterString.write(chatId, into: &buf)
-            FfiConverterUInt64.write(revision, into: &buf)
-            
         
-        case let .composerChanged(chatId,revision):
-            writeInt(&buf, Int32(3))
-            FfiConverterString.write(chatId, into: &buf)
-            FfiConverterUInt64.write(revision, into: &buf)
-            
+        case .noProjects:
+            writeInt(&buf, Int32(2))
         
-        case let .connectivityChanged(connectivity):
-            writeInt(&buf, Int32(4))
-            FfiConverterTypeConnectivity.write(connectivity, into: &buf)
-            
         
-        case let .authRefreshed(tokens):
-            writeInt(&buf, Int32(5))
-            FfiConverterTypeAuthTokens.write(tokens, into: &buf)
-            
+        case .iosOnly:
+            writeInt(&buf, Int32(3))
         
-        case let .authExpired(reason):
-            writeInt(&buf, Int32(6))
-            FfiConverterString.write(reason, into: &buf)
-            
         }
     }
 }
@@ -8708,92 +10956,37 @@ public struct FfiConverterTypeClientEvent: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeClientEvent_lift(_ buf: RustBuffer) throws -> ClientEvent {
-    return try FfiConverterTypeClientEvent.lift(buf)
+public func FfiConverterTypeDemoFixture_lift(_ buf: RustBuffer) throws -> DemoFixture {
+    return try FfiConverterTypeDemoFixture.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeClientEvent_lower(_ value: ClientEvent) -> RustBuffer {
-    return FfiConverterTypeClientEvent.lower(value)
+public func FfiConverterTypeDemoFixture_lower(_ value: DemoFixture) -> RustBuffer {
+    return FfiConverterTypeDemoFixture.lower(value)
 }
 
 
 
 /**
- * Paint roles. The painter maps these to its palette (light/dark).
+ * Faces the platform registers (same bytes it hands CoreText/Skia).
  */
 
-public enum ColorRole: Equatable, Hashable {
+public enum FaceRole: Equatable, Hashable {
     
-    case text
-    case textSecondary
-    case textTertiary
-    case link
-    case accent
-    case danger
-    case success
-    case warning
-    case inlineCodeText
-    case inlineCodeBackground
-    case codeText
-    case codeBackground
-    case codeBorder
-    case quoteBar
-    case rule
-    case tableBorder
-    case tableHeaderBackground
-    case userBubble
-    case chipBackground
-    case syntaxKeyword
-    case syntaxString
-    case syntaxComment
-    case syntaxNumber
-    case syntaxFunction
-    case syntaxType
-    case syntaxConstant
-    case syntaxVariable
-    case syntaxProperty
-    case syntaxOperator
-    case syntaxPunctuation
-    case syntaxTag
-    case syntaxAttribute
-    case syntaxEscape
-    /**
-     * `text_faint`: detail bodies.
-     */
-    case textFaint
-    /**
-     * `text` @ 0.85: file badge names, agent card details.
-     */
-    case textSoft
-    /**
-     * `hairline(0.12)`: the activity rail.
-     */
-    case toolRail
-    /**
-     * `ink(0.06)`: file badge fill.
-     */
-    case toolBadge
-    /**
-     * File-icon well inside a badge.
-     */
-    case toolWell
-    /**
-     * `ink(0.03)` / `hairline(0.07)` / `ink(0.08)`: subagent cards and tiles.
-     */
-    case agentCard
-    case agentCardBorder
-    case agentTile
-    /**
-     * Diff rows: wash (0.055), accent bar (0.55), hunk header.
-     */
-    case diffAddWash
-    case diffDelWash
-    case diffAddBar
-    case diffDelBar
-    case diffHunk
+    case sans
+    case sansMedium
+    case sansSemibold
+    case sansBold
+    case sansItalic
+    case sansMediumItalic
+    case sansSemiboldItalic
+    case sansBoldItalic
+    case mono
+    case monoMedium
+    case monoSemibold
+    case monoItalic
 
 
 
@@ -8802,301 +10995,174 @@ public enum ColorRole: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ColorRole: Sendable {}
+extension FaceRole: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeColorRole: FfiConverterRustBuffer {
-    typealias SwiftType = ColorRole
+public struct FfiConverterTypeFaceRole: FfiConverterRustBuffer {
+    typealias SwiftType = FaceRole
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ColorRole {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FaceRole {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .text
-        
-        case 2: return .textSecondary
-        
-        case 3: return .textTertiary
-        
-        case 4: return .link
-        
-        case 5: return .accent
-        
-        case 6: return .danger
-        
-        case 7: return .success
-        
-        case 8: return .warning
-        
-        case 9: return .inlineCodeText
-        
-        case 10: return .inlineCodeBackground
-        
-        case 11: return .codeText
-        
-        case 12: return .codeBackground
-        
-        case 13: return .codeBorder
-        
-        case 14: return .quoteBar
-        
-        case 15: return .rule
-        
-        case 16: return .tableBorder
-        
-        case 17: return .tableHeaderBackground
-        
-        case 18: return .userBubble
-        
-        case 19: return .chipBackground
-        
-        case 20: return .syntaxKeyword
-        
-        case 21: return .syntaxString
-        
-        case 22: return .syntaxComment
-        
-        case 23: return .syntaxNumber
-        
-        case 24: return .syntaxFunction
-        
-        case 25: return .syntaxType
-        
-        case 26: return .syntaxConstant
-        
-        case 27: return .syntaxVariable
-        
-        case 28: return .syntaxProperty
-        
-        case 29: return .syntaxOperator
-        
-        case 30: return .syntaxPunctuation
-        
-        case 31: return .syntaxTag
-        
-        case 32: return .syntaxAttribute
-        
-        case 33: return .syntaxEscape
-        
-        case 34: return .textFaint
-        
-        case 35: return .textSoft
+        case 1: return .sans
         
-        case 36: return .toolRail
+        case 2: return .sansMedium
         
-        case 37: return .toolBadge
+        case 3: return .sansSemibold
         
-        case 38: return .toolWell
+        case 4: return .sansBold
         
-        case 39: return .agentCard
+        case 5: return .sansItalic
         
-        case 40: return .agentCardBorder
+        case 6: return .sansMediumItalic
         
-        case 41: return .agentTile
+        case 7: return .sansSemiboldItalic
         
-        case 42: return .diffAddWash
+        case 8: return .sansBoldItalic
         
-        case 43: return .diffDelWash
+        case 9: return .mono
         
-        case 44: return .diffAddBar
+        case 10: return .monoMedium
         
-        case 45: return .diffDelBar
+        case 11: return .monoSemibold
         
-        case 46: return .diffHunk
+        case 12: return .monoItalic
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: ColorRole, into buf: inout [UInt8]) {
+    public static func write(_ value: FaceRole, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .text:
+        case .sans:
             writeInt(&buf, Int32(1))
         
         
-        case .textSecondary:
+        case .sansMedium:
             writeInt(&buf, Int32(2))
         
         
-        case .textTertiary:
+        case .sansSemibold:
             writeInt(&buf, Int32(3))
         
         
-        case .link:
+        case .sansBold:
             writeInt(&buf, Int32(4))
         
         
-        case .accent:
+        case .sansItalic:
             writeInt(&buf, Int32(5))
         
         
-        case .danger:
+        case .sansMediumItalic:
             writeInt(&buf, Int32(6))
         
         
-        case .success:
+        case .sansSemiboldItalic:
             writeInt(&buf, Int32(7))
         
         
-        case .warning:
+        case .sansBoldItalic:
             writeInt(&buf, Int32(8))
         
         
-        case .inlineCodeText:
+        case .mono:
             writeInt(&buf, Int32(9))
         
         
-        case .inlineCodeBackground:
+        case .monoMedium:
             writeInt(&buf, Int32(10))
         
         
-        case .codeText:
+        case .monoSemibold:
             writeInt(&buf, Int32(11))
         
         
-        case .codeBackground:
+        case .monoItalic:
             writeInt(&buf, Int32(12))
         
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFaceRole_lift(_ buf: RustBuffer) throws -> FaceRole {
+    return try FfiConverterTypeFaceRole.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFaceRole_lower(_ value: FaceRole) -> RustBuffer {
+    return FfiConverterTypeFaceRole.lower(value)
+}
+
+
+
+/**
+ * Which way overflowing text fades out.
+ */
+
+public enum FadeEdge: Equatable, Hashable {
+    
+    /**
+     * Text fades to transparent across the rect, left → right, and is
+     * clipped at its right edge (single lines wider than their slot).
+     */
+    case trailing
+    /**
+     * Text fades to transparent across the rect, top → bottom (folded
+     * blocks whose last visible line continues).
+     */
+    case bottom
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension FadeEdge: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFadeEdge: FfiConverterRustBuffer {
+    typealias SwiftType = FadeEdge
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FadeEdge {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
         
-        case .codeBorder:
-            writeInt(&buf, Int32(13))
-        
-        
-        case .quoteBar:
-            writeInt(&buf, Int32(14))
-        
-        
-        case .rule:
-            writeInt(&buf, Int32(15))
-        
-        
-        case .tableBorder:
-            writeInt(&buf, Int32(16))
-        
-        
-        case .tableHeaderBackground:
-            writeInt(&buf, Int32(17))
-        
-        
-        case .userBubble:
-            writeInt(&buf, Int32(18))
-        
-        
-        case .chipBackground:
-            writeInt(&buf, Int32(19))
-        
-        
-        case .syntaxKeyword:
-            writeInt(&buf, Int32(20))
-        
-        
-        case .syntaxString:
-            writeInt(&buf, Int32(21))
-        
-        
-        case .syntaxComment:
-            writeInt(&buf, Int32(22))
-        
-        
-        case .syntaxNumber:
-            writeInt(&buf, Int32(23))
-        
-        
-        case .syntaxFunction:
-            writeInt(&buf, Int32(24))
-        
-        
-        case .syntaxType:
-            writeInt(&buf, Int32(25))
-        
-        
-        case .syntaxConstant:
-            writeInt(&buf, Int32(26))
-        
-        
-        case .syntaxVariable:
-            writeInt(&buf, Int32(27))
-        
-        
-        case .syntaxProperty:
-            writeInt(&buf, Int32(28))
-        
-        
-        case .syntaxOperator:
-            writeInt(&buf, Int32(29))
-        
-        
-        case .syntaxPunctuation:
-            writeInt(&buf, Int32(30))
-        
-        
-        case .syntaxTag:
-            writeInt(&buf, Int32(31))
-        
-        
-        case .syntaxAttribute:
-            writeInt(&buf, Int32(32))
-        
-        
-        case .syntaxEscape:
-            writeInt(&buf, Int32(33))
-        
-        
-        case .textFaint:
-            writeInt(&buf, Int32(34))
-        
-        
-        case .textSoft:
-            writeInt(&buf, Int32(35))
-        
-        
-        case .toolRail:
-            writeInt(&buf, Int32(36))
-        
-        
-        case .toolBadge:
-            writeInt(&buf, Int32(37))
-        
-        
-        case .toolWell:
-            writeInt(&buf, Int32(38))
-        
-        
-        case .agentCard:
-            writeInt(&buf, Int32(39))
-        
-        
-        case .agentCardBorder:
-            writeInt(&buf, Int32(40))
-        
-        
-        case .agentTile:
-            writeInt(&buf, Int32(41))
-        
-        
-        case .diffAddWash:
-            writeInt(&buf, Int32(42))
-        
-        
-        case .diffDelWash:
-            writeInt(&buf, Int32(43))
+        case 1: return .trailing
         
+        case 2: return .bottom
         
-        case .diffAddBar:
-            writeInt(&buf, Int32(44))
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: FadeEdge, into buf: inout [UInt8]) {
+        switch value {
         
         
-        case .diffDelBar:
-            writeInt(&buf, Int32(45))
+        case .trailing:
+            writeInt(&buf, Int32(1))
         
         
-        case .diffHunk:
-            writeInt(&buf, Int32(46))
+        case .bottom:
+            writeInt(&buf, Int32(2))
         
         }
     }
@@ -9106,35 +11172,29 @@ public struct FfiConverterTypeColorRole: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeColorRole_lift(_ buf: RustBuffer) throws -> ColorRole {
-    return try FfiConverterTypeColorRole.lift(buf)
+public func FfiConverterTypeFadeEdge_lift(_ buf: RustBuffer) throws -> FadeEdge {
+    return try FfiConverterTypeFadeEdge.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeColorRole_lower(_ value: ColorRole) -> RustBuffer {
-    return FfiConverterTypeColorRole.lower(value)
+public func FfiConverterTypeFadeEdge_lower(_ value: FadeEdge) -> RustBuffer {
+    return FfiConverterTypeFadeEdge.lower(value)
 }
 
 
 
+/**
+ * The four tuned size presets (inline 20, avatar 64, large 96, hero 128).
+ */
 
-public enum ConnectivityState: Equatable, Hashable {
+public enum OrbPreset: Equatable, Hashable {
     
-    /**
-     * Demo / no edge transports — hide the pill.
-     */
-    case disabled
-    /**
-     * No network path (graced): sends are saved locally.
-     */
-    case offline
-    /**
-     * The registry room is down (graced).
-     */
-    case reconnecting
-    case connected
+    case inline
+    case avatar
+    case large
+    case hero
 
 
 
@@ -9143,48 +11203,48 @@ public enum ConnectivityState: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension ConnectivityState: Sendable {}
+extension OrbPreset: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeConnectivityState: FfiConverterRustBuffer {
-    typealias SwiftType = ConnectivityState
+public struct FfiConverterTypeOrbPreset: FfiConverterRustBuffer {
+    typealias SwiftType = OrbPreset
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConnectivityState {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OrbPreset {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .disabled
+        case 1: return .inline
         
-        case 2: return .offline
+        case 2: return .avatar
         
-        case 3: return .reconnecting
+        case 3: return .large
         
-        case 4: return .connected
+        case 4: return .hero
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: ConnectivityState, into buf: inout [UInt8]) {
+    public static func write(_ value: OrbPreset, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .disabled:
+        case .inline:
             writeInt(&buf, Int32(1))
         
         
-        case .offline:
+        case .avatar:
             writeInt(&buf, Int32(2))
         
         
-        case .reconnecting:
+        case .large:
             writeInt(&buf, Int32(3))
         
         
-        case .connected:
+        case .hero:
             writeInt(&buf, Int32(4))
         
         }
@@ -9195,179 +11255,137 @@ public struct FfiConverterTypeConnectivityState: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeConnectivityState_lift(_ buf: RustBuffer) throws -> ConnectivityState {
-    return try FfiConverterTypeConnectivityState.lift(buf)
+public func FfiConverterTypeOrbPreset_lift(_ buf: RustBuffer) throws -> OrbPreset {
+    return try FfiConverterTypeOrbPreset.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeConnectivityState_lower(_ value: ConnectivityState) -> RustBuffer {
-    return FfiConverterTypeConnectivityState.lower(value)
+public func FfiConverterTypeOrbPreset_lower(_ value: OrbPreset) -> RustBuffer {
+    return FfiConverterTypeOrbPreset.lower(value)
 }
 
 
 
-public 
-enum CoreError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
 
+public enum PendingKind: Equatable, Hashable {
     
-    
-    case NotFound(message: String
-    )
-    case InvalidArgument(message: String
-    )
-    /**
-     * The host device could not be reached over the relay.
-     */
-    case HostUnavailable(message: String
-    )
-    case Unsupported(message: String
-    )
-    /**
-     * The host answered with an error (bad request, git failure, …).
-     */
-    case HostError(message: String
-    )
-    case Network(message: String
-    )
-    /**
-     * Credentials rejected. Irrecoverable cases also raise `AuthExpired`.
-     */
-    case Auth(message: String
-    )
-    case Storage(message: String
-    )
-    case NotImplemented(message: String
-    )
-    case Closed
-    case Internal(message: String
-    )
+    case run
+    case steer
+
+
 
-    
 
-    
 
-    
-    public var errorDescription: String? {
-        String(reflecting: self)
-    }
-    
 }
 
 #if compiler(>=6)
-extension CoreError: Sendable {}
+extension PendingKind: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeCoreError: FfiConverterRustBuffer {
-    typealias SwiftType = CoreError
+public struct FfiConverterTypePendingKind: FfiConverterRustBuffer {
+    typealias SwiftType = PendingKind
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CoreError {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PendingKind {
         let variant: Int32 = try readInt(&buf)
         switch variant {
-
         
-
+        case 1: return .run
         
-        case 1: return .NotFound(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 2: return .InvalidArgument(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 3: return .HostUnavailable(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 4: return .Unsupported(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 5: return .HostError(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 6: return .Network(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 7: return .Auth(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 8: return .Storage(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 9: return .NotImplemented(
-            message: try FfiConverterString.read(from: &buf)
-            )
-        case 10: return .Closed
-        case 11: return .Internal(
-            message: try FfiConverterString.read(from: &buf)
-            )
-
-         default: throw UniffiInternalError.unexpectedEnumCase
+        case 2: return .steer
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: CoreError, into buf: inout [UInt8]) {
+    public static func write(_ value: PendingKind, into buf: inout [UInt8]) {
         switch value {
-
         
+        
+        case .run:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .steer:
+            writeInt(&buf, Int32(2))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypePendingKind_lift(_ buf: RustBuffer) throws -> PendingKind {
+    return try FfiConverterTypePendingKind.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypePendingKind_lower(_ value: PendingKind) -> RustBuffer {
+    return FfiConverterTypePendingKind.lower(value)
+}
+
+
+
+
+public enum PullRequestState: Equatable, Hashable {
+    
+    case `open`
+    case merged
+    case closed
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension PullRequestState: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypePullRequestState: FfiConverterRustBuffer {
+    typealias SwiftType = PullRequestState
 
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PullRequestState {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
         
+        case 1: return .`open`
         
-        case let .NotFound(message):
-            writeInt(&buf, Int32(1))
-            FfiConverterString.write(message, into: &buf)
-            
-        
-        case let .InvalidArgument(message):
-            writeInt(&buf, Int32(2))
-            FfiConverterString.write(message, into: &buf)
-            
-        
-        case let .HostUnavailable(message):
-            writeInt(&buf, Int32(3))
-            FfiConverterString.write(message, into: &buf)
-            
+        case 2: return .merged
         
-        case let .Unsupported(message):
-            writeInt(&buf, Int32(4))
-            FfiConverterString.write(message, into: &buf)
-            
+        case 3: return .closed
         
-        case let .HostError(message):
-            writeInt(&buf, Int32(5))
-            FfiConverterString.write(message, into: &buf)
-            
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: PullRequestState, into buf: inout [UInt8]) {
+        switch value {
         
-        case let .Network(message):
-            writeInt(&buf, Int32(6))
-            FfiConverterString.write(message, into: &buf)
-            
         
-        case let .Auth(message):
-            writeInt(&buf, Int32(7))
-            FfiConverterString.write(message, into: &buf)
-            
+        case .`open`:
+            writeInt(&buf, Int32(1))
         
-        case let .Storage(message):
-            writeInt(&buf, Int32(8))
-            FfiConverterString.write(message, into: &buf)
-            
         
-        case let .NotImplemented(message):
-            writeInt(&buf, Int32(9))
-            FfiConverterString.write(message, into: &buf)
-            
+        case .merged:
+            writeInt(&buf, Int32(2))
         
-        case .Closed:
-            writeInt(&buf, Int32(10))
         
+        case .closed:
+            writeInt(&buf, Int32(3))
         
-        case let .Internal(message):
-            writeInt(&buf, Int32(11))
-            FfiConverterString.write(message, into: &buf)
-            
         }
     }
 }
@@ -9376,39 +11394,38 @@ public struct FfiConverterTypeCoreError: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeCoreError_lift(_ buf: RustBuffer) throws -> CoreError {
-    return try FfiConverterTypeCoreError.lift(buf)
+public func FfiConverterTypePullRequestState_lift(_ buf: RustBuffer) throws -> PullRequestState {
+    return try FfiConverterTypePullRequestState.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeCoreError_lower(_ value: CoreError) -> RustBuffer {
-    return FfiConverterTypeCoreError.lower(value)
+public func FfiConverterTypePullRequestState_lower(_ value: PullRequestState) -> RustBuffer {
+    return FfiConverterTypePullRequestState.lower(value)
 }
 
 
-/**
- * How the client authenticates against the edge.
- */
 
-public enum Credentials: Equatable, Hashable {
+
+public enum QueueEditAction: Equatable, Hashable {
     
     /**
-     * WorkOS session scoped to `org_id`.
+     * Save the new text.
      */
-    case workOs(userId: String, orgId: String, tokens: AuthTokens
-    )
+    case commit
     /**
-     * `AUTH_MODE=dev` edge: the bearer is `userId@orgId`.
+     * Keep the old text, release the row.
      */
-    case dev(userId: String, orgId: String
-    )
+    case cancel
     /**
-     * Fully offline dataset with a simulated host.
+     * Delete the row.
      */
-    case demo(options: DemoOptions
-    )
+    case discard
+    /**
+     * Release without changing anything.
+     */
+    case release
 
 
 
@@ -9417,53 +11434,50 @@ public enum Credentials: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension Credentials: Sendable {}
+extension QueueEditAction: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeCredentials: FfiConverterRustBuffer {
-    typealias SwiftType = Credentials
+public struct FfiConverterTypeQueueEditAction: FfiConverterRustBuffer {
+    typealias SwiftType = QueueEditAction
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Credentials {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditAction {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .workOs(userId: try FfiConverterString.read(from: &buf), orgId: try FfiConverterString.read(from: &buf), tokens: try FfiConverterTypeAuthTokens.read(from: &buf)
-        )
+        case 1: return .commit
         
-        case 2: return .dev(userId: try FfiConverterString.read(from: &buf), orgId: try FfiConverterString.read(from: &buf)
-        )
+        case 2: return .cancel
         
-        case 3: return .demo(options: try FfiConverterTypeDemoOptions.read(from: &buf)
-        )
+        case 3: return .discard
+        
+        case 4: return .release
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: Credentials, into buf: inout [UInt8]) {
+    public static func write(_ value: QueueEditAction, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .workOs(userId,orgId,tokens):
+        case .commit:
             writeInt(&buf, Int32(1))
-            FfiConverterString.write(userId, into: &buf)
-            FfiConverterString.write(orgId, into: &buf)
-            FfiConverterTypeAuthTokens.write(tokens, into: &buf)
-            
         
-        case let .dev(userId,orgId):
+        
+        case .cancel:
             writeInt(&buf, Int32(2))
-            FfiConverterString.write(userId, into: &buf)
-            FfiConverterString.write(orgId, into: &buf)
-            
         
-        case let .demo(options):
+        
+        case .discard:
             writeInt(&buf, Int32(3))
-            FfiConverterTypeDemoOptions.write(options, into: &buf)
-            
+        
+        
+        case .release:
+            writeInt(&buf, Int32(4))
+        
         }
     }
 }
@@ -9472,28 +11486,33 @@ public struct FfiConverterTypeCredentials: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeCredentials_lift(_ buf: RustBuffer) throws -> Credentials {
-    return try FfiConverterTypeCredentials.lift(buf)
+public func FfiConverterTypeQueueEditAction_lift(_ buf: RustBuffer) throws -> QueueEditAction {
+    return try FfiConverterTypeQueueEditAction.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeCredentials_lower(_ value: Credentials) -> RustBuffer {
-    return FfiConverterTypeCredentials.lower(value)
+public func FfiConverterTypeQueueEditAction_lower(_ value: QueueEditAction) -> RustBuffer {
+    return FfiConverterTypeQueueEditAction.lower(value)
 }
 
 
 
-/**
- * Text decorations, painted relative to the run's baseline.
- */
 
-public enum Decoration: Equatable, Hashable {
+public enum QueueEditFinish: Equatable, Hashable {
     
-    case none
-    case underline
-    case strikethrough
+    case finished
+    /**
+     * The row changed under the lease.
+     */
+    case conflict
+    case missing
+    /**
+     * The lease was superseded or expired.
+     */
+    case lost
+    case unavailable
 
 
 
@@ -9502,44 +11521,56 @@ public enum Decoration: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension Decoration: Sendable {}
+extension QueueEditFinish: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeDecoration: FfiConverterRustBuffer {
-    typealias SwiftType = Decoration
+public struct FfiConverterTypeQueueEditFinish: FfiConverterRustBuffer {
+    typealias SwiftType = QueueEditFinish
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Decoration {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditFinish {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .none
+        case 1: return .finished
         
-        case 2: return .underline
+        case 2: return .conflict
         
-        case 3: return .strikethrough
+        case 3: return .missing
+        
+        case 4: return .lost
+        
+        case 5: return .unavailable
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: Decoration, into buf: inout [UInt8]) {
+    public static func write(_ value: QueueEditFinish, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .none:
+        case .finished:
             writeInt(&buf, Int32(1))
         
         
-        case .underline:
+        case .conflict:
             writeInt(&buf, Int32(2))
         
         
-        case .strikethrough:
+        case .missing:
             writeInt(&buf, Int32(3))
         
+        
+        case .lost:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .unavailable:
+            writeInt(&buf, Int32(5))
+        
         }
     }
 }
@@ -9548,34 +11579,36 @@ public struct FfiConverterTypeDecoration: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDecoration_lift(_ buf: RustBuffer) throws -> Decoration {
-    return try FfiConverterTypeDecoration.lift(buf)
+public func FfiConverterTypeQueueEditFinish_lift(_ buf: RustBuffer) throws -> QueueEditFinish {
+    return try FfiConverterTypeQueueEditFinish.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDecoration_lower(_ value: Decoration) -> RustBuffer {
-    return FfiConverterTypeDecoration.lower(value)
+public func FfiConverterTypeQueueEditFinish_lower(_ value: QueueEditFinish) -> RustBuffer {
+    return FfiConverterTypeQueueEditFinish.lower(value)
 }
 
 
 
 
-public enum DemoFixture: Equatable, Hashable {
+public enum QueueEditStart: Equatable, Hashable {
     
+    case acquired(lease: QueueEditLease
+    )
     /**
-     * Devices, projects, pinned + sectioned sessions, PRs in every state.
+     * Another editor holds the row.
      */
-    case standard
+    case locked
     /**
-     * No projects and no sessions (empty states).
+     * The row left the queue.
      */
-    case noProjects
+    case missing
     /**
-     * Only this phone — no execution hosts.
+     * Host unreachable / capability missing.
      */
-    case iosOnly
+    case unavailable
 
 
 
@@ -9584,44 +11617,52 @@ public enum DemoFixture: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension DemoFixture: Sendable {}
+extension QueueEditStart: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeDemoFixture: FfiConverterRustBuffer {
-    typealias SwiftType = DemoFixture
+public struct FfiConverterTypeQueueEditStart: FfiConverterRustBuffer {
+    typealias SwiftType = QueueEditStart
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DemoFixture {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditStart {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .standard
+        case 1: return .acquired(lease: try FfiConverterTypeQueueEditLease.read(from: &buf)
+        )
         
-        case 2: return .noProjects
+        case 2: return .locked
         
-        case 3: return .iosOnly
+        case 3: return .missing
+        
+        case 4: return .unavailable
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: DemoFixture, into buf: inout [UInt8]) {
+    public static func write(_ value: QueueEditStart, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .standard:
+        case let .acquired(lease):
             writeInt(&buf, Int32(1))
+            FfiConverterTypeQueueEditLease.write(lease, into: &buf)
+            
         
-        
-        case .noProjects:
+        case .locked:
             writeInt(&buf, Int32(2))
         
         
-        case .iosOnly:
+        case .missing:
             writeInt(&buf, Int32(3))
         
+        
+        case .unavailable:
+            writeInt(&buf, Int32(4))
+        
         }
     }
 }
@@ -9630,37 +11671,32 @@ public struct FfiConverterTypeDemoFixture: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDemoFixture_lift(_ buf: RustBuffer) throws -> DemoFixture {
-    return try FfiConverterTypeDemoFixture.lift(buf)
+public func FfiConverterTypeQueueEditStart_lift(_ buf: RustBuffer) throws -> QueueEditStart {
+    return try FfiConverterTypeQueueEditStart.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeDemoFixture_lower(_ value: DemoFixture) -> RustBuffer {
-    return FfiConverterTypeDemoFixture.lower(value)
+public func FfiConverterTypeQueueEditStart_lower(_ value: QueueEditStart) -> RustBuffer {
+    return FfiConverterTypeQueueEditStart.lower(value)
 }
 
 
 
-/**
- * Faces the platform registers (same bytes it hands CoreText/Skia).
- */
 
-public enum FaceRole: Equatable, Hashable {
+public enum QueueGate: Equatable, Hashable {
     
-    case sans
-    case sansMedium
-    case sansSemibold
-    case sansBold
-    case sansItalic
-    case sansMediumItalic
-    case sansSemiboldItalic
-    case sansBoldItalic
-    case mono
-    case monoMedium
-    case monoSemibold
-    case monoItalic
+    /**
+     * Someone holds an edit lease; the row won't deliver until released.
+     */
+    case editing(ownerDeviceId: String, expiresAtMs: Int64, mine: Bool
+    )
+    /**
+     * A lease lapsed — a person must review before it sends.
+     */
+    case reviewRequired(ownerDeviceId: String
+    )
 
 
 
@@ -9669,98 +11705,44 @@ public enum FaceRole: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FaceRole: Sendable {}
+extension QueueGate: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFaceRole: FfiConverterRustBuffer {
-    typealias SwiftType = FaceRole
+public struct FfiConverterTypeQueueGate: FfiConverterRustBuffer {
+    typealias SwiftType = QueueGate
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FaceRole {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueGate {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .sans
-        
-        case 2: return .sansMedium
-        
-        case 3: return .sansSemibold
-        
-        case 4: return .sansBold
-        
-        case 5: return .sansItalic
-        
-        case 6: return .sansMediumItalic
-        
-        case 7: return .sansSemiboldItalic
-        
-        case 8: return .sansBoldItalic
-        
-        case 9: return .mono
-        
-        case 10: return .monoMedium
-        
-        case 11: return .monoSemibold
+        case 1: return .editing(ownerDeviceId: try FfiConverterString.read(from: &buf), expiresAtMs: try FfiConverterInt64.read(from: &buf), mine: try FfiConverterBool.read(from: &buf)
+        )
         
-        case 12: return .monoItalic
+        case 2: return .reviewRequired(ownerDeviceId: try FfiConverterString.read(from: &buf)
+        )
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: FaceRole, into buf: inout [UInt8]) {
+    public static func write(_ value: QueueGate, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .sans:
+        case let .editing(ownerDeviceId,expiresAtMs,mine):
             writeInt(&buf, Int32(1))
+            FfiConverterString.write(ownerDeviceId, into: &buf)
+            FfiConverterInt64.write(expiresAtMs, into: &buf)
+            FfiConverterBool.write(mine, into: &buf)
+            
         
-        
-        case .sansMedium:
+        case let .reviewRequired(ownerDeviceId):
             writeInt(&buf, Int32(2))
-        
-        
-        case .sansSemibold:
-            writeInt(&buf, Int32(3))
-        
-        
-        case .sansBold:
-            writeInt(&buf, Int32(4))
-        
-        
-        case .sansItalic:
-            writeInt(&buf, Int32(5))
-        
-        
-        case .sansMediumItalic:
-            writeInt(&buf, Int32(6))
-        
-        
-        case .sansSemiboldItalic:
-            writeInt(&buf, Int32(7))
-        
-        
-        case .sansBoldItalic:
-            writeInt(&buf, Int32(8))
-        
-        
-        case .mono:
-            writeInt(&buf, Int32(9))
-        
-        
-        case .monoMedium:
-            writeInt(&buf, Int32(10))
-        
-        
-        case .monoSemibold:
-            writeInt(&buf, Int32(11))
-        
-        
-        case .monoItalic:
-            writeInt(&buf, Int32(12))
-        
+            FfiConverterString.write(ownerDeviceId, into: &buf)
+            
         }
     }
 }
@@ -9769,35 +11751,31 @@ public struct FfiConverterTypeFaceRole: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFaceRole_lift(_ buf: RustBuffer) throws -> FaceRole {
-    return try FfiConverterTypeFaceRole.lift(buf)
+public func FfiConverterTypeQueueGate_lift(_ buf: RustBuffer) throws -> QueueGate {
+    return try FfiConverterTypeQueueGate.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFaceRole_lower(_ value: FaceRole) -> RustBuffer {
-    return FfiConverterTypeFaceRole.lower(value)
+public func FfiConverterTypeQueueGate_lower(_ value: QueueGate) -> RustBuffer {
+    return FfiConverterTypeQueueGate.lower(value)
 }
 
 
 
 /**
- * Which way overflowing text fades out.
+ * Row kinds the painter may style differently (e.g. context menus).
  */
 
-public enum FadeEdge: Equatable, Hashable {
+public enum RowKind: Equatable, Hashable {
     
-    /**
-     * Text fades to transparent across the rect, left → right, and is
-     * clipped at its right edge (single lines wider than their slot).
-     */
-    case trailing
-    /**
-     * Text fades to transparent across the rect, top → bottom (folded
-     * blocks whose last visible line continues).
-     */
-    case bottom
+    case markdown
+    case user
+    case tools
+    case chip
+    case image
+    case working
 
 
 
@@ -9806,38 +11784,62 @@ public enum FadeEdge: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension FadeEdge: Sendable {}
+extension RowKind: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeFadeEdge: FfiConverterRustBuffer {
-    typealias SwiftType = FadeEdge
+public struct FfiConverterTypeRowKind: FfiConverterRustBuffer {
+    typealias SwiftType = RowKind
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FadeEdge {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RowKind {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .trailing
+        case 1: return .markdown
         
-        case 2: return .bottom
+        case 2: return .user
+        
+        case 3: return .tools
+        
+        case 4: return .chip
+        
+        case 5: return .image
+        
+        case 6: return .working
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: FadeEdge, into buf: inout [UInt8]) {
+    public static func write(_ value: RowKind, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .trailing:
+        case .markdown:
             writeInt(&buf, Int32(1))
         
         
-        case .bottom:
+        case .user:
             writeInt(&buf, Int32(2))
         
+        
+        case .tools:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .chip:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .image:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .working:
+            writeInt(&buf, Int32(6))
+        
         }
     }
 }
@@ -9846,24 +11848,25 @@ public struct FfiConverterTypeFadeEdge: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFadeEdge_lift(_ buf: RustBuffer) throws -> FadeEdge {
-    return try FfiConverterTypeFadeEdge.lift(buf)
+public func FfiConverterTypeRowKind_lift(_ buf: RustBuffer) throws -> RowKind {
+    return try FfiConverterTypeRowKind.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeFadeEdge_lower(_ value: FadeEdge) -> RustBuffer {
-    return FfiConverterTypeFadeEdge.lower(value)
+public func FfiConverterTypeRowKind_lower(_ value: RowKind) -> RustBuffer {
+    return FfiConverterTypeRowKind.lower(value)
 }
 
 
 
 
-public enum PendingKind: Equatable, Hashable {
+public enum SandboxLevel: Equatable, Hashable {
     
-    case run
-    case steer
+    case readOnly
+    case workspaceWrite
+    case dangerFullAccess
 
 
 
@@ -9872,38 +11875,44 @@ public enum PendingKind: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension PendingKind: Sendable {}
+extension SandboxLevel: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypePendingKind: FfiConverterRustBuffer {
-    typealias SwiftType = PendingKind
+public struct FfiConverterTypeSandboxLevel: FfiConverterRustBuffer {
+    typealias SwiftType = SandboxLevel
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PendingKind {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SandboxLevel {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .run
+        case 1: return .readOnly
         
-        case 2: return .steer
+        case 2: return .workspaceWrite
+        
+        case 3: return .dangerFullAccess
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: PendingKind, into buf: inout [UInt8]) {
+    public static func write(_ value: SandboxLevel, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .run:
+        case .readOnly:
             writeInt(&buf, Int32(1))
         
         
-        case .steer:
+        case .workspaceWrite:
             writeInt(&buf, Int32(2))
         
+        
+        case .dangerFullAccess:
+            writeInt(&buf, Int32(3))
+        
         }
     }
 }
@@ -9912,25 +11921,26 @@ public struct FfiConverterTypePendingKind: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePendingKind_lift(_ buf: RustBuffer) throws -> PendingKind {
-    return try FfiConverterTypePendingKind.lift(buf)
+public func FfiConverterTypeSandboxLevel_lift(_ buf: RustBuffer) throws -> SandboxLevel {
+    return try FfiConverterTypeSandboxLevel.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePendingKind_lower(_ value: PendingKind) -> RustBuffer {
-    return FfiConverterTypePendingKind.lower(value)
+public func FfiConverterTypeSandboxLevel_lower(_ value: SandboxLevel) -> RustBuffer {
+    return FfiConverterTypeSandboxLevel.lower(value)
 }
 
 
 
 
-public enum PullRequestState: Equatable, Hashable {
+public enum SearchField: Equatable, Hashable {
     
-    case `open`
-    case merged
-    case closed
+    case title
+    case project
+    case branch
+    case preview
 
 
 
@@ -9939,44 +11949,50 @@ public enum PullRequestState: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension PullRequestState: Sendable {}
+extension SearchField: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypePullRequestState: FfiConverterRustBuffer {
-    typealias SwiftType = PullRequestState
+public struct FfiConverterTypeSearchField: FfiConverterRustBuffer {
+    typealias SwiftType = SearchField
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PullRequestState {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SearchField {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .`open`
+        case 1: return .title
         
-        case 2: return .merged
+        case 2: return .project
         
-        case 3: return .closed
+        case 3: return .branch
+        
+        case 4: return .preview
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: PullRequestState, into buf: inout [UInt8]) {
+    public static func write(_ value: SearchField, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .`open`:
+        case .title:
             writeInt(&buf, Int32(1))
         
         
-        case .merged:
+        case .project:
             writeInt(&buf, Int32(2))
         
         
-        case .closed:
+        case .branch:
             writeInt(&buf, Int32(3))
         
+        
+        case .preview:
+            writeInt(&buf, Int32(4))
+        
         }
     }
 }
@@ -9985,38 +12001,37 @@ public struct FfiConverterTypePullRequestState: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePullRequestState_lift(_ buf: RustBuffer) throws -> PullRequestState {
-    return try FfiConverterTypePullRequestState.lift(buf)
+public func FfiConverterTypeSearchField_lift(_ buf: RustBuffer) throws -> SearchField {
+    return try FfiConverterTypeSearchField.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypePullRequestState_lower(_ value: PullRequestState) -> RustBuffer {
-    return FfiConverterTypePullRequestState.lower(value)
+public func FfiConverterTypeSearchField_lower(_ value: SearchField) -> RustBuffer {
+    return FfiConverterTypeSearchField.lower(value)
 }
 
 
 
 
-public enum QueueEditAction: Equatable, Hashable {
+public enum SendOutcome: Equatable, Hashable {
     
     /**
-     * Save the new text.
-     */
-    case commit
-    /**
-     * Keep the old text, release the row.
+     * A new turn was requested; the echo's id is `message_id`.
      */
-    case cancel
+    case started(messageId: String
+    )
     /**
-     * Delete the row.
+     * Delivered into the live turn.
      */
-    case discard
+    case steered(messageId: String
+    )
     /**
-     * Release without changing anything.
+     * Parked on the shared queue.
      */
-    case release
+    case queued(queueId: String
+    )
 
 
 
@@ -10025,50 +12040,50 @@ public enum QueueEditAction: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension QueueEditAction: Sendable {}
+extension SendOutcome: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeQueueEditAction: FfiConverterRustBuffer {
-    typealias SwiftType = QueueEditAction
+public struct FfiConverterTypeSendOutcome: FfiConverterRustBuffer {
+    typealias SwiftType = SendOutcome
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditAction {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SendOutcome {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .commit
-        
-        case 2: return .cancel
+        case 1: return .started(messageId: try FfiConverterString.read(from: &buf)
+        )
         
-        case 3: return .discard
+        case 2: return .steered(messageId: try FfiConverterString.read(from: &buf)
+        )
         
-        case 4: return .release
+        case 3: return .queued(queueId: try FfiConverterString.read(from: &buf)
+        )
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: QueueEditAction, into buf: inout [UInt8]) {
+    public static func write(_ value: SendOutcome, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .commit:
+        case let .started(messageId):
             writeInt(&buf, Int32(1))
+            FfiConverterString.write(messageId, into: &buf)
+            
         
-        
-        case .cancel:
+        case let .steered(messageId):
             writeInt(&buf, Int32(2))
+            FfiConverterString.write(messageId, into: &buf)
+            
         
-        
-        case .discard:
+        case let .queued(queueId):
             writeInt(&buf, Int32(3))
-        
-        
-        case .release:
-            writeInt(&buf, Int32(4))
-        
+            FfiConverterString.write(queueId, into: &buf)
+            
         }
     }
 }
@@ -10077,33 +12092,31 @@ public struct FfiConverterTypeQueueEditAction: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditAction_lift(_ buf: RustBuffer) throws -> QueueEditAction {
-    return try FfiConverterTypeQueueEditAction.lift(buf)
+public func FfiConverterTypeSendOutcome_lift(_ buf: RustBuffer) throws -> SendOutcome {
+    return try FfiConverterTypeSendOutcome.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditAction_lower(_ value: QueueEditAction) -> RustBuffer {
-    return FfiConverterTypeQueueEditAction.lower(value)
+public func FfiConverterTypeSendOutcome_lower(_ value: SendOutcome) -> RustBuffer {
+    return FfiConverterTypeSendOutcome.lower(value)
 }
 
 
 
 
-public enum QueueEditFinish: Equatable, Hashable {
+public enum SendState: Equatable, Hashable {
     
-    case finished
+    case sending
     /**
-     * The row changed under the lease.
+     * Durable, waiting on a degraded path.
      */
-    case conflict
-    case missing
+    case queued
     /**
-     * The lease was superseded or expired.
+     * "Not delivered — retry".
      */
-    case lost
-    case unavailable
+    case failed
 
 
 
@@ -10112,56 +12125,44 @@ public enum QueueEditFinish: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension QueueEditFinish: Sendable {}
+extension SendState: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeQueueEditFinish: FfiConverterRustBuffer {
-    typealias SwiftType = QueueEditFinish
+public struct FfiConverterTypeSendState: FfiConverterRustBuffer {
+    typealias SwiftType = SendState
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditFinish {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SendState {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .finished
-        
-        case 2: return .conflict
-        
-        case 3: return .missing
+        case 1: return .sending
         
-        case 4: return .lost
+        case 2: return .queued
         
-        case 5: return .unavailable
+        case 3: return .failed
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: QueueEditFinish, into buf: inout [UInt8]) {
+    public static func write(_ value: SendState, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .finished:
+        case .sending:
             writeInt(&buf, Int32(1))
         
         
-        case .conflict:
+        case .queued:
             writeInt(&buf, Int32(2))
         
         
-        case .missing:
+        case .failed:
             writeInt(&buf, Int32(3))
         
-        
-        case .lost:
-            writeInt(&buf, Int32(4))
-        
-        
-        case .unavailable:
-            writeInt(&buf, Int32(5))
-        
         }
     }
 }
@@ -10170,36 +12171,35 @@ public struct FfiConverterTypeQueueEditFinish: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditFinish_lift(_ buf: RustBuffer) throws -> QueueEditFinish {
-    return try FfiConverterTypeQueueEditFinish.lift(buf)
+public func FfiConverterTypeSendState_lift(_ buf: RustBuffer) throws -> SendState {
+    return try FfiConverterTypeSendState.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditFinish_lower(_ value: QueueEditFinish) -> RustBuffer {
-    return FfiConverterTypeQueueEditFinish.lower(value)
+public func FfiConverterTypeSendState_lower(_ value: SendState) -> RustBuffer {
+    return FfiConverterTypeSendState.lower(value)
 }
 
 
 
+/**
+ * Where a new session runs.
+ */
 
-public enum QueueEditStart: Equatable, Hashable {
+public enum SessionTarget: Equatable, Hashable {
     
-    case acquired(lease: QueueEditLease
-    )
-    /**
-     * Another editor holds the row.
-     */
-    case locked
     /**
-     * The row left the queue.
+     * In a project (host = its device, cwd = its folder or `cwd` override).
      */
-    case missing
+    case project(spaceId: String
+    )
     /**
-     * Host unreachable / capability missing.
+     * No project: the chosen host's home folder.
      */
-    case unavailable
+    case projectless(deviceId: String
+    )
 
 
 
@@ -10208,52 +12208,42 @@ public enum QueueEditStart: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension QueueEditStart: Sendable {}
+extension SessionTarget: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeQueueEditStart: FfiConverterRustBuffer {
-    typealias SwiftType = QueueEditStart
+public struct FfiConverterTypeSessionTarget: FfiConverterRustBuffer {
+    typealias SwiftType = SessionTarget
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueEditStart {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SessionTarget {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .acquired(lease: try FfiConverterTypeQueueEditLease.read(from: &buf)
+        case 1: return .project(spaceId: try FfiConverterString.read(from: &buf)
         )
         
-        case 2: return .locked
-        
-        case 3: return .missing
-        
-        case 4: return .unavailable
+        case 2: return .projectless(deviceId: try FfiConverterString.read(from: &buf)
+        )
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: QueueEditStart, into buf: inout [UInt8]) {
+    public static func write(_ value: SessionTarget, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .acquired(lease):
+        case let .project(spaceId):
             writeInt(&buf, Int32(1))
-            FfiConverterTypeQueueEditLease.write(lease, into: &buf)
+            FfiConverterString.write(spaceId, into: &buf)
             
         
-        case .locked:
+        case let .projectless(deviceId):
             writeInt(&buf, Int32(2))
-        
-        
-        case .missing:
-            writeInt(&buf, Int32(3))
-        
-        
-        case .unavailable:
-            writeInt(&buf, Int32(4))
-        
+            FfiConverterString.write(deviceId, into: &buf)
+            
         }
     }
 }
@@ -10262,32 +12252,30 @@ public struct FfiConverterTypeQueueEditStart: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditStart_lift(_ buf: RustBuffer) throws -> QueueEditStart {
-    return try FfiConverterTypeQueueEditStart.lift(buf)
+public func FfiConverterTypeSessionTarget_lift(_ buf: RustBuffer) throws -> SessionTarget {
+    return try FfiConverterTypeSessionTarget.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueEditStart_lower(_ value: QueueEditStart) -> RustBuffer {
-    return FfiConverterTypeQueueEditStart.lower(value)
+public func FfiConverterTypeSessionTarget_lower(_ value: SessionTarget) -> RustBuffer {
+    return FfiConverterTypeSessionTarget.lower(value)
 }
 
 
 
 
-public enum QueueGate: Equatable, Hashable {
+public enum StreamSpeed: Equatable, Hashable {
     
     /**
-     * Someone holds an edit lease; the row won't deliver until released.
+     * Word by word at 30–140ms.
      */
-    case editing(ownerDeviceId: String, expiresAtMs: Int64, mine: Bool
-    )
+    case realistic
     /**
-     * A lease lapsed — a person must review before it sends.
+     * ~4ms per word (benchmarks).
      */
-    case reviewRequired(ownerDeviceId: String
-    )
+    case fast
 
 
 
@@ -10296,44 +12284,38 @@ public enum QueueGate: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension QueueGate: Sendable {}
+extension StreamSpeed: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeQueueGate: FfiConverterRustBuffer {
-    typealias SwiftType = QueueGate
+public struct FfiConverterTypeStreamSpeed: FfiConverterRustBuffer {
+    typealias SwiftType = StreamSpeed
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> QueueGate {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StreamSpeed {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .editing(ownerDeviceId: try FfiConverterString.read(from: &buf), expiresAtMs: try FfiConverterInt64.read(from: &buf), mine: try FfiConverterBool.read(from: &buf)
-        )
+        case 1: return .realistic
         
-        case 2: return .reviewRequired(ownerDeviceId: try FfiConverterString.read(from: &buf)
-        )
+        case 2: return .fast
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: QueueGate, into buf: inout [UInt8]) {
+    public static func write(_ value: StreamSpeed, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .editing(ownerDeviceId,expiresAtMs,mine):
+        case .realistic:
             writeInt(&buf, Int32(1))
-            FfiConverterString.write(ownerDeviceId, into: &buf)
-            FfiConverterInt64.write(expiresAtMs, into: &buf)
-            FfiConverterBool.write(mine, into: &buf)
-            
         
-        case let .reviewRequired(ownerDeviceId):
+        
+        case .fast:
             writeInt(&buf, Int32(2))
-            FfiConverterString.write(ownerDeviceId, into: &buf)
-            
+        
         }
     }
 }
@@ -10342,31 +12324,33 @@ public struct FfiConverterTypeQueueGate: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueGate_lift(_ buf: RustBuffer) throws -> QueueGate {
-    return try FfiConverterTypeQueueGate.lift(buf)
+public func FfiConverterTypeStreamSpeed_lift(_ buf: RustBuffer) throws -> StreamSpeed {
+    return try FfiConverterTypeStreamSpeed.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeQueueGate_lower(_ value: QueueGate) -> RustBuffer {
-    return FfiConverterTypeQueueGate.lower(value)
+public func FfiConverterTypeStreamSpeed_lower(_ value: StreamSpeed) -> RustBuffer {
+    return FfiConverterTypeStreamSpeed.lower(value)
 }
 
 
 
-/**
- * Row kinds the painter may style differently (e.g. context menus).
- */
 
-public enum RowKind: Equatable, Hashable {
+public enum TranscriptScale: Equatable, Hashable {
     
-    case markdown
-    case user
-    case tools
-    case chip
-    case image
-    case working
+    case normal
+    /**
+     * 120 synthetic turns.
+     */
+    case big
+    /**
+     * 600 synthetic turns.
+     */
+    case huge
+    case turns(count: UInt32
+    )
 
 
 
@@ -10375,62 +12359,52 @@ public enum RowKind: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension RowKind: Sendable {}
+extension TranscriptScale: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeRowKind: FfiConverterRustBuffer {
-    typealias SwiftType = RowKind
+public struct FfiConverterTypeTranscriptScale: FfiConverterRustBuffer {
+    typealias SwiftType = TranscriptScale
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RowKind {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TranscriptScale {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .markdown
-        
-        case 2: return .user
-        
-        case 3: return .tools
+        case 1: return .normal
         
-        case 4: return .chip
+        case 2: return .big
         
-        case 5: return .image
+        case 3: return .huge
         
-        case 6: return .working
+        case 4: return .turns(count: try FfiConverterUInt32.read(from: &buf)
+        )
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: RowKind, into buf: inout [UInt8]) {
+    public static func write(_ value: TranscriptScale, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .markdown:
+        case .normal:
             writeInt(&buf, Int32(1))
         
         
-        case .user:
+        case .big:
             writeInt(&buf, Int32(2))
         
         
-        case .tools:
+        case .huge:
             writeInt(&buf, Int32(3))
         
         
-        case .chip:
+        case let .turns(count):
             writeInt(&buf, Int32(4))
-        
-        
-        case .image:
-            writeInt(&buf, Int32(5))
-        
-        
-        case .working:
-            writeInt(&buf, Int32(6))
-        
+            FfiConverterUInt32.write(count, into: &buf)
+            
         }
     }
 }
@@ -10439,25 +12413,25 @@ public struct FfiConverterTypeRowKind: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRowKind_lift(_ buf: RustBuffer) throws -> RowKind {
-    return try FfiConverterTypeRowKind.lift(buf)
+public func FfiConverterTypeTranscriptScale_lift(_ buf: RustBuffer) throws -> TranscriptScale {
+    return try FfiConverterTypeTranscriptScale.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeRowKind_lower(_ value: RowKind) -> RustBuffer {
-    return FfiConverterTypeRowKind.lower(value)
+public func FfiConverterTypeTranscriptScale_lower(_ value: TranscriptScale) -> RustBuffer {
+    return FfiConverterTypeTranscriptScale.lower(value)
 }
 
 
 
 
-public enum SandboxLevel: Equatable, Hashable {
+public enum VoiceCallPhase: Equatable, Hashable {
     
-    case readOnly
-    case workspaceWrite
-    case dangerFullAccess
+    case connecting
+    case active
+    case ending
 
 
 
@@ -10466,42 +12440,42 @@ public enum SandboxLevel: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SandboxLevel: Sendable {}
+extension VoiceCallPhase: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSandboxLevel: FfiConverterRustBuffer {
-    typealias SwiftType = SandboxLevel
+public struct FfiConverterTypeVoiceCallPhase: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceCallPhase
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SandboxLevel {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceCallPhase {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .readOnly
+        case 1: return .connecting
         
-        case 2: return .workspaceWrite
+        case 2: return .active
         
-        case 3: return .dangerFullAccess
+        case 3: return .ending
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: SandboxLevel, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceCallPhase, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .readOnly:
+        case .connecting:
             writeInt(&buf, Int32(1))
         
         
-        case .workspaceWrite:
+        case .active:
             writeInt(&buf, Int32(2))
         
         
-        case .dangerFullAccess:
+        case .ending:
             writeInt(&buf, Int32(3))
         
         }
@@ -10512,26 +12486,31 @@ public struct FfiConverterTypeSandboxLevel: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSandboxLevel_lift(_ buf: RustBuffer) throws -> SandboxLevel {
-    return try FfiConverterTypeSandboxLevel.lift(buf)
+public func FfiConverterTypeVoiceCallPhase_lift(_ buf: RustBuffer) throws -> VoiceCallPhase {
+    return try FfiConverterTypeVoiceCallPhase.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSandboxLevel_lower(_ value: SandboxLevel) -> RustBuffer {
-    return FfiConverterTypeSandboxLevel.lower(value)
+public func FfiConverterTypeVoiceCallPhase_lower(_ value: VoiceCallPhase) -> RustBuffer {
+    return FfiConverterTypeVoiceCallPhase.lower(value)
 }
 
 
 
 
-public enum SearchField: Equatable, Hashable {
+public enum VoiceCallWork: Equatable, Hashable {
     
-    case title
-    case project
-    case branch
-    case preview
+    case idle
+    /**
+     * The orchestrator's Codex turn (or a delegation) is running.
+     */
+    case working
+    /**
+     * Codex asked the user something; answer it in the transcript.
+     */
+    case awaitingInput
 
 
 
@@ -10540,50 +12519,44 @@ public enum SearchField: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SearchField: Sendable {}
+extension VoiceCallWork: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSearchField: FfiConverterRustBuffer {
-    typealias SwiftType = SearchField
+public struct FfiConverterTypeVoiceCallWork: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceCallWork
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SearchField {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceCallWork {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .title
-        
-        case 2: return .project
+        case 1: return .idle
         
-        case 3: return .branch
+        case 2: return .working
         
-        case 4: return .preview
+        case 3: return .awaitingInput
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: SearchField, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceCallWork, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .title:
+        case .idle:
             writeInt(&buf, Int32(1))
         
         
-        case .project:
+        case .working:
             writeInt(&buf, Int32(2))
         
         
-        case .branch:
+        case .awaitingInput:
             writeInt(&buf, Int32(3))
         
-        
-        case .preview:
-            writeInt(&buf, Int32(4))
-        
         }
     }
 }
@@ -10592,37 +12565,42 @@ public struct FfiConverterTypeSearchField: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSearchField_lift(_ buf: RustBuffer) throws -> SearchField {
-    return try FfiConverterTypeSearchField.lift(buf)
+public func FfiConverterTypeVoiceCallWork_lift(_ buf: RustBuffer) throws -> VoiceCallWork {
+    return try FfiConverterTypeVoiceCallWork.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSearchField_lower(_ value: SearchField) -> RustBuffer {
-    return FfiConverterTypeSearchField.lower(value)
+public func FfiConverterTypeVoiceCallWork_lower(_ value: VoiceCallWork) -> RustBuffer {
+    return FfiConverterTypeVoiceCallWork.lower(value)
 }
 
 
 
+/**
+ * Why a call ended without the user hanging up.
+ */
 
-public enum SendOutcome: Equatable, Hashable {
+public enum VoiceEndReason: Equatable, Hashable {
     
+    case microphoneDenied
+    case audioUnavailable
     /**
-     * A new turn was requested; the echo's id is `message_id`.
+     * Codex on the host must be signed in with ChatGPT.
      */
-    case started(messageId: String
-    )
+    case signInRequired
+    case usageUnavailable
     /**
-     * Delivered into the live turn.
+     * The host already has a voice call.
      */
-    case steered(messageId: String
-    )
+    case busy
+    case hostUnavailable
     /**
-     * Parked on the shared queue.
+     * The host's Zeron is too old or has remote voice disabled.
      */
-    case queued(queueId: String
-    )
+    case hostIncompatible
+    case connectionLost
 
 
 
@@ -10631,50 +12609,74 @@ public enum SendOutcome: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SendOutcome: Sendable {}
+extension VoiceEndReason: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSendOutcome: FfiConverterRustBuffer {
-    typealias SwiftType = SendOutcome
+public struct FfiConverterTypeVoiceEndReason: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceEndReason
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SendOutcome {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceEndReason {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .started(messageId: try FfiConverterString.read(from: &buf)
-        )
+        case 1: return .microphoneDenied
         
-        case 2: return .steered(messageId: try FfiConverterString.read(from: &buf)
-        )
+        case 2: return .audioUnavailable
         
-        case 3: return .queued(queueId: try FfiConverterString.read(from: &buf)
-        )
+        case 3: return .signInRequired
+        
+        case 4: return .usageUnavailable
+        
+        case 5: return .busy
+        
+        case 6: return .hostUnavailable
+        
+        case 7: return .hostIncompatible
+        
+        case 8: return .connectionLost
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: SendOutcome, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceEndReason, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .started(messageId):
+        case .microphoneDenied:
             writeInt(&buf, Int32(1))
-            FfiConverterString.write(messageId, into: &buf)
-            
         
-        case let .steered(messageId):
+        
+        case .audioUnavailable:
             writeInt(&buf, Int32(2))
-            FfiConverterString.write(messageId, into: &buf)
-            
         
-        case let .queued(queueId):
+        
+        case .signInRequired:
             writeInt(&buf, Int32(3))
-            FfiConverterString.write(queueId, into: &buf)
-            
+        
+        
+        case .usageUnavailable:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .busy:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .hostUnavailable:
+            writeInt(&buf, Int32(6))
+        
+        
+        case .hostIncompatible:
+            writeInt(&buf, Int32(7))
+        
+        
+        case .connectionLost:
+            writeInt(&buf, Int32(8))
+        
         }
     }
 }
@@ -10683,31 +12685,27 @@ public struct FfiConverterTypeSendOutcome: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSendOutcome_lift(_ buf: RustBuffer) throws -> SendOutcome {
-    return try FfiConverterTypeSendOutcome.lift(buf)
+public func FfiConverterTypeVoiceEndReason_lift(_ buf: RustBuffer) throws -> VoiceEndReason {
+    return try FfiConverterTypeVoiceEndReason.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSendOutcome_lower(_ value: SendOutcome) -> RustBuffer {
-    return FfiConverterTypeSendOutcome.lower(value)
+public func FfiConverterTypeVoiceEndReason_lower(_ value: VoiceEndReason) -> RustBuffer {
+    return FfiConverterTypeVoiceEndReason.lower(value)
 }
 
 
 
+/**
+ * Why a platform media operation failed.
+ */
 
-public enum SendState: Equatable, Hashable {
+public enum VoiceMediaFailure: Equatable, Hashable {
     
-    case sending
-    /**
-     * Durable, waiting on a degraded path.
-     */
-    case queued
-    /**
-     * "Not delivered — retry".
-     */
-    case failed
+    case permissionDenied
+    case unavailable
 
 
 
@@ -10716,44 +12714,38 @@ public enum SendState: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SendState: Sendable {}
+extension VoiceMediaFailure: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSendState: FfiConverterRustBuffer {
-    typealias SwiftType = SendState
+public struct FfiConverterTypeVoiceMediaFailure: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceMediaFailure
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SendState {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceMediaFailure {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .sending
-        
-        case 2: return .queued
+        case 1: return .permissionDenied
         
-        case 3: return .failed
+        case 2: return .unavailable
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: SendState, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceMediaFailure, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .sending:
+        case .permissionDenied:
             writeInt(&buf, Int32(1))
         
         
-        case .queued:
+        case .unavailable:
             writeInt(&buf, Int32(2))
         
-        
-        case .failed:
-            writeInt(&buf, Int32(3))
-        
         }
     }
 }
@@ -10762,35 +12754,28 @@ public struct FfiConverterTypeSendState: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSendState_lift(_ buf: RustBuffer) throws -> SendState {
-    return try FfiConverterTypeSendState.lift(buf)
-}
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public func FfiConverterTypeSendState_lower(_ value: SendState) -> RustBuffer {
-    return FfiConverterTypeSendState.lower(value)
+public func FfiConverterTypeVoiceMediaFailure_lift(_ buf: RustBuffer) throws -> VoiceMediaFailure {
+    return try FfiConverterTypeVoiceMediaFailure.lift(buf)
 }
 
-
-
-/**
- * Where a new session runs.
- */
-
-public enum SessionTarget: Equatable, Hashable {
-    
-    /**
-     * In a project (host = its device, cwd = its folder or `cwd` override).
-     */
-    case project(spaceId: String
-    )
-    /**
-     * No project: the chosen host's home folder.
-     */
-    case projectless(deviceId: String
-    )
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeVoiceMediaFailure_lower(_ value: VoiceMediaFailure) -> RustBuffer {
+    return FfiConverterTypeVoiceMediaFailure.lower(value)
+}
+
+
+
+
+public enum VoiceMediaOperation: Equatable, Hashable {
+    
+    case prepare
+    case offer
+    case applyAnswer
+    case setMuted
+    case levels
+    case close
 
 
 
@@ -10799,42 +12784,62 @@ public enum SessionTarget: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension SessionTarget: Sendable {}
+extension VoiceMediaOperation: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeSessionTarget: FfiConverterRustBuffer {
-    typealias SwiftType = SessionTarget
+public struct FfiConverterTypeVoiceMediaOperation: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceMediaOperation
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SessionTarget {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceMediaOperation {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .project(spaceId: try FfiConverterString.read(from: &buf)
-        )
+        case 1: return .prepare
         
-        case 2: return .projectless(deviceId: try FfiConverterString.read(from: &buf)
-        )
+        case 2: return .offer
+        
+        case 3: return .applyAnswer
+        
+        case 4: return .setMuted
+        
+        case 5: return .levels
+        
+        case 6: return .close
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: SessionTarget, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceMediaOperation, into buf: inout [UInt8]) {
         switch value {
         
         
-        case let .project(spaceId):
+        case .prepare:
             writeInt(&buf, Int32(1))
-            FfiConverterString.write(spaceId, into: &buf)
-            
         
-        case let .projectless(deviceId):
+        
+        case .offer:
             writeInt(&buf, Int32(2))
-            FfiConverterString.write(deviceId, into: &buf)
-            
+        
+        
+        case .applyAnswer:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .setMuted:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .levels:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .close:
+            writeInt(&buf, Int32(6))
+        
         }
     }
 }
@@ -10843,30 +12848,35 @@ public struct FfiConverterTypeSessionTarget: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSessionTarget_lift(_ buf: RustBuffer) throws -> SessionTarget {
-    return try FfiConverterTypeSessionTarget.lift(buf)
+public func FfiConverterTypeVoiceMediaOperation_lift(_ buf: RustBuffer) throws -> VoiceMediaOperation {
+    return try FfiConverterTypeVoiceMediaOperation.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeSessionTarget_lower(_ value: SessionTarget) -> RustBuffer {
-    return FfiConverterTypeSessionTarget.lower(value)
+public func FfiConverterTypeVoiceMediaOperation_lower(_ value: VoiceMediaOperation) -> RustBuffer {
+    return FfiConverterTypeVoiceMediaOperation.lower(value)
 }
 
 
 
+/**
+ * What the voice orb is showing, in call terms.
+ */
 
-public enum StreamSpeed: Equatable, Hashable {
+public enum VoiceOrb: Equatable, Hashable {
     
     /**
-     * Word by word at 30–140ms.
-     */
-    case realistic
-    /**
-     * ~4ms per word (benchmarks).
+     * No call: the calm form of a muted orchestrator.
      */
-    case fast
+    case idle
+    case connecting
+    case listening
+    case speaking
+    case working
+    case awaitingInput
+    case muted
 
 
 
@@ -10875,38 +12885,68 @@ public enum StreamSpeed: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension StreamSpeed: Sendable {}
+extension VoiceOrb: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeStreamSpeed: FfiConverterRustBuffer {
-    typealias SwiftType = StreamSpeed
+public struct FfiConverterTypeVoiceOrb: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceOrb
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StreamSpeed {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceOrb {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .realistic
+        case 1: return .idle
         
-        case 2: return .fast
+        case 2: return .connecting
+        
+        case 3: return .listening
+        
+        case 4: return .speaking
+        
+        case 5: return .working
+        
+        case 6: return .awaitingInput
+        
+        case 7: return .muted
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: StreamSpeed, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceOrb, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .realistic:
+        case .idle:
             writeInt(&buf, Int32(1))
         
         
-        case .fast:
+        case .connecting:
             writeInt(&buf, Int32(2))
         
+        
+        case .listening:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .speaking:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .working:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .awaitingInput:
+            writeInt(&buf, Int32(6))
+        
+        
+        case .muted:
+            writeInt(&buf, Int32(7))
+        
         }
     }
 }
@@ -10915,33 +12955,24 @@ public struct FfiConverterTypeStreamSpeed: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeStreamSpeed_lift(_ buf: RustBuffer) throws -> StreamSpeed {
-    return try FfiConverterTypeStreamSpeed.lift(buf)
+public func FfiConverterTypeVoiceOrb_lift(_ buf: RustBuffer) throws -> VoiceOrb {
+    return try FfiConverterTypeVoiceOrb.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeStreamSpeed_lower(_ value: StreamSpeed) -> RustBuffer {
-    return FfiConverterTypeStreamSpeed.lower(value)
+public func FfiConverterTypeVoiceOrb_lower(_ value: VoiceOrb) -> RustBuffer {
+    return FfiConverterTypeVoiceOrb.lower(value)
 }
 
 
 
 
-public enum TranscriptScale: Equatable, Hashable {
+public enum VoiceSpeaker: Equatable, Hashable {
     
-    case normal
-    /**
-     * 120 synthetic turns.
-     */
-    case big
-    /**
-     * 600 synthetic turns.
-     */
-    case huge
-    case turns(count: UInt32
-    )
+    case user
+    case assistant
 
 
 
@@ -10950,52 +12981,38 @@ public enum TranscriptScale: Equatable, Hashable {
 }
 
 #if compiler(>=6)
-extension TranscriptScale: Sendable {}
+extension VoiceSpeaker: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public struct FfiConverterTypeTranscriptScale: FfiConverterRustBuffer {
-    typealias SwiftType = TranscriptScale
+public struct FfiConverterTypeVoiceSpeaker: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceSpeaker
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TranscriptScale {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VoiceSpeaker {
         let variant: Int32 = try readInt(&buf)
         switch variant {
         
-        case 1: return .normal
-        
-        case 2: return .big
-        
-        case 3: return .huge
+        case 1: return .user
         
-        case 4: return .turns(count: try FfiConverterUInt32.read(from: &buf)
-        )
+        case 2: return .assistant
         
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
-    public static func write(_ value: TranscriptScale, into buf: inout [UInt8]) {
+    public static func write(_ value: VoiceSpeaker, into buf: inout [UInt8]) {
         switch value {
         
         
-        case .normal:
+        case .user:
             writeInt(&buf, Int32(1))
         
         
-        case .big:
+        case .assistant:
             writeInt(&buf, Int32(2))
         
-        
-        case .huge:
-            writeInt(&buf, Int32(3))
-        
-        
-        case let .turns(count):
-            writeInt(&buf, Int32(4))
-            FfiConverterUInt32.write(count, into: &buf)
-            
         }
     }
 }
@@ -11004,15 +13021,15 @@ public struct FfiConverterTypeTranscriptScale: FfiConverterRustBuffer {
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeTranscriptScale_lift(_ buf: RustBuffer) throws -> TranscriptScale {
-    return try FfiConverterTypeTranscriptScale.lift(buf)
+public func FfiConverterTypeVoiceSpeaker_lift(_ buf: RustBuffer) throws -> VoiceSpeaker {
+    return try FfiConverterTypeVoiceSpeaker.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
-public func FfiConverterTypeTranscriptScale_lower(_ value: TranscriptScale) -> RustBuffer {
-    return FfiConverterTypeTranscriptScale.lower(value)
+public func FfiConverterTypeVoiceSpeaker_lower(_ value: VoiceSpeaker) -> RustBuffer {
+    return FfiConverterTypeVoiceSpeaker.lower(value)
 }
 
 
@@ -11876,6 +13893,78 @@ fileprivate struct FfiConverterOptionTypeSendState: FfiConverterRustBuffer {
     }
 }
 
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeVoiceEndReason: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceEndReason?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeVoiceEndReason.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeVoiceEndReason.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeVoiceMediaFailure: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceMediaFailure?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeVoiceMediaFailure.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeVoiceMediaFailure.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeVoiceSpeaker: FfiConverterRustBuffer {
+    typealias SwiftType = VoiceSpeaker?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeVoiceSpeaker.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeVoiceSpeaker.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -12001,6 +14090,31 @@ fileprivate struct FfiConverterSequenceTypeBoxPrim: FfiConverterRustBuffer {
     }
 }
 
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeCaptionSpan: FfiConverterRustBuffer {
+    typealias SwiftType = [CaptionSpan]
+
+    public static func write(_ value: [CaptionSpan], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeCaptionSpan.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CaptionSpan] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [CaptionSpan]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeCaptionSpan.read(from: &buf))
+        }
+        return seq
+    }
+}
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -12975,6 +15089,26 @@ public func fileMentionLink(path: String, isDir: Bool) -> String  {
     )
 })
 }
+/**
+ * Codex voice styles to offer before a host reports its own.
+ */
+public func defaultVoiceStyles() -> [String]  {
+    return try!  FfiConverterSequenceString.lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_func_default_voice_styles(uniffiCallStatus
+    )
+})
+}
+/**
+ * Hosts advertising this capability accept client-media voice calls.
+ */
+public func voiceHostCapability() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_zeron_mobile_fn_func_voice_host_capability(uniffiCallStatus
+    )
+})
+}
 /**
  * Rust's line breaks for `text` in one face/size at `width`, as UTF-16
  * offsets of each line start — the accuracy harness compares these with
@@ -13116,6 +15250,12 @@ private let initializationResult: InitializationResult = {
     if (uniffi_zeron_mobile_checksum_func_file_mention_link() != 14340) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_zeron_mobile_checksum_func_default_voice_styles() != 30650) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_func_voice_host_capability() != 32424) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_zeron_mobile_checksum_func_debug_line_starts() != 43822) {
         return InitializationResult.apiChecksumMismatch
     }
@@ -13128,6 +15268,9 @@ private let initializationResult: InitializationResult = {
     if (uniffi_zeron_mobile_checksum_func_wallpaper_safe_opacity() != 57056) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_zeron_mobile_checksum_method_captionfader_frame() != 19899) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_zeron_mobile_checksum_method_clientlistener_on_event() != 55106) {
         return InitializationResult.apiChecksumMismatch
     }
@@ -13305,6 +15448,9 @@ private let initializationResult: InitializationResult = {
     if (uniffi_zeron_mobile_checksum_method_coreclient_workspace_revision() != 48105) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_zeron_mobile_checksum_method_coreclient_start_voice() != 62086) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_zeron_mobile_checksum_method_uploadprogress_on_progress() != 40458) {
         return InitializationResult.apiChecksumMismatch
     }
@@ -13368,6 +15514,24 @@ private let initializationResult: InitializationResult = {
     if (uniffi_zeron_mobile_checksum_method_sessionhandle_transcript_status() != 12910) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_zeron_mobile_checksum_method_voicecall_complete_media() != 130) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_voicecall_set_muted() != 41942) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_voicecall_stop() != 33696) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_voicemedialistener_on_request() != 10473) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_voicesessionlistener_on_voice_state() != 7593) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_voicesessionlistener_on_voice_closed() != 14100) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_zeron_mobile_checksum_method_layoutframe_build_micros() != 17231) {
         return InitializationResult.apiChecksumMismatch
     }
@@ -13443,6 +15607,18 @@ private let initializationResult: InitializationResult = {
     if (uniffi_zeron_mobile_checksum_method_transcriptview_toggle_detail() != 17098) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_zeron_mobile_checksum_method_orbrenderer_next_frame() != 6064) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_orbrenderer_set_audio_levels() != 53067) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_method_orbrenderer_set_orb() != 18211) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_zeron_mobile_checksum_constructor_captionfader_new() != 15591) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_zeron_mobile_checksum_constructor_coreclient_new() != 27504) {
         return InitializationResult.apiChecksumMismatch
     }
@@ -13452,11 +15628,16 @@ private let initializationResult: InitializationResult = {
     if (uniffi_zeron_mobile_checksum_constructor_transcriptview_new() != 26914) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_zeron_mobile_checksum_constructor_orbrenderer_new() != 46989) {
+        return InitializationResult.apiChecksumMismatch
+    }
 
     uniffiCallbackInitClientListener()
     uniffiCallbackInitLayoutListener()
     uniffiCallbackInitPlatformMeasurer()
     uniffiCallbackInitUploadProgress()
+    uniffiCallbackInitVoiceMediaListener()
+    uniffiCallbackInitVoiceSessionListener()
     return InitializationResult.ok
 }()
 
diff --git a/apps/ios/Zeron/Info.plist b/apps/ios/Zeron/Info.plist
index f0ab6a5d76..886741d917 100644
--- a/apps/ios/Zeron/Info.plist
+++ b/apps/ios/Zeron/Info.plist
@@ -52,6 +52,14 @@
 	</dict>
 	<key>NSPhotoLibraryUsageDescription</key>
 	<string>Attach photos to messages.</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>Voice calls you start stream your audio to OpenAI through the ChatGPT account signed in to Codex on your host.</string>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>audio</string>
+	</array>
+	<key>NSSupportsLiveActivities</key>
+	<true/>
 	<key>NSCameraUsageDescription</key>
 	<string>Take photos to attach to messages.</string>
 	<key>UILaunchScreen</key>
diff --git a/apps/ios/Zeron/Session/SessionViewController.swift b/apps/ios/Zeron/Session/SessionViewController.swift
index 5e8d7548f9..2935998aaf 100644
--- a/apps/ios/Zeron/Session/SessionViewController.swift
+++ b/apps/ios/Zeron/Session/SessionViewController.swift
@@ -41,6 +41,21 @@ final class SessionViewController: UIViewController, UIGestureRecognizerDelegate
         navigationItem.largeTitleDisplayMode = .never
         navigationItem.titleView = titleView
         navigationItem.rightBarButtonItem = UIBarButtonItem(image: UIImage(systemName: "ellipsis"), menu: sessionMenu())
+        // The session has its own composer, so the tab bar's voice control
+        // steps aside with the accessory; the call stays a tap away up here.
+        let voiceBar = VoiceBarItem(app: app, host: self)
+        self.voiceBar = voiceBar
+        let menu = navigationItem.rightBarButtonItem!
+        let syncVoice = { [weak self, weak voiceBar] in
+            guard let self, let voiceBar else { return }
+            let items = voiceBar.visible ? [menu, voiceBar.item] : [menu]
+            if self.navigationItem.rightBarButtonItems?.count != items.count {
+                self.navigationItem.setRightBarButtonItems(items, animated: self.view.window != nil)
+            }
+        }
+        voiceToken = app.voice.observe(syncVoice)
+        hostsToken = app.observe(syncVoice)
+        syncVoice()
 
         list.frame = view.bounds
         list.autoresizingMask = [.flexibleWidth, .flexibleHeight]
@@ -165,6 +180,9 @@ final class SessionViewController: UIViewController, UIGestureRecognizerDelegate
 
     private var hasAppeared = false
     private var backgroundObserver: NSObjectProtocol?
+    private var voiceBar: VoiceBarItem?
+    private var voiceToken: AnyObject?
+    private var hostsToken: AnyObject?
 
     deinit {
         if let backgroundObserver { NotificationCenter.default.removeObserver(backgroundObserver) }
diff --git a/apps/ios/Zeron/Shell/MainTabController.swift b/apps/ios/Zeron/Shell/MainTabController.swift
index ce493afdd7..eda05c2c03 100644
--- a/apps/ios/Zeron/Shell/MainTabController.swift
+++ b/apps/ios/Zeron/Shell/MainTabController.swift
@@ -40,6 +40,25 @@ final class MainTabController: UITabBarController, UITabBarControllerDelegate, A
         liveToken = app.observe { [weak self] in
             guard let self else { return }
             self.accessoryContent.update(self.app.live)
+            // Hosts come and go with the workspace (online, capabilities).
+            self.accessoryContent.updateVoice(self.app.voice)
+        }
+        let voice = accessoryContent.voice
+        voice.onStart = { [weak self] source in
+            guard let self else { return }
+            self.openVoice(app: self.app, source: source)
+        }
+        voice.onOpen = { [weak self] source in
+            guard let self else { return }
+            self.presentVoiceStage(app: self.app, source: source)
+        }
+        voice.onMute = { [weak self] in self?.app.voice.toggleMute() }
+        voice.onEnd = { [weak self] in self?.app.voice.stop() }
+        voice.startButton.menu = voiceMenu(app: app)
+        accessoryContent.updateVoice(app.voice)
+        voiceToken = app.voice.observe { [weak self] in
+            guard let self else { return }
+            self.accessoryContent.updateVoice(self.app.voice)
         }
     }
 
@@ -63,6 +82,7 @@ final class MainTabController: UITabBarController, UITabBarControllerDelegate, A
     private lazy var accessoryContent = AskAnythingAccessory { [weak self] in self?.presentNewSession() }
     private lazy var accessory = UITabAccessory(contentView: accessoryContent)
     private var liveToken: AnyObject?
+    private var voiceToken: AnyObject?
 
     /// Accessory state from what's on screen: hidden over a session (it has
     /// its own composer).
@@ -202,24 +222,33 @@ final class MainTabController: UITabBarController, UITabBarControllerDelegate, A
 }
 
 /// The capsule above the tab bar: a plus, "New session", and a live
-/// summary of what's running ("2 working · 1 needs you"). Tapping it opens the
-/// new-session composer.
-final class AskAnythingAccessory: UIControl {
-    private let onTap: () -> Void
+/// summary of what's running ("2 working · 1 needs you"), with voice at its
+/// trailing end. Tapping the plus side opens the new-session composer; the
+/// waveform calls Codex, and during a call the strip shows it (orb, clock,
+/// mute, hang-up) and opens the call stage.
+final class AskAnythingAccessory: UIView {
+    private let newSession = PressableControl()
     private let label = UILabel()
     private let summary = UILabel()
     private let cells = StatusGlyph()
     private let mark = UIImageView(image: UIImage(systemName: "plus", withConfiguration: UIImage.SymbolConfiguration(pointSize: 15, weight: .semibold)))
+    private let plate = UIView()
+    let voice = VoiceAccessoryView()
+    private var voiceShown = false
+    private var voiceLive = false
+    private var restConstraints: [NSLayoutConstraint] = []
+    private var idleVoiceConstraints: [NSLayoutConstraint] = []
+    private var liveVoiceConstraints: [NSLayoutConstraint] = []
 
     init(onTap: @escaping () -> Void) {
-        self.onTap = onTap
         super.init(frame: .zero)
-        accessibilityIdentifier = "new-session"
-        accessibilityTraits = .button
+        newSession.accessibilityIdentifier = "new-session"
+        newSession.accessibilityTraits = .button
+        newSession.isAccessibilityElement = true
+        newSession.addAction(UIAction { _ in onTap() }, for: .touchUpInside)
 
         mark.tintColor = Palette.accent
         mark.contentMode = .center
-        let plate = UIView()
         plate.backgroundColor = Palette.accentSoft
         // A circle, concentric with the accessory capsule (7pt inset).
         plate.layer.cornerRadius = 17
@@ -233,31 +262,56 @@ final class AskAnythingAccessory: UIControl {
         summary.textColor = Palette.secondary
         summary.textAlignment = .right
         cells.isHidden = true
-        for v in [plate, label, mark, summary, cells] as [UIView] { v.translatesAutoresizingMaskIntoConstraints = false }
-        for v in [plate, label, summary, cells] as [UIView] { addSubview(v) }
+        for v in [newSession, plate, label, mark, summary, cells, voice] as [UIView] { v.translatesAutoresizingMaskIntoConstraints = false }
+        for v in [plate, label, summary, cells] as [UIView] { newSession.addSubview(v) }
+        addSubview(newSession)
+        addSubview(voice)
+        voice.isHidden = true
         summary.setContentCompressionResistancePriority(.required, for: .horizontal)
         NSLayoutConstraint.activate([
-            plate.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 7),
-            plate.centerYAnchor.constraint(equalTo: centerYAnchor),
+            newSession.leadingAnchor.constraint(equalTo: leadingAnchor),
+            newSession.topAnchor.constraint(equalTo: topAnchor),
+            newSession.bottomAnchor.constraint(equalTo: bottomAnchor),
+            plate.leadingAnchor.constraint(equalTo: newSession.leadingAnchor, constant: 7),
+            plate.centerYAnchor.constraint(equalTo: newSession.centerYAnchor),
             plate.widthAnchor.constraint(equalToConstant: 34),
             plate.heightAnchor.constraint(equalToConstant: 34),
             mark.centerXAnchor.constraint(equalTo: plate.centerXAnchor),
             mark.centerYAnchor.constraint(equalTo: plate.centerYAnchor),
             label.leadingAnchor.constraint(equalTo: plate.trailingAnchor, constant: 11),
-            label.centerYAnchor.constraint(equalTo: centerYAnchor),
-            label.trailingAnchor.constraint(lessThanOrEqualTo: cells.leadingAnchor, constant: -10),
-            summary.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
-            summary.centerYAnchor.constraint(equalTo: centerYAnchor),
+            label.centerYAnchor.constraint(equalTo: newSession.centerYAnchor),
+            summary.trailingAnchor.constraint(equalTo: newSession.trailingAnchor, constant: -16),
+            summary.centerYAnchor.constraint(equalTo: newSession.centerYAnchor),
             cells.trailingAnchor.constraint(equalTo: summary.leadingAnchor, constant: -7),
-            cells.centerYAnchor.constraint(equalTo: centerYAnchor),
+            cells.centerYAnchor.constraint(equalTo: newSession.centerYAnchor),
             cells.widthAnchor.constraint(equalToConstant: 12),
             cells.heightAnchor.constraint(equalToConstant: 12),
+            voice.topAnchor.constraint(equalTo: topAnchor),
+            voice.bottomAnchor.constraint(equalTo: bottomAnchor),
+            voice.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -7),
         ])
-        addAction(UIAction { [weak self] _ in self?.onTap() }, for: .touchUpInside)
+        // Yields while the call strip narrows this side to the plus.
+        let labelEnd = label.trailingAnchor.constraint(lessThanOrEqualTo: cells.leadingAnchor, constant: -10)
+        labelEnd.priority = .defaultHigh
+        labelEnd.isActive = true
+        // No voice: "New session" spans the capsule.
+        restConstraints = [newSession.trailingAnchor.constraint(equalTo: trailingAnchor)]
+        // Idle voice: a 34pt waveform at the trailing end.
+        idleVoiceConstraints = [
+            voice.widthAnchor.constraint(equalToConstant: 34),
+            newSession.trailingAnchor.constraint(equalTo: voice.leadingAnchor, constant: -2),
+        ]
+        // Live: the call strip takes everything after the plus.
+        liveVoiceConstraints = [
+            newSession.trailingAnchor.constraint(equalTo: plate.trailingAnchor, constant: 4),
+            voice.leadingAnchor.constraint(equalTo: plate.trailingAnchor, constant: 12),
+        ]
+        NSLayoutConstraint.activate(restConstraints)
         registerForTraitChanges([UITraitTabAccessoryEnvironment.self]) { (self: AskAnythingAccessory, _) in
             // Inline (minimized tab bar): the plus and the live summary only.
             let inline = self.traitCollection.tabAccessoryEnvironment == .inline
-            self.label.alpha = inline ? 0 : 1
+            self.label.alpha = inline || self.voiceLive ? 0 : 1
+            self.voice.setInline(inline)
         }
         update(AppModel.LiveCounts())
     }
@@ -269,12 +323,34 @@ final class AskAnythingAccessory: UIControl {
         if live.working > 0 { parts.append("\(live.working) working") }
         if live.awaiting > 0 { parts.append("\(live.awaiting) need\(live.awaiting == 1 ? "s" : "") you") }
         summary.text = parts.joined(separator: " · ")
-        cells.isHidden = parts.isEmpty
+        cells.isHidden = parts.isEmpty || voiceLive
+        summary.isHidden = voiceLive
         cells.kind = live.working > 0 ? .spinner : .dot(StatusTone.input)
-        accessibilityLabel = parts.isEmpty ? "New session" : "New session, " + parts.joined(separator: ", ")
+        newSession.accessibilityLabel = parts.isEmpty ? "New session" : "New session, " + parts.joined(separator: ", ")
     }
 
-    override var isHighlighted: Bool {
-        didSet { UIView.animate(withDuration: 0.15) { self.alpha = self.isHighlighted ? 0.6 : 1 } }
+    /// Show voice when a host can run it, and the call strip while one runs.
+    func updateVoice(_ controller: RemoteVoiceController) {
+        let shown = controller.live || controller.available
+        let live = controller.live
+        voice.update(controller)
+        guard shown != voiceShown || live != voiceLive else { return }
+        voiceShown = shown
+        voiceLive = live
+        NSLayoutConstraint.deactivate(restConstraints + idleVoiceConstraints + liveVoiceConstraints)
+        NSLayoutConstraint.activate(!shown ? restConstraints : live ? liveVoiceConstraints : idleVoiceConstraints)
+        voice.isHidden = !shown
+        let inline = traitCollection.tabAccessoryEnvironment == .inline
+        let apply = {
+            self.label.alpha = inline || live ? 0 : 1
+            self.summary.isHidden = live
+            self.cells.isHidden = live || self.summary.text?.isEmpty != false
+            self.layoutIfNeeded()
+        }
+        if window == nil || UIAccessibility.isReduceMotionEnabled {
+            apply()
+        } else {
+            UIView.animate(withDuration: 0.35, delay: 0, usingSpringWithDamping: 0.9, initialSpringVelocity: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: apply)
+        }
     }
 }
diff --git a/apps/ios/Zeron/Shell/MoreViewController.swift b/apps/ios/Zeron/Shell/MoreViewController.swift
index d3310dba97..c98ecfd974 100644
--- a/apps/ios/Zeron/Shell/MoreViewController.swift
+++ b/apps/ios/Zeron/Shell/MoreViewController.swift
@@ -184,6 +184,10 @@ final class MoreViewController: UIViewController, UICollectionViewDelegate {
         ])
         s.appendSections(["Devices"])
         s.appendItems(app.hostOptions.map { Row(id: "device:\($0.id)", title: $0.name, subtitle: $0.online ? "Online" : "Offline", symbol: "desktopcomputer", accessory: .dot($0.online)) })
+        if app.voice.available {
+            s.appendSections(["Voice"])
+            s.appendItems([Row(id: "voice", title: "Voice", subtitle: app.voice.selectedStyle.map { "Codex voice · \($0.capitalized)" } ?? "Codex voice device and style", symbol: "waveform")])
+        }
         s.appendSections(["Notifications"])
         s.appendItems(notificationRows())
         s.appendSections(["Appearance"])
@@ -212,6 +216,7 @@ final class MoreViewController: UIViewController, UICollectionViewDelegate {
         collectionView.deselectItem(at: path, animated: true)
         guard let row = dataSource.itemIdentifier(for: path) else { return }
         switch row.id {
+        case "voice": navigationController?.pushViewController(VoiceViewController(app: app), animated: true)
         case let id where id.hasPrefix("appearance:"):
             let style = Int(id.dropFirst(11)) ?? 0
             UserDefaults.standard.set(style, forKey: "appearance")
diff --git a/apps/ios/Zeron/Shell/SplitRootController.swift b/apps/ios/Zeron/Shell/SplitRootController.swift
index ed707d9e6e..bbbc3b7787 100644
--- a/apps/ios/Zeron/Shell/SplitRootController.swift
+++ b/apps/ios/Zeron/Shell/SplitRootController.swift
@@ -200,6 +200,9 @@ final class SidebarViewController: UIViewController, UISearchResultsUpdating {
     private let list: SessionsViewController
     private let nav: UINavigationController
     private let search = UISearchController(searchResultsController: nil)
+    private var voiceBar: VoiceBarItem?
+    private var voiceToken: AnyObject?
+    private var workspaceToken: AnyObject?
 
     var currentChatId: String? {
         get { list.currentChatId }
@@ -250,6 +253,19 @@ final class SidebarViewController: UIViewController, UISearchResultsUpdating {
         list.navigationItem.rightBarButtonItem = nil
         list.toolbarItems = [settings, options, .flexibleSpace(), compose]
         nav.isToolbarHidden = false
+        // Voice beside compose, once a host can run it.
+        let voiceBar = VoiceBarItem(app: app, host: self)
+        self.voiceBar = voiceBar
+        let syncVoice = { [weak self, weak voiceBar] in
+            guard let self, let voiceBar else { return }
+            let items = voiceBar.visible ? [settings, options, .flexibleSpace(), voiceBar.item, compose] : [settings, options, .flexibleSpace(), compose]
+            if self.list.toolbarItems?.count != items.count {
+                self.list.setToolbarItems(items, animated: self.view.window != nil)
+            }
+        }
+        voiceToken = app.voice.observe(syncVoice)
+        workspaceToken = app.observe(syncVoice)
+        syncVoice()
 
         // A hairline between the sidebar and the main column.
         let edge = UIView()
diff --git a/apps/ios/Zeron/Voice/CodexVoicePeer.swift b/apps/ios/Zeron/Voice/CodexVoicePeer.swift
new file mode 100644
index 0000000000..49b4a8e8d8
--- /dev/null
+++ b/apps/ios/Zeron/Voice/CodexVoicePeer.swift
@@ -0,0 +1,230 @@
+import AVFoundation
+import UIKit
+import WebRTC
+
+/// Native audio endpoint. Credentials and tools stay on the execution host.
+/// The ordered oai-events channel and gathered offer mirror the pinned helper.
+///
+/// Audio behaves like a phone call: loudspeaker while the phone is in hand,
+/// the earpiece while it is held to the ear, and whatever headset or car the
+/// user connected otherwise. The call survives the screen locking (background
+/// audio); an interruption such as an incoming call ends it.
+@MainActor
+final class CodexVoicePeer: NSObject {
+    enum Failure: Error { case closed, unavailable, permissionDenied, timeout }
+    private static let factory: RTCPeerConnectionFactory = {
+        RTCInitializeSSL()
+        return RTCPeerConnectionFactory()
+    }()
+    private var peer: RTCPeerConnection?
+    private var channel: RTCDataChannel?
+    private var track: RTCAudioTrack?
+    private var closed = false
+    private var active = false
+    private var nearEar = false
+    private var observers: [NSObjectProtocol] = []
+    var onFailure: (() -> Void)?
+
+    func prepare() async throws {
+        guard !closed else { throw Failure.closed }
+        guard await AVAudioApplication.requestRecordPermission() else { throw Failure.permissionDenied }
+        guard !closed, UIApplication.shared.applicationState != .background else { throw Failure.closed }
+        let audio = RTCAudioSession.sharedInstance()
+        audio.useManualAudio = true
+        audio.isAudioEnabled = false
+        let configuration = RTCAudioSessionConfiguration.webRTC()
+        configuration.category = AVAudioSession.Category.playAndRecord.rawValue
+        configuration.mode = AVAudioSession.Mode.voiceChat.rawValue
+        // No defaultToSpeaker: the route follows the proximity sensor instead.
+        configuration.categoryOptions = [.allowBluetoothHFP]
+        // WebRTC re-applies its *global* configuration when the audio unit
+        // starts; a session-only change would be overwritten mid-call.
+        RTCAudioSessionConfiguration.setWebRTC(configuration)
+        audio.lockForConfiguration()
+        defer { audio.unlockForConfiguration() }
+        try audio.setConfiguration(configuration)
+        let config = RTCConfiguration()
+        config.sdpSemantics = .unifiedPlan
+        config.bundlePolicy = .maxBundle
+        guard let connection = Self.factory.peerConnection(with: config, constraints: RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil), delegate: self) else { throw Failure.unavailable }
+        peer = connection
+        let source = Self.factory.audioSource(with: RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil))
+        let track = Self.factory.audioTrack(with: source, trackId: "voice-audio")
+        track.isEnabled = false
+        self.track = track
+        connection.add(track, streamIds: ["voice"])
+        let dataConfig = RTCDataChannelConfiguration()
+        dataConfig.isOrdered = true
+        channel = connection.dataChannel(forLabel: "oai-events", configuration: dataConfig)
+        guard channel != nil else { throw Failure.unavailable }
+        channel?.delegate = self
+        observers.append(NotificationCenter.default.addObserver(forName: AVAudioSession.interruptionNotification, object: nil, queue: .main) { [weak self] notification in
+            // A phone call, Siri or an alarm takes the audio: end, never resume.
+            guard (notification.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt) == AVAudioSession.InterruptionType.began.rawValue else { return }
+            MainActor.assumeIsolated { self?.fail() }
+        })
+        observers.append(NotificationCenter.default.addObserver(forName: AVAudioSession.routeChangeNotification, object: nil, queue: .main) { [weak self] notification in
+            // Our own override reports a change too; everything else (a headset
+            // leaving, WebRTC re-applying its category) re-routes the call.
+            guard (notification.userInfo?[AVAudioSessionRouteChangeReasonKey] as? UInt) != AVAudioSession.RouteChangeReason.override.rawValue else { return }
+            MainActor.assumeIsolated { self?.applyRoute() }
+        })
+    }
+
+    func offer() async throws -> String {
+        guard let peer, !closed else { throw Failure.closed }
+        let offer: RTCSessionDescription = try await callback { complete in
+            peer.offer(for: RTCMediaConstraints(mandatoryConstraints: ["OfferToReceiveAudio": "true"], optionalConstraints: nil)) { description, error in
+                complete(description.map(Result.success) ?? .failure(error ?? Failure.unavailable))
+            }
+        }
+        let _: Void = try await callback { complete in
+            peer.setLocalDescription(offer) { error in complete(error.map(Result.failure) ?? .success(())) }
+        }
+        try await waitUntil { peer.iceGatheringState == .complete }
+        guard let sdp = peer.localDescription?.sdp, sdp.utf8.count <= 65_536 else { throw Failure.unavailable }
+        return sdp
+    }
+
+    func apply(answer: String) async throws {
+        guard let peer, !closed, !answer.isEmpty, answer.utf8.count <= 65_536 else { throw Failure.closed }
+        let _: Void = try await callback { complete in
+            peer.setRemoteDescription(RTCSessionDescription(type: .answer, sdp: answer)) { error in
+                complete(error.map(Result.failure) ?? .success(()))
+            }
+        }
+        try await waitUntil { peer.connectionState == .connected && self.channel?.readyState == .open }
+    }
+
+    func setMuted(_ muted: Bool) throws {
+        guard !closed, peer?.connectionState == .connected else { throw Failure.closed }
+        // Called only after the host confirms the current generation.
+        if !active {
+            let audio = RTCAudioSession.sharedInstance()
+            audio.lockForConfiguration()
+            defer { audio.unlockForConfiguration() }
+            try audio.setActive(true)
+            audio.isAudioEnabled = true
+            active = true
+            applyRoute(locked: true)
+        }
+        track?.isEnabled = !muted
+    }
+
+    /// The proximity sensor: held to the ear, play through the earpiece.
+    func setNearEar(_ near: Bool) {
+        guard nearEar != near else { return }
+        nearEar = near
+        applyRoute()
+    }
+
+    /// Loudspeaker in hand, earpiece at the ear; a headset, Bluetooth or car
+    /// route always wins.
+    private func applyRoute(locked: Bool = false) {
+        guard active, !closed else { return }
+        let audio = RTCAudioSession.sharedInstance()
+        let external = audio.session.currentRoute.outputs.contains {
+            $0.portType != .builtInReceiver && $0.portType != .builtInSpeaker
+        }
+        if !locked { audio.lockForConfiguration() }
+        defer { if !locked { audio.unlockForConfiguration() } }
+        try? audio.overrideOutputAudioPort(external || nearEar ? .none : .speaker)
+    }
+
+    func levels() async throws -> (UInt16, UInt16) {
+        guard let peer, !closed, peer.connectionState != .failed, peer.connectionState != .closed else { throw Failure.closed }
+        // Nobody sees the orb with the screen off; skip the statistics walk.
+        guard UIApplication.shared.applicationState != .background else { return (0, 0) }
+        let report: RTCStatisticsReport = try await callback { complete in peer.statistics { complete(.success($0)) } }
+        var microphone: Double = 0
+        var speaker: Double = 0
+        for stat in report.statistics.values {
+            guard let level = stat.values["audioLevel"] as? NSNumber else { continue }
+            if stat.type == "media-source" { microphone = max(microphone, level.doubleValue) }
+            if stat.type == "inbound-rtp" { speaker = max(speaker, level.doubleValue) }
+        }
+        return (UInt16(min(1, max(0, microphone)) * 65535), UInt16(min(1, max(0, speaker)) * 65535))
+    }
+
+    func close() {
+        guard !closed else { return }
+        closed = true
+        track?.isEnabled = false
+        RTCAudioSession.sharedInstance().isAudioEnabled = false
+        channel?.close()
+        peer?.close()
+        channel = nil; peer = nil; track = nil
+        for observer in observers { NotificationCenter.default.removeObserver(observer) }
+        observers.removeAll()
+        let audio = RTCAudioSession.sharedInstance()
+        audio.lockForConfiguration()
+        try? audio.overrideOutputAudioPort(.none)
+        try? audio.setActive(false)
+        audio.unlockForConfiguration()
+        active = false
+    }
+
+    private func fail() { guard !closed else { return }; close(); onFailure?() }
+    private func waitUntil(_ ready: () -> Bool) async throws {
+        let deadline = ContinuousClock.now.advanced(by: .seconds(25))
+        while !ready() {
+            guard !closed else { throw Failure.closed }
+            guard ContinuousClock.now < deadline else { throw Failure.timeout }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        guard !closed else { throw Failure.closed }
+    }
+    private func callback<T>(_ start: (@escaping (Result<T, Error>) -> Void) -> Void) async throws -> T {
+        let slot = VoiceContinuation<T>()
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                slot.install(continuation)
+                start { slot.finish($0) }
+            }
+        } onCancel: { slot.finish(.failure(CancellationError())) }
+    }
+}
+
+/// A cancelled operation can receive a late RTC callback, exactly once.
+final class VoiceContinuation<T>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var continuation: CheckedContinuation<T, Error>?
+    private var result: Result<T, Error>?
+    private var finished = false
+    func install(_ continuation: CheckedContinuation<T, Error>) {
+        lock.lock()
+        if let result { lock.unlock(); continuation.resume(with: result); return }
+        self.continuation = continuation
+        lock.unlock()
+    }
+    func finish(_ result: Result<T, Error>) {
+        lock.lock()
+        guard !finished else { lock.unlock(); return }
+        finished = true
+        self.result = result
+        let continuation = self.continuation
+        self.continuation = nil
+        lock.unlock()
+        continuation?.resume(with: result)
+    }
+}
+
+extension CodexVoicePeer: RTCPeerConnectionDelegate, RTCDataChannelDelegate {
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didChange stateChanged: RTCSignalingState) {}
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didAdd stream: RTCMediaStream) {}
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didRemove stream: RTCMediaStream) {}
+    nonisolated func peerConnectionShouldNegotiate(_ peerConnection: RTCPeerConnection) {}
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didChange newState: RTCIceConnectionState) {
+        if newState == .failed || newState == .closed || newState == .disconnected { Task { @MainActor [weak self] in self?.fail() } }
+    }
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didChange newState: RTCIceGatheringState) {}
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didGenerate candidate: RTCIceCandidate) {}
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didRemove candidates: [RTCIceCandidate]) {}
+    nonisolated func peerConnection(_ peerConnection: RTCPeerConnection, didOpen dataChannel: RTCDataChannel) { dataChannel.close() }
+    nonisolated func dataChannelDidChangeState(_ dataChannel: RTCDataChannel) {
+        if dataChannel.readyState == .closed || dataChannel.readyState == .closing { Task { @MainActor [weak self] in self?.fail() } }
+    }
+    nonisolated func dataChannel(_ dataChannel: RTCDataChannel, didReceiveMessageWith buffer: RTCDataBuffer) {
+        // The host owns canonical transcripts and handoffs. Do not persist a second copy.
+    }
+}
diff --git a/apps/ios/Zeron/Voice/NativeVoiceMedia.swift b/apps/ios/Zeron/Voice/NativeVoiceMedia.swift
new file mode 100644
index 0000000000..3ed4574aca
--- /dev/null
+++ b/apps/ios/Zeron/Voice/NativeVoiceMedia.swift
@@ -0,0 +1,82 @@
+import Foundation
+
+/// A single-generation platform bridge. The Rust call owns the callback object;
+/// its back-reference is weak so releasing the call always closes native audio.
+@MainActor
+final class NativeVoiceMedia: VoiceMediaListener {
+    weak var call: VoiceCall?
+    private let peer = CodexVoicePeer()
+    private var operations: [UInt64: Task<Void, Never>] = [:]
+    private var closed = false
+    private var activated = false
+    var onFailure: (() -> Void)?
+
+    init() {
+        peer.onFailure = { [weak self] in
+            guard let self else { return }
+            self.close()
+            self.call?.stop()
+            self.onFailure?()
+        }
+    }
+
+    nonisolated func onRequest(request: VoiceMediaRequest) {
+        Task { @MainActor in self.perform(request) }
+    }
+
+    private func perform(_ request: VoiceMediaRequest) {
+        if case .close = request.operation { close(); return }
+        guard !closed else {
+            call?.completeMedia(requestId: request.requestId, failure: .unavailable, sdp: nil, microphone: 0, speaker: 0)
+            return
+        }
+        guard operations.count < 4 else { close(); call?.stop(); return }
+        operations[request.requestId] = Task { @MainActor [weak self] in
+            guard let self else { return }
+            defer { self.operations[request.requestId] = nil }
+            do {
+                var sdp: String?
+                var microphone: UInt16 = 0
+                var speaker: UInt16 = 0
+                switch request.operation {
+                case .prepare: try await self.peer.prepare()
+                case .offer: sdp = try await self.peer.offer()
+                case .applyAnswer:
+                    guard let answer = request.sdp else { throw CodexVoicePeer.Failure.unavailable }
+                    try await self.peer.apply(answer: answer)
+                case .setMuted:
+                    try self.peer.setMuted(request.muted)
+                    self.activated = true
+                case .levels: (microphone, speaker) = try await self.peer.levels()
+                case .close: self.close()
+                }
+                guard !self.closed, !Task.isCancelled else { return }
+                self.call?.completeMedia(requestId: request.requestId, failure: nil, sdp: sdp, microphone: microphone, speaker: speaker)
+            } catch {
+                guard !self.closed else { return }
+                let failure: VoiceMediaFailure = (error as? CodexVoicePeer.Failure) == .permissionDenied ? .permissionDenied : .unavailable
+                self.call?.completeMedia(requestId: request.requestId, failure: failure, sdp: nil, microphone: 0, speaker: 0)
+            }
+        }
+    }
+
+    func muteLocally(_ muted: Bool) {
+        // UI mute never waits for the Rust control queue or the relay.
+        guard !closed, activated else { return }
+        try? peer.setMuted(muted)
+    }
+
+    /// Proximity sensor state: the earpiece while the phone is at the ear.
+    func setNearEar(_ near: Bool) {
+        guard !closed else { return }
+        peer.setNearEar(near)
+    }
+
+    func close() {
+        guard !closed else { return }
+        closed = true
+        peer.close()
+        for operation in operations.values { operation.cancel() }
+        operations.removeAll()
+    }
+}
diff --git a/apps/ios/Zeron/Voice/OrbView.swift b/apps/ios/Zeron/Voice/OrbView.swift
new file mode 100644
index 0000000000..8d82300107
--- /dev/null
+++ b/apps/ios/Zeron/Voice/OrbView.swift
@@ -0,0 +1,131 @@
+import UIKit
+
+/// The desktop voice orb (`zeron-orb`): the core runs the same geometry,
+/// clock, audio response and 300 ms state crossfades as the GPUI widget, and
+/// this view only paints the frames — lines, then disks back to front, in
+/// monochrome ink on a transparent canvas.
+///
+/// Redraws at 30 fps (the desktop rate) while on screen; hidden, off-window or
+/// backgrounded it costs nothing and its clock stops, so motion resumes where
+/// it left off. Reduce Motion shows the desktop's static frame.
+final class OrbView: UIView {
+    var orb: VoiceOrb {
+        didSet {
+            guard orb != oldValue else { return }
+            renderer.setOrb(orb: orb)
+            if link == nil { redraw(animating: false) }
+        }
+    }
+
+    private let renderer: OrbRenderer
+    private var frameData: OrbFrame?
+    private var link: CADisplayLink?
+    private var observers: [NSObjectProtocol] = []
+
+    init(preset: OrbPreset, orb: VoiceOrb = .idle) {
+        self.orb = orb
+        renderer = OrbRenderer(preset: preset, orb: orb)
+        super.init(frame: .zero)
+        isOpaque = false
+        backgroundColor = .clear
+        contentMode = .redraw
+        isUserInteractionEnabled = false
+        isAccessibilityElement = false
+        // Resume on didBecomeActive: at willEnterForeground the app still
+        // reports .background, so the display link would stay stopped.
+        for name in [UIApplication.didEnterBackgroundNotification, UIApplication.didBecomeActiveNotification, UIAccessibility.reduceMotionStatusDidChangeNotification] {
+            observers.append(NotificationCenter.default.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
+                self?.syncLink()
+            })
+        }
+        registerForTraitChanges([UITraitUserInterfaceStyle.self]) { (self: OrbView, _) in self.setNeedsDisplay() }
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    deinit {
+        link?.invalidate()
+        observers.forEach(NotificationCenter.default.removeObserver)
+    }
+
+    /// Normalized 0…1 peaks. They quicken the motion, like the desktop orb.
+    func setLevels(microphone: Float, speaker: Float) {
+        renderer.setAudioLevels(microphone: microphone, speaker: speaker)
+    }
+
+    override var isHidden: Bool { didSet { syncLink() } }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        syncLink()
+    }
+
+    private var shouldAnimate: Bool {
+        window != nil && !isHidden && !UIAccessibility.isReduceMotionEnabled
+            && UIApplication.shared.applicationState != .background
+    }
+
+    private func syncLink() {
+        if shouldAnimate {
+            guard link == nil else { return }
+            let link = CADisplayLink(target: DisplayLinkProxy(self), selector: #selector(DisplayLinkProxy.tick))
+            link.preferredFrameRateRange = CAFrameRateRange(minimum: 30, maximum: 30, preferred: 30)
+            link.add(to: .main, forMode: .common)
+            self.link = link
+            redraw(animating: true)
+        } else {
+            link?.invalidate()
+            link = nil
+            // Stop the clock now, so the hidden time never plays back as a jump.
+            if window != nil { redraw(animating: false) }
+        }
+    }
+
+    fileprivate func tick() { redraw(animating: true) }
+
+    private func redraw(animating: Bool) {
+        frameData = renderer.nextFrame(animating: animating, reducedMotion: UIAccessibility.isReduceMotionEnabled)
+        setNeedsDisplay()
+    }
+
+    override func draw(_ rect: CGRect) {
+        guard let frame = frameData, frame.size > 0, let ctx = UIGraphicsGetCurrentContext() else { return }
+        let dark = traitCollection.userInterfaceStyle == .dark
+        // The preset's artwork, scaled uniformly to fit and centered.
+        let scale = min(bounds.width, bounds.height) / CGFloat(frame.size)
+        ctx.translateBy(x: (bounds.width - CGFloat(frame.size) * scale) / 2, y: (bounds.height - CGFloat(frame.size) * scale) / 2)
+        ctx.scaleBy(x: scale, y: scale)
+        ctx.setLineCap(.butt)
+        let lines = frame.lines
+        var i = 0
+        while i + 6 < lines.count {
+            ctx.setStrokeColor(gray: ink(lines[i + 5], dark), alpha: CGFloat(min(1, max(0, lines[i + 6]))))
+            ctx.setLineWidth(CGFloat(lines[i + 4]))
+            ctx.move(to: CGPoint(x: CGFloat(lines[i]), y: CGFloat(lines[i + 1])))
+            ctx.addLine(to: CGPoint(x: CGFloat(lines[i + 2]), y: CGFloat(lines[i + 3])))
+            ctx.strokePath()
+            i += 7
+        }
+        let dots = frame.dots
+        i = 0
+        while i + 4 < dots.count {
+            let r = CGFloat(dots[i + 2])
+            ctx.setFillColor(gray: ink(dots[i + 3], dark), alpha: CGFloat(min(1, max(0, dots[i + 4]))))
+            ctx.fillEllipse(in: CGRect(x: CGFloat(dots[i]) - r, y: CGFloat(dots[i + 1]) - r, width: r * 2, height: r * 2))
+            i += 5
+        }
+    }
+
+    /// Ink `white` on paper; dark appearances mirror it (desktop `ink_color`).
+    private func ink(_ white: Float, _ dark: Bool) -> CGFloat {
+        let w = CGFloat(min(1, max(0, white)))
+        return dark ? 1 - w : w
+    }
+}
+
+/// CADisplayLink retains its target; the proxy keeps the orb releasable.
+private final class DisplayLinkProxy: NSObject {
+    weak var view: OrbView?
+    init(_ view: OrbView) { self.view = view }
+    @objc func tick() { MainActor.assumeIsolated { view?.tick() } }
+}
diff --git a/apps/ios/Zeron/Voice/RemoteVoiceController.swift b/apps/ios/Zeron/Voice/RemoteVoiceController.swift
new file mode 100644
index 0000000000..2fa8096d04
--- /dev/null
+++ b/apps/ios/Zeron/Voice/RemoteVoiceController.swift
@@ -0,0 +1,331 @@
+import AudioToolbox
+import UIKit
+
+/// The app-wide voice orchestrator call. Audio runs on this phone; Codex, its
+/// credentials and the orchestrator chat run on a registered execution host
+/// (any device advertising `voice-client-media-v1`). One call at a time, no
+/// automatic reconnect: a dropped call explains itself and waits for a tap.
+@MainActor
+final class RemoteVoiceController {
+    static let capability = voiceHostCapability()
+    /// Development override: offer voice before any host advertises it.
+    static var forced: Bool {
+        ProcessInfo.processInfo.arguments.contains("-remote-voice") || ProcessInfo.processInfo.environment["ZERON_REMOTE_VOICE"] == "1"
+    }
+
+    private weak var app: AppModel?
+    private var call: VoiceCall?
+    private var media: NativeVoiceMedia?
+    private var generation: UInt64 = 0
+    private var observers: [UUID: () -> Void] = [:]
+    private var proximity: NSObjectProtocol?
+    /// The call in the Dynamic Island and on the Lock Screen.
+    private let liveActivity = VoiceActivityController()
+
+    private(set) var state: VoiceCallState?
+    /// Why the last call ended on its own; cleared by the next start.
+    private(set) var endReason: VoiceEndReason?
+    private(set) var muted = false
+    private(set) var hostName = ""
+    private(set) var activeSince: Date?
+    /// Styles the last host offered.
+    private(set) var styles: [String] = defaultVoiceStyles()
+
+    var live: Bool {
+        #if DEBUG
+        return call != nil || previewing
+        #else
+        return call != nil
+        #endif
+    }
+    var active: Bool { state?.phase == .active }
+    var orb: VoiceOrb { state?.orb ?? (live ? .connecting : .idle) }
+
+    init(app: AppModel) {
+        self.app = app
+        liveActivity.attach(to: self)
+    }
+
+    // MARK: Hosts and preferences
+
+    static func compatible(_ device: DeviceView) -> Bool {
+        device.isExecutionHost && device.capabilities.contains(capability)
+    }
+
+    /// Registered hosts that can take a call right now.
+    var hosts: [DeviceView] { app?.client?.devices().filter { $0.online && Self.compatible($0) } ?? [] }
+
+    /// Voice controls appear once any registered host can run them.
+    var available: Bool {
+        Self.forced || (app?.client?.devices().contains(where: Self.compatible) ?? false)
+    }
+
+    private var preferenceKey: String {
+        "remoteVoice.\(app?.client?.userId() ?? "none").\(app?.client?.orgId() ?? "none")"
+    }
+    var selectedHost: String? {
+        get { UserDefaults.standard.string(forKey: preferenceKey + ".host") }
+        set { if !live { UserDefaults.standard.set(newValue, forKey: preferenceKey + ".host"); changed() } }
+    }
+    var selectedStyle: String? {
+        get { UserDefaults.standard.string(forKey: preferenceKey + ".style") }
+        set { UserDefaults.standard.set(newValue, forKey: preferenceKey + ".style"); changed() }
+    }
+
+    /// The host a plain tap calls: the chosen one, or the only one online.
+    var startHost: DeviceView? {
+        let hosts = self.hosts
+        if let id = selectedHost, let host = hosts.first(where: { $0.id == id }) { return host }
+        return hosts.count == 1 ? hosts.first : nil
+    }
+
+    func observe(_ callback: @escaping () -> Void) -> AnyObject {
+        let id = UUID()
+        observers[id] = callback
+        return Token { [weak self] in self?.observers[id] = nil }
+    }
+    private func changed() { for callback in observers.values { callback() } }
+
+    // MARK: Call
+
+    /// Calls `host` (remembered for next time) or the default host. False
+    /// when there is no host to call; the caller offers the picker.
+    @discardableResult
+    func start(host: DeviceView? = nil) -> Bool {
+        guard !live, let client = app?.client, let device = host ?? startHost else { return false }
+        if host != nil { selectedHost = device.id }
+        generation &+= 1
+        state = nil; endReason = nil; muted = false; activeSince = nil
+        hostName = device.name
+        let media = NativeVoiceMedia()
+        self.media = media
+        let generation = self.generation
+        media.onFailure = { [weak self] in
+            guard let self, self.generation == generation else { return }
+            self.finish(reason: .audioUnavailable)
+        }
+        let listener = VoiceListenerBridge(controller: self, generation: generation)
+        let call = client.startVoice(hostDeviceId: device.id, voice: selectedStyle, media: media, listener: listener)
+        self.call = call
+        media.call = call
+        // A call keeps the screen awake, like the phone app.
+        UIApplication.shared.isIdleTimerDisabled = true
+        UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+        // The call sounds as it is placed, well before the microphone opens.
+        CallSound.start.play()
+        changed()
+        return true
+    }
+
+    func toggleMute() {
+        guard live else { return }
+        muted.toggle()
+        media?.muteLocally(muted)
+        call?.setMuted(muted: muted)
+        UIImpactFeedbackGenerator(style: .light).impactOccurred()
+        changed()
+    }
+
+    /// The user hangs up. Local capture stops before any remote control.
+    func stop() {
+        guard live else { return }
+        UIImpactFeedbackGenerator(style: .rigid).impactOccurred()
+        finish(reason: nil)
+    }
+
+    func dismissEndReason() {
+        guard endReason != nil else { return }
+        endReason = nil
+        changed()
+    }
+
+    private func finish(reason: VoiceEndReason?) {
+        #if DEBUG
+        previewing = false
+        previewTimer?.invalidate()
+        #endif
+        generation &+= 1
+        // A hang-up or a connected call ending sounds; a failure to connect
+        // only explains itself.
+        let sounds = call != nil && (activeSince != nil || reason == nil)
+        media?.close()
+        call?.stop()
+        // After close: the call's audio session no longer ducks it.
+        if sounds { CallSound.end.play() }
+        call = nil; media = nil; state = nil; activeSince = nil
+        endReason = reason
+        setProximityMonitoring(false)
+        UIApplication.shared.isIdleTimerDisabled = false
+        if let reason {
+            UINotificationFeedbackGenerator().notificationOccurred(.error)
+            // The stage explains a failure itself; elsewhere a toast does.
+            if let window = Self.keyWindow, !(Self.top(window.rootViewController) is VoiceStageViewController) {
+                endReason = nil
+                Toast.show(message(for: reason), action: reason == .microphoneDenied ? "Settings" : "Retry", in: window) { [weak self] in
+                    if reason == .microphoneDenied, let url = URL(string: UIApplication.openSettingsURLString) {
+                        UIApplication.shared.open(url)
+                    } else if let self, let app = self.app, self.start() {
+                        Self.top(window.rootViewController)?.presentVoiceStage(app: app, source: nil)
+                    }
+                }
+            }
+        }
+        changed()
+    }
+
+    private static var keyWindow: UIWindow? {
+        UIApplication.shared.connectedScenes.compactMap { ($0 as? UIWindowScene)?.keyWindow }.first
+    }
+
+    private static func top(_ controller: UIViewController?) -> UIViewController? {
+        var top = controller
+        while let presented = top?.presentedViewController { top = presented }
+        return top
+    }
+
+    fileprivate func receive(_ state: VoiceCallState, generation: UInt64) {
+        guard generation == self.generation, live else { return }
+        let becameActive = state.phase == .active && self.state?.phase != .active
+        self.state = state
+        if !state.voices.isEmpty { styles = state.voices }
+        if becameActive {
+            activeSince = Date()
+            setProximityMonitoring(true)
+            UINotificationFeedbackGenerator().notificationOccurred(.success)
+        }
+        changed()
+    }
+
+    fileprivate func closed(_ reason: VoiceEndReason?, generation: UInt64) {
+        guard generation == self.generation, live else { return }
+        finish(reason: reason)
+    }
+
+    /// Held to the ear the screen goes dark and audio moves to the earpiece;
+    /// in hand it plays on the loudspeaker. No-op on devices without a sensor.
+    private func setProximityMonitoring(_ on: Bool) {
+        UIDevice.current.isProximityMonitoringEnabled = on
+        if on, proximity == nil {
+            proximity = NotificationCenter.default.addObserver(forName: UIDevice.proximityStateDidChangeNotification, object: nil, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated { self?.media?.setNearEar(UIDevice.current.proximityState) }
+            }
+        } else if !on, let proximity {
+            NotificationCenter.default.removeObserver(proximity)
+            self.proximity = nil
+        }
+    }
+
+    // MARK: Presentation
+
+    /// `m:ss`, or `h:mm:ss` past the hour (desktop `format_elapsed`).
+    var elapsedText: String? {
+        guard let activeSince else { return nil }
+        let seconds = max(0, Int(Date().timeIntervalSince(activeSince)))
+        let (h, m, s) = (seconds / 3600, seconds / 60 % 60, seconds % 60)
+        return h > 0 ? String(format: "%d:%02d:%02d", h, m, s) : String(format: "%d:%02d", m, s)
+    }
+
+    /// One line for what the call is doing now.
+    var statusText: String {
+        guard let state else { return live ? "Calling \(hostName)…" : "Codex voice" }
+        if state.phase == .connecting { return "Connecting to \(hostName)…" }
+        if state.phase == .ending { return "Ending…" }
+        switch state.orb {
+        case .speaking: return "Speaking"
+        case .awaitingInput: return "Codex needs your answer"
+        case .working: return "Working on it…"
+        case .muted: return "Muted"
+        default: return "Listening"
+        }
+    }
+
+    func message(for reason: VoiceEndReason) -> String {
+        Self.message(for: reason, host: hostName.isEmpty ? "the selected device" : hostName)
+    }
+
+    static func message(for reason: VoiceEndReason, host: String) -> String {
+        switch reason {
+        case .microphoneDenied: return "Zeron needs microphone access to talk with Codex."
+        case .audioUnavailable: return "The audio connection closed. Start a new call to reconnect."
+        case .signInRequired: return "Sign in to Codex with ChatGPT on \(host)."
+        case .usageUnavailable: return "Codex usage is currently unavailable on \(host)."
+        case .busy: return "\(host) is already on a voice call."
+        case .hostUnavailable: return "\(host) isn't reachable right now."
+        case .hostIncompatible: return "Update Zeron on \(host) and enable remote voice there."
+        case .connectionLost: return "The call dropped. Start a new one to reconnect."
+        }
+    }
+
+    #if DEBUG
+    private var previewing = false
+    private var previewTimer: Timer?
+
+    /// `-voice-preview`: a scripted call for screenshots and UI work — the
+    /// orb walks through listening, speaking and working with synthetic
+    /// levels. No audio, host or relay is involved.
+    func preview() {
+        previewing = true
+        hostName = "Fedora"
+        activeSince = Date().addingTimeInterval(-83)
+        let script: [(VoiceOrb, VoiceCallWork, String, VoiceSpeaker?)] = [
+            (.listening, .idle, "Open a chat on the Mac and ask Claude to fix the failing sync test", .user),
+            (.speaking, .idle, "On it. I'm starting a Claude session in the comet project to look at the sync test.", nil),
+            (.working, .working, "On it. I'm starting a Claude session in the comet project to look at the sync test.", .assistant),
+            (.awaitingInput, .awaitingInput, "Claude wants to know whether to update the fixture or the parser.", .assistant),
+        ]
+        var step = 0
+        previewTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self else { return }
+                let turn = (step / 40) % script.count
+                let (orb, work, caption, speaker) = script[turn]
+                let wave = Float(abs(sin(Double(step) / 2.3)))
+                // Words stream in, about three per second, like a live partial.
+                let words = caption.split(separator: " ")
+                let streamed = words.prefix(1 + (step % 40) / 3).joined(separator: " ")
+                self.state = VoiceCallState(phase: .active, orb: orb, chatId: "voice-orchestrator-preview", work: work, muted: self.muted, speaking: orb == .speaking, caption: streamed, captionSpeaker: speaker, captionItem: "preview-\(turn)", microphone: orb == .listening ? wave : 0, speaker: orb == .speaking ? wave : 0, voices: [])
+                step += 1
+                self.changed()
+            }
+        }
+    }
+    #endif
+
+    private final class Token {
+        let cancel: () -> Void
+        init(cancel: @escaping () -> Void) { self.cancel = cancel }
+        deinit { cancel() }
+    }
+}
+
+/// The call's two sounds, as system sounds: they play beside the call's own
+/// audio session and follow the ringer switch, like the phone's.
+@MainActor
+private enum CallSound: String {
+    case start = "voice-start"
+    case end = "voice-end"
+
+    private static var loaded: [CallSound: SystemSoundID] = [:]
+
+    func play() {
+        if Self.loaded[self] == nil, let url = Bundle.main.url(forResource: rawValue, withExtension: "wav") {
+            var id: SystemSoundID = 0
+            if AudioServicesCreateSystemSoundID(url as CFURL, &id) == kAudioServicesNoError { Self.loaded[self] = id }
+        }
+        if let id = Self.loaded[self] { AudioServicesPlaySystemSound(id) }
+    }
+}
+
+private final class VoiceListenerBridge: VoiceSessionListener, @unchecked Sendable {
+    private weak var controller: RemoteVoiceController?
+    private let generation: UInt64
+    init(controller: RemoteVoiceController, generation: UInt64) { self.controller = controller; self.generation = generation }
+    func onVoiceState(state: VoiceCallState) {
+        let controller = controller; let generation = generation
+        Task { @MainActor [weak controller] in controller?.receive(state, generation: generation) }
+    }
+    func onVoiceClosed(reason: VoiceEndReason?) {
+        let controller = controller; let generation = generation
+        Task { @MainActor [weak controller] in controller?.closed(reason, generation: generation) }
+    }
+}
diff --git a/apps/ios/Zeron/Voice/Sounds/voice-end.wav b/apps/ios/Zeron/Voice/Sounds/voice-end.wav
new file mode 100644
index 0000000000000000000000000000000000000000..d2be6c2b86eae843c72a099bda261dcee692eeff
GIT binary patch
literal 165164
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%0AbpTe%#epqIg2mJ#V6&UA+pi->FIm<u3h@#d`)j`
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
Nqx}D0^S|>5{2xr)hxh;h

literal 0
HcmV?d00001

diff --git a/apps/ios/Zeron/Voice/Sounds/voice-start.wav b/apps/ios/Zeron/Voice/Sounds/voice-start.wav
new file mode 100644
index 0000000000000000000000000000000000000000..866e5957be9429222b676fe499420dae33f987ae
GIT binary patch
literal 172844
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
WZ}lhozuV5Uzv2Hs<NwV&@V@|N;+NI{

literal 0
HcmV?d00001

diff --git a/apps/ios/Zeron/Voice/ThinkingOrbs-LICENSE.txt b/apps/ios/Zeron/Voice/ThinkingOrbs-LICENSE.txt
new file mode 100644
index 0000000000..77841b14ef
--- /dev/null
+++ b/apps/ios/Zeron/Voice/ThinkingOrbs-LICENSE.txt
@@ -0,0 +1,30 @@
+The voice orb (zeron-orb) is extracted from Bezel
+(https://github.com/clearloop/bezel, revision
+6141af9c16f7353cdf36003f7404e0a94566a163), a port of gpui-thinking-orbs
+(https://github.com/FrancoEscob/gpui-thinking-orbs), itself a port of
+thinking-orbs by Jakub Antalik (https://github.com/Jakubantalik/thinking-orbs).
+
+MIT License
+
+Copyright (c) 2026 clearloop
+Copyright (c) 2026 Wing (portions extracted from zeronsh/comet)
+Copyright (c) 2026 gpui-thinking-orbs contributors
+Copyright (c) 2026 Jakub Antalik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/apps/ios/Zeron/Voice/VoiceActivityController.swift b/apps/ios/Zeron/Voice/VoiceActivityController.swift
new file mode 100644
index 0000000000..8f4f8d15d9
--- /dev/null
+++ b/apps/ios/Zeron/Voice/VoiceActivityController.swift
@@ -0,0 +1,103 @@
+import ActivityKit
+import Foundation
+
+/// Mirrors the call into its Live Activity (`ZeronLiveActivity`): requested
+/// when a call starts (the app is in front then), updated as the orb changes
+/// state and ended with the call. The Dynamic Island only shows it once Zeron
+/// leaves the screen. Its mute and end buttons drive this controller's call.
+@MainActor
+final class VoiceActivityController {
+    private weak var voice: RemoteVoiceController?
+    private var token: AnyObject?
+    private var activity: Activity<VoiceActivityAttributes>?
+    private var sent: VoiceActivityAttributes.ContentState?
+    private var sentAt = Date.distantPast
+    private var pending: Task<Void, Never>?
+
+    /// Orb states flip with every sentence; the island needs at most one
+    /// update a second to keep up.
+    private static let interval: TimeInterval = 1
+
+    func attach(to voice: RemoteVoiceController) {
+        self.voice = voice
+        token = voice.observe { [weak self] in self?.sync() }
+        VoiceActivityAction.handler = { [weak voice] action in
+            switch action {
+            case .toggleMute: voice?.toggleMute()
+            case .end: voice?.stop()
+            }
+        }
+        // A call never outlives its process: anything still showing is stale.
+        Task {
+            for stale in Activity<VoiceActivityAttributes>.activities where stale.id != activity?.id {
+                await stale.end(nil, dismissalPolicy: .immediate)
+            }
+        }
+    }
+
+    private func sync() {
+        guard let voice, voice.live else { return end() }
+        let state = VoiceActivityAttributes.ContentState(orb: Self.orb(voice), muted: voice.muted, since: voice.activeSince)
+        guard let activity else { return start(host: voice.hostName, state: state) }
+        guard state != sent else {
+            pending?.cancel()
+            pending = nil
+            return
+        }
+        pending?.cancel()
+        let delay = Self.interval - Date().timeIntervalSince(sentAt)
+        // Mute, end and the call going live answer at once; orb flips settle.
+        let urgent = state.muted != sent?.muted || state.since != sent?.since
+        pending = Task { [weak self] in
+            if !urgent, delay > 0 {
+                try? await Task.sleep(for: .seconds(delay))
+                if Task.isCancelled { return }
+            }
+            self?.send(state, to: activity)
+        }
+    }
+
+    private func start(host: String, state: VoiceActivityAttributes.ContentState) {
+        guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+        do {
+            activity = try Activity.request(
+                attributes: VoiceActivityAttributes(host: host),
+                content: ActivityContent(state: state, staleDate: nil),
+                pushType: nil
+            )
+            sent = state
+            sentAt = Date()
+        } catch {
+            activity = nil
+        }
+    }
+
+    private func send(_ state: VoiceActivityAttributes.ContentState, to activity: Activity<VoiceActivityAttributes>) {
+        guard activity.id == self.activity?.id else { return }
+        sent = state
+        sentAt = Date()
+        Task { await activity.update(ActivityContent(state: state, staleDate: nil)) }
+    }
+
+    private func end() {
+        pending?.cancel()
+        pending = nil
+        guard let activity else { return }
+        self.activity = nil
+        let last = sent
+        sent = nil
+        Task { await activity.end(last.map { ActivityContent(state: $0, staleDate: nil) }, dismissalPolicy: .immediate) }
+    }
+
+    private static func orb(_ voice: RemoteVoiceController) -> VoiceActivityOrb {
+        guard let state = voice.state, state.phase == .active else { return .connecting }
+        switch state.orb {
+        case .speaking: return .speaking
+        case .working: return .working
+        case .awaitingInput: return .awaiting
+        case .listening: return .listening
+        case .connecting: return .connecting
+        case .muted, .idle: return .muted
+        }
+    }
+}
diff --git a/apps/ios/Zeron/Voice/VoiceControls.swift b/apps/ios/Zeron/Voice/VoiceControls.swift
new file mode 100644
index 0000000000..719b82b5d8
--- /dev/null
+++ b/apps/ios/Zeron/Voice/VoiceControls.swift
@@ -0,0 +1,205 @@
+import UIKit
+
+/// Voice inside the tab bar's bottom accessory. Idle: a round waveform button
+/// beside "New session" (tap to call, hold for host and style). Live: a call
+/// strip with the orb, the call clock and mute/hang-up — tap it for the stage.
+final class VoiceAccessoryView: UIView {
+    var onStart: ((UIView) -> Void)?
+    var onOpen: ((UIView) -> Void)?
+    var onMute: (() -> Void)?
+    var onEnd: (() -> Void)?
+
+    private(set) var live = false
+    let startButton = UIButton(type: .system)
+    private let strip = PressableControl()
+    let orb = OrbView(preset: .avatar, orb: .connecting)
+    private let title = UILabel()
+    private let detail = UILabel()
+    private let mute = UIButton(type: .system)
+    private let end = UIButton(type: .system)
+    private var inline = false
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        var config = UIButton.Configuration.filled()
+        config.image = UIImage(systemName: "waveform", withConfiguration: UIImage.SymbolConfiguration(pointSize: 15, weight: .semibold))
+        config.baseForegroundColor = Palette.accent
+        config.baseBackgroundColor = Palette.accentSoft
+        config.cornerStyle = .capsule
+        startButton.configuration = config
+        startButton.accessibilityLabel = "Talk to Codex"
+        startButton.accessibilityHint = "Starts a voice call. Touch and hold to choose the device and voice."
+        startButton.accessibilityIdentifier = "voice-start"
+        startButton.addAction(UIAction { [weak self] _ in
+            guard let self else { return }
+            self.onStart?(self.startButton)
+        }, for: .primaryActionTriggered)
+
+        orb.isUserInteractionEnabled = false
+        title.font = Fonts.ui(.sansMedium, 15)
+        title.textColor = Palette.text
+        detail.font = Fonts.ui(.monoMedium, 12)
+        detail.textColor = Palette.secondary
+        let labels = UIStackView(arrangedSubviews: [title, detail])
+        labels.axis = .vertical
+        labels.spacing = 0
+        labels.isUserInteractionEnabled = false
+        for (button, symbol, tint, fill) in [
+            (mute, "mic.fill", Palette.text, Palette.controlFill),
+            (end, "phone.down.fill", UIColor.white, UIColor.systemRed),
+        ] {
+            var config = UIButton.Configuration.filled()
+            config.image = UIImage(systemName: symbol, withConfiguration: UIImage.SymbolConfiguration(pointSize: 13, weight: .bold))
+            config.baseForegroundColor = tint
+            config.baseBackgroundColor = fill
+            config.cornerStyle = .capsule
+            button.configuration = config
+            button.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                button.widthAnchor.constraint(equalToConstant: 32),
+                button.heightAnchor.constraint(equalToConstant: 32),
+            ])
+        }
+        mute.addAction(UIAction { [weak self] _ in self?.onMute?() }, for: .primaryActionTriggered)
+        end.addAction(UIAction { [weak self] _ in self?.onEnd?() }, for: .primaryActionTriggered)
+        end.accessibilityLabel = "End call"
+        end.accessibilityIdentifier = "voice-accessory-end"
+        strip.accessibilityIdentifier = "voice-live"
+        strip.isAccessibilityElement = true
+        strip.accessibilityTraits = .button
+        // A plain UIControl never sends .primaryActionTriggered (only buttons do).
+        strip.addAction(UIAction { [weak self] _ in
+            guard let self else { return }
+            self.onOpen?(self.orb)
+        }, for: .touchUpInside)
+
+        for v in [orb, labels, mute, end] as [UIView] {
+            v.translatesAutoresizingMaskIntoConstraints = false
+            strip.addSubview(v)
+        }
+        for v in [startButton, strip] as [UIView] {
+            v.translatesAutoresizingMaskIntoConstraints = false
+            addSubview(v)
+        }
+        NSLayoutConstraint.activate([
+            startButton.trailingAnchor.constraint(equalTo: trailingAnchor),
+            startButton.centerYAnchor.constraint(equalTo: centerYAnchor),
+            startButton.widthAnchor.constraint(equalToConstant: 34),
+            startButton.heightAnchor.constraint(equalToConstant: 34),
+            startButton.leadingAnchor.constraint(greaterThanOrEqualTo: leadingAnchor),
+
+            strip.topAnchor.constraint(equalTo: topAnchor),
+            strip.bottomAnchor.constraint(equalTo: bottomAnchor),
+            strip.leadingAnchor.constraint(equalTo: leadingAnchor),
+            strip.trailingAnchor.constraint(equalTo: trailingAnchor),
+            orb.leadingAnchor.constraint(equalTo: strip.leadingAnchor),
+            orb.centerYAnchor.constraint(equalTo: strip.centerYAnchor),
+            orb.widthAnchor.constraint(equalToConstant: 34),
+            orb.heightAnchor.constraint(equalToConstant: 34),
+            labels.leadingAnchor.constraint(equalTo: orb.trailingAnchor, constant: 8),
+            labels.centerYAnchor.constraint(equalTo: strip.centerYAnchor),
+            labels.trailingAnchor.constraint(lessThanOrEqualTo: mute.leadingAnchor, constant: -8),
+            mute.trailingAnchor.constraint(equalTo: end.leadingAnchor, constant: -6),
+            mute.centerYAnchor.constraint(equalTo: strip.centerYAnchor),
+            end.trailingAnchor.constraint(equalTo: strip.trailingAnchor),
+            end.centerYAnchor.constraint(equalTo: strip.centerYAnchor),
+        ])
+        strip.isHidden = true
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    /// Minimized tab bar: the orb, the clock and hang-up only.
+    func setInline(_ inline: Bool) {
+        self.inline = inline
+        title.isHidden = inline
+        mute.isHidden = inline
+    }
+
+    func update(_ voice: RemoteVoiceController) {
+        live = voice.live
+        startButton.isHidden = live
+        strip.isHidden = !live
+        orb.isHidden = !live
+        guard live else { return }
+        let state = voice.state
+        orb.orb = voice.orb
+        orb.setLevels(microphone: state?.microphone ?? 0, speaker: state?.speaker ?? 0)
+        title.text = state?.work == .awaitingInput ? "Codex needs you" : "Codex"
+        title.textColor = state?.work == .awaitingInput ? Palette.warning : Palette.text
+        detail.text = voice.active ? [voice.elapsedText, voice.muted ? "Muted" : nil].compactMap { $0 }.joined(separator: " · ") : "Connecting…"
+        var config = mute.configuration
+        config?.image = UIImage(systemName: voice.muted ? "mic.slash.fill" : "mic.fill", withConfiguration: UIImage.SymbolConfiguration(pointSize: 13, weight: .bold))
+        config?.baseBackgroundColor = voice.muted ? Palette.text : Palette.controlFill
+        config?.baseForegroundColor = voice.muted ? Palette.background : Palette.text
+        mute.configuration = config
+        mute.accessibilityLabel = voice.muted ? "Unmute microphone" : "Mute microphone"
+        strip.accessibilityLabel = "Voice call, \(voice.statusText)" + (voice.elapsedText.map { ", \($0)" } ?? "")
+        strip.accessibilityHint = "Opens the call"
+    }
+}
+
+/// A plain control that dims while pressed.
+class PressableControl: UIControl {
+    override var isHighlighted: Bool {
+        didSet { UIView.animate(withDuration: 0.15) { self.alpha = self.isHighlighted ? 0.6 : 1 } }
+    }
+}
+
+/// Voice in a navigation bar or toolbar: a waveform to start, the live orb
+/// while a call runs. Used beside an open session and in the iPad sidebar.
+@MainActor
+final class VoiceBarItem {
+    let item: UIBarButtonItem
+    private let app: AppModel
+    private let button = UIButton(type: .system)
+    private let orb = OrbView(preset: .avatar, orb: .connecting)
+    private weak var host: UIViewController?
+    private var token: AnyObject?
+
+    init(app: AppModel, host: UIViewController) {
+        self.app = app
+        self.host = host
+        orb.isUserInteractionEnabled = false
+        orb.translatesAutoresizingMaskIntoConstraints = false
+        button.translatesAutoresizingMaskIntoConstraints = false
+        button.addSubview(orb)
+        NSLayoutConstraint.activate([
+            button.widthAnchor.constraint(equalToConstant: 36),
+            button.heightAnchor.constraint(equalToConstant: 36),
+            orb.centerXAnchor.constraint(equalTo: button.centerXAnchor),
+            orb.centerYAnchor.constraint(equalTo: button.centerYAnchor),
+            orb.widthAnchor.constraint(equalToConstant: 32),
+            orb.heightAnchor.constraint(equalToConstant: 32),
+        ])
+        button.setImage(UIImage(systemName: "waveform", withConfiguration: UIImage.SymbolConfiguration(pointSize: 16, weight: .semibold)), for: .normal)
+        button.tintColor = Palette.text
+        button.accessibilityIdentifier = "voice-bar"
+        item = UIBarButtonItem(customView: button)
+        button.addAction(UIAction { [weak self] _ in
+            guard let self, let host = self.host else { return }
+            host.openVoice(app: app, source: self.button)
+        }, for: .primaryActionTriggered)
+        token = app.voice.observe { [weak self] in self?.refresh() }
+        refresh()
+    }
+
+    var visible: Bool { app.voice.live || app.voice.available }
+
+    private var shownLive: Bool?
+
+    private func refresh() {
+        let voice = app.voice
+        if voice.live {
+            orb.orb = voice.orb
+            orb.setLevels(microphone: voice.state?.microphone ?? 0, speaker: voice.state?.speaker ?? 0)
+        }
+        button.accessibilityLabel = voice.live ? "Voice call, \(voice.statusText)" : "Talk to Codex"
+        guard shownLive != voice.live else { return }
+        shownLive = voice.live
+        orb.isHidden = !voice.live
+        button.setImage(voice.live ? nil : UIImage(systemName: "waveform", withConfiguration: UIImage.SymbolConfiguration(pointSize: 16, weight: .semibold)), for: .normal)
+        // Holding the live orb must not offer to change the call's host.
+        button.menu = voice.live ? nil : host?.voiceMenu(app: app)
+    }
+}
diff --git a/apps/ios/Zeron/Voice/VoiceStageViewController.swift b/apps/ios/Zeron/Voice/VoiceStageViewController.swift
new file mode 100644
index 0000000000..056f654466
--- /dev/null
+++ b/apps/ios/Zeron/Voice/VoiceStageViewController.swift
@@ -0,0 +1,432 @@
+import AVKit
+import UIKit
+
+/// The full-screen call (desktop `voice_stage.rs`): the session's orb over the
+/// wallpaper, the live caption, and the call controls. Swipe down to get back
+/// to the app; the call continues until End. Held to the ear it behaves like a
+/// phone call — screen off, audio in the earpiece.
+final class VoiceStageViewController: UIViewController {
+    private let app: AppModel
+    private var voice: RemoteVoiceController { app.voice }
+    private var token: AnyObject?
+    private let wallpaper = WallpaperView()
+    private let orb = OrbView(preset: .hero, orb: .connecting)
+    private let dot = UIView()
+    private let clock = UILabel()
+    private let host = UILabel()
+    private let status = UILabel()
+    private let caption = UILabel()
+    /// The previous speaker turn, fading out over the new caption.
+    private let previousCaption = UILabel()
+    /// Streamed words veil in as on desktop (`zeron-veil` through the core).
+    private let captionFader = CaptionFader(maxChars: 160)
+    private var captionLink: CADisplayLink?
+    private var captionSource: (item: String?, text: String, user: Bool) = (nil, "", false)
+    /// The caption holds an end-of-call message instead of the utterance.
+    private var captionShowsMessage = false
+    private lazy var minimize = Glass.circleButton(symbol: "chevron.down", size: 44, pointSize: 16, action: UIAction { [weak self] _ in
+        self?.dismiss(animated: true)
+    })
+    private lazy var transcript = Glass.circleButton(symbol: "text.bubble", size: 44, pointSize: 16, action: UIAction { [weak self] _ in
+        self?.openTranscript()
+    })
+    private let badge = UIView()
+    private let bar = Glass.surface()
+    private let controls = UIStackView()
+    private lazy var mute = Self.callButton(symbol: "mic.fill", tint: Palette.text, background: Palette.controlFill) { [weak self] in
+        self?.voice.toggleMute()
+    }
+    private let route = AVRoutePickerView()
+    private lazy var routeWell = Self.well(route)
+    private lazy var end = Self.callButton(symbol: "phone.down.fill", tint: .white, background: .systemRed, width: 88) { [weak self] in
+        self?.voice.stop()
+    }
+    private lazy var retry = Self.pillButton(title: "Call again", tint: .white, background: Palette.accent) { [weak self] in
+        self?.retryCall()
+    }
+    private lazy var close = Self.pillButton(title: "Close", tint: Palette.text, background: Palette.controlFill) { [weak self] in
+        self?.voice.dismissEndReason()
+        self?.dismiss(animated: true)
+    }
+    private var shownMuted: Bool?
+
+    init(app: AppModel) {
+        self.app = app
+        super.init(nibName: nil, bundle: nil)
+        modalPresentationStyle = .fullScreen
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = Palette.background
+        view.accessibilityIdentifier = "voice-stage"
+        view.addSubview(wallpaper)
+
+        orb.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(orb)
+
+        dot.layer.cornerRadius = 3.5
+        dot.translatesAutoresizingMaskIntoConstraints = false
+        clock.font = Fonts.ui(.monoMedium, 13)
+        clock.textColor = Palette.secondary
+        host.font = Fonts.ui(.sansMedium, 13)
+        host.textColor = Palette.tertiary
+        let header = UIStackView(arrangedSubviews: [dot, clock, host])
+        header.spacing = 7
+        header.alignment = .center
+        header.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(header)
+
+        status.font = Fonts.ui(.sansMedium, 17)
+        status.textColor = Palette.text
+        status.textAlignment = .center
+        status.accessibilityTraits = .updatesFrequently
+        caption.font = Fonts.ui(.sans, 16)
+        caption.textColor = Palette.secondary
+        caption.textAlignment = .center
+        caption.numberOfLines = 4
+        caption.lineBreakMode = .byTruncatingHead
+        previousCaption.font = caption.font
+        previousCaption.textColor = Palette.secondary
+        previousCaption.textAlignment = .center
+        previousCaption.numberOfLines = 4
+        previousCaption.isAccessibilityElement = false
+        previousCaption.isHidden = true
+        for label in [status, caption, previousCaption] {
+            label.translatesAutoresizingMaskIntoConstraints = false
+            view.addSubview(label)
+        }
+
+        minimize.accessibilityLabel = "Back to Zeron"
+        minimize.accessibilityIdentifier = "voice-minimize"
+        transcript.accessibilityLabel = "Open the voice transcript"
+        transcript.accessibilityIdentifier = "voice-transcript"
+        badge.backgroundColor = Palette.warning
+        badge.layer.cornerRadius = 5
+        badge.layer.borderWidth = 2
+        badge.layer.borderColor = Palette.background.cgColor
+        badge.isUserInteractionEnabled = false
+        badge.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(minimize)
+        view.addSubview(transcript)
+        view.addSubview(badge)
+
+        route.activeTintColor = Palette.accent
+        route.tintColor = Palette.text
+        route.prioritizesVideoDevices = false
+        routeWell.accessibilityLabel = "Audio output"
+        mute.accessibilityIdentifier = "voice-mute"
+        end.accessibilityLabel = "End call"
+        end.accessibilityIdentifier = "voice-end"
+        retry.accessibilityIdentifier = "voice-retry"
+        controls.axis = .horizontal
+        controls.spacing = 14
+        controls.alignment = .center
+        controls.translatesAutoresizingMaskIntoConstraints = false
+        for v in [mute, routeWell, end, retry, close] { controls.addArrangedSubview(v) }
+        bar.contentView.addSubview(controls)
+        bar.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(bar)
+
+        let side = orb.widthAnchor.constraint(equalToConstant: 340)
+        side.priority = .defaultHigh
+        NSLayoutConstraint.activate([
+            minimize.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 8),
+            minimize.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
+            transcript.centerYAnchor.constraint(equalTo: minimize.centerYAnchor),
+            transcript.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
+            badge.widthAnchor.constraint(equalToConstant: 10),
+            badge.heightAnchor.constraint(equalToConstant: 10),
+            badge.topAnchor.constraint(equalTo: transcript.topAnchor, constant: 2),
+            badge.trailingAnchor.constraint(equalTo: transcript.trailingAnchor, constant: -2),
+            dot.widthAnchor.constraint(equalToConstant: 7),
+            dot.heightAnchor.constraint(equalToConstant: 7),
+            header.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            header.centerYAnchor.constraint(equalTo: minimize.centerYAnchor),
+            header.leadingAnchor.constraint(greaterThanOrEqualTo: minimize.trailingAnchor, constant: 12),
+
+            orb.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            orb.centerYAnchor.constraint(equalTo: view.safeAreaLayoutGuide.centerYAnchor, constant: -64),
+            side,
+            orb.widthAnchor.constraint(lessThanOrEqualTo: view.widthAnchor, constant: -32),
+            orb.heightAnchor.constraint(equalTo: orb.widthAnchor),
+            orb.topAnchor.constraint(greaterThanOrEqualTo: minimize.bottomAnchor, constant: 8),
+
+            status.topAnchor.constraint(equalTo: orb.bottomAnchor, constant: 4),
+            status.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 32),
+            status.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -32),
+            caption.topAnchor.constraint(equalTo: status.bottomAnchor, constant: 10),
+            caption.leadingAnchor.constraint(equalTo: status.leadingAnchor),
+            caption.trailingAnchor.constraint(equalTo: status.trailingAnchor),
+            caption.bottomAnchor.constraint(lessThanOrEqualTo: bar.topAnchor, constant: -16),
+            previousCaption.topAnchor.constraint(equalTo: caption.topAnchor),
+            previousCaption.leadingAnchor.constraint(equalTo: caption.leadingAnchor),
+            previousCaption.trailingAnchor.constraint(equalTo: caption.trailingAnchor),
+
+            bar.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            bar.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -20),
+            controls.topAnchor.constraint(equalTo: bar.contentView.topAnchor, constant: 10),
+            controls.bottomAnchor.constraint(equalTo: bar.contentView.bottomAnchor, constant: -10),
+            controls.leadingAnchor.constraint(equalTo: bar.contentView.leadingAnchor, constant: 10),
+            controls.trailingAnchor.constraint(equalTo: bar.contentView.trailingAnchor, constant: -10),
+        ])
+
+        let swipe = UISwipeGestureRecognizer(target: self, action: #selector(swipeDown))
+        swipe.direction = .down
+        view.addGestureRecognizer(swipe)
+
+        token = voice.observe { [weak self] in self?.refresh() }
+        // The veil colors are resolved per appearance.
+        registerForTraitChanges([UITraitUserInterfaceStyle.self]) { (self: VoiceStageViewController, _) in
+            if !self.captionShowsMessage { self.paintCaption() }
+        }
+        refresh()
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        wallpaper.frame = CGRect(x: 0, y: 0, width: view.bounds.width, height: min(view.bounds.height * 0.72, 760))
+    }
+
+    @objc private func swipeDown() { dismiss(animated: true) }
+
+    private func refresh() {
+        let voice = self.voice
+        guard voice.live || voice.endReason != nil else {
+            // Hung up (here or elsewhere): the stage has nothing left to show.
+            if presentingViewController != nil, !isBeingDismissed { dismiss(animated: true) }
+            return
+        }
+        let state = voice.state
+        orb.orb = voice.live ? voice.orb : .idle
+        orb.setLevels(microphone: state?.microphone ?? 0, speaker: state?.speaker ?? 0)
+
+        let awaiting = state?.work == .awaitingInput
+        dot.backgroundColor = !voice.active ? Palette.tertiary : awaiting ? Palette.warning : voice.muted ? Palette.tertiary : Palette.success
+        clock.text = voice.elapsedText ?? "–:––"
+        host.text = voice.hostName
+        transcript.isHidden = state?.chatId == nil
+        badge.isHidden = transcript.isHidden || !awaiting
+        transcript.accessibilityLabel = awaiting ? "Answer Codex in the transcript" : "Open the voice transcript"
+
+        if let reason = voice.endReason, !voice.live {
+            status.text = "Call ended"
+            stopCaptionLink()
+            captionShowsMessage = true
+            previousCaption.isHidden = true
+            caption.attributedText = nil
+            caption.text = voice.message(for: reason)
+            caption.textColor = Palette.secondary
+            retry.configuration?.title = reason == .microphoneDenied ? "Open Settings" : "Call again"
+        } else {
+            status.text = voice.statusText
+            let source = (item: state?.captionItem, text: state?.caption ?? "", user: state?.captionSpeaker == .user)
+            if captionShowsMessage || source != captionSource {
+                captionShowsMessage = false
+                captionSource = source
+                paintCaption()
+            }
+        }
+        let ended = !voice.live
+        for v in [mute, routeWell, end] { v.isHidden = ended }
+        for v in [retry, close] { v.isHidden = !ended }
+        if shownMuted != voice.muted {
+            shownMuted = voice.muted
+            var config = mute.configuration
+            config?.image = UIImage(systemName: voice.muted ? "mic.slash.fill" : "mic.fill", withConfiguration: UIImage.SymbolConfiguration(pointSize: 20, weight: .semibold))
+            // Inverted plate while muted, like the desktop call bar.
+            config?.baseBackgroundColor = voice.muted ? Palette.text : Palette.controlFill
+            config?.baseForegroundColor = voice.muted ? Palette.background : Palette.text
+            mute.configuration = config
+            mute.accessibilityLabel = voice.muted ? "Unmute microphone" : "Mute microphone"
+        }
+    }
+
+    private func openTranscript() {
+        guard let chatId = voice.state?.chatId else { return }
+        let router = self.router
+        dismiss(animated: true) { router?.openSession(chatId) }
+    }
+
+    private func retryCall() {
+        if voice.endReason == .microphoneDenied, let url = URL(string: UIApplication.openSettingsURLString) {
+            UIApplication.shared.open(url)
+            return
+        }
+        if !voice.start() { voice.dismissEndReason() }
+    }
+
+    /// The tail of the utterance, its newest words fading in and the previous
+    /// turn fading out; repaints every display frame until settled.
+    private func paintCaption() {
+        let frame = captionFader.frame(item: captionSource.item, text: captionSource.text, reducedMotion: UIAccessibility.isReduceMotionEnabled)
+        let color = (captionSource.user ? Palette.tertiary : Palette.secondary).resolvedColor(with: traitCollection)
+        let text = NSMutableAttributedString(string: frame.text, attributes: [.font: caption.font as Any, .foregroundColor: color])
+        for span in frame.spans where span.alpha < 1 {
+            let range = NSRange(location: Int(span.start), length: Int(span.end) - Int(span.start))
+            guard NSMaxRange(range) <= text.length else { continue }
+            text.addAttribute(.foregroundColor, value: color.withAlphaComponent(color.cgColor.alpha * CGFloat(span.alpha)), range: range)
+        }
+        caption.attributedText = text
+        previousCaption.text = frame.previous
+        previousCaption.alpha = CGFloat(frame.previousAlpha)
+        previousCaption.isHidden = frame.previous == nil
+        if frame.animating, captionLink == nil {
+            let link = CADisplayLink(target: CaptionLinkProxy(self), selector: #selector(CaptionLinkProxy.tick))
+            link.add(to: .main, forMode: .common)
+            captionLink = link
+        } else if !frame.animating {
+            stopCaptionLink()
+        }
+    }
+
+    fileprivate func captionTick() { paintCaption() }
+
+    private func stopCaptionLink() {
+        captionLink?.invalidate()
+        captionLink = nil
+    }
+
+    deinit { captionLink?.invalidate() }
+
+    private static func callButton(symbol: String, tint: UIColor, background: UIColor, width: CGFloat = 60, action: @escaping () -> Void) -> UIButton {
+        var config = UIButton.Configuration.filled()
+        config.image = UIImage(systemName: symbol, withConfiguration: UIImage.SymbolConfiguration(pointSize: 20, weight: .semibold))
+        config.baseForegroundColor = tint
+        config.baseBackgroundColor = background
+        config.cornerStyle = .capsule
+        let button = UIButton(configuration: config, primaryAction: UIAction { _ in action() })
+        button.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            button.widthAnchor.constraint(equalToConstant: width),
+            button.heightAnchor.constraint(equalToConstant: 60),
+        ])
+        return button
+    }
+
+    private static func pillButton(title: String, tint: UIColor, background: UIColor, action: @escaping () -> Void) -> UIButton {
+        var config = UIButton.Configuration.filled()
+        config.title = title
+        config.baseForegroundColor = tint
+        config.baseBackgroundColor = background
+        config.cornerStyle = .capsule
+        config.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 22, bottom: 0, trailing: 22)
+        config.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { attributes in
+            var attributes = attributes
+            attributes.font = Fonts.ui(.sansSemibold, 16)
+            return attributes
+        }
+        let button = UIButton(configuration: config, primaryAction: UIAction { _ in action() })
+        button.translatesAutoresizingMaskIntoConstraints = false
+        button.heightAnchor.constraint(equalToConstant: 52).isActive = true
+        return button
+    }
+
+    /// The system route picker (speaker, AirPods, car) in a call-button well.
+    private static func well(_ picker: AVRoutePickerView) -> UIView {
+        let well = UIView()
+        well.backgroundColor = Palette.controlFill
+        well.layer.cornerRadius = 30
+        well.isAccessibilityElement = false
+        picker.translatesAutoresizingMaskIntoConstraints = false
+        well.addSubview(picker)
+        well.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            well.widthAnchor.constraint(equalToConstant: 60),
+            well.heightAnchor.constraint(equalToConstant: 60),
+            picker.centerXAnchor.constraint(equalTo: well.centerXAnchor),
+            picker.centerYAnchor.constraint(equalTo: well.centerYAnchor),
+            picker.widthAnchor.constraint(equalToConstant: 44),
+            picker.heightAnchor.constraint(equalToConstant: 44),
+        ])
+        return well
+    }
+}
+
+// MARK: - Entry points
+
+extension UIViewController {
+    /// The voice control in a bar: open the live call, start one on the
+    /// default host, or let the user pick a host.
+    func openVoice(app: AppModel, source: UIView?) {
+        let voice = app.voice
+        if voice.live || voice.start() {
+            presentVoiceStage(app: app, source: source)
+        } else {
+            presentVoiceHostPicker(app: app, source: source)
+        }
+    }
+
+    func presentVoiceStage(app: AppModel, source: UIView?) {
+        let host = presentedViewController ?? self
+        guard !(host is VoiceStageViewController) else { return }
+        let stage = VoiceStageViewController(app: app)
+        if let source, source.window != nil, !UIAccessibility.isReduceMotionEnabled {
+            // The orb blooms out of the bar, like the desktop footer orb.
+            stage.preferredTransition = .zoom { [weak source] _ in source }
+        }
+        host.present(stage, animated: true)
+    }
+
+    func presentVoiceHostPicker(app: AppModel, source: UIView?) {
+        let hosts = app.voice.hosts
+        let message = hosts.isEmpty
+            ? "No online device can host Codex voice. Start Zeron with remote voice enabled on your Mac or server."
+            : "Audio stays on this iPhone. Codex and its tools run on the device you pick."
+        let sheet = UIAlertController(title: "Talk to Codex on…", message: message, preferredStyle: .actionSheet)
+        for device in hosts {
+            sheet.addAction(UIAlertAction(title: device.name, style: .default) { [weak self] _ in
+                guard let self, app.voice.start(host: device) else { return }
+                self.presentVoiceStage(app: app, source: source)
+            })
+        }
+        sheet.addAction(UIAlertAction(title: "Voice Settings", style: .default) { [weak self] _ in
+            self?.presentVoiceSettings(app: app)
+        })
+        sheet.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+        sheet.popoverPresentationController?.sourceView = source ?? view
+        (presentedViewController ?? self).present(sheet, animated: true)
+    }
+
+    func presentVoiceSettings(app: AppModel) {
+        let settings = VoiceViewController(app: app)
+        let nav = MainTabController.nav(settings)
+        settings.navigationItem.rightBarButtonItem = UIBarButtonItem(systemItem: .done, primaryAction: UIAction { [weak nav] _ in
+            nav?.dismiss(animated: true)
+        })
+        (presentedViewController ?? self).present(nav, animated: true)
+    }
+
+    /// Long-press menu of a voice control: host and style for the next call.
+    func voiceMenu(app: AppModel) -> UIMenu {
+        UIMenu(children: [UIDeferredMenuElement.uncached { [weak self] completion in
+            let voice = app.voice
+            let hosts = voice.hosts.map { device in
+                UIAction(title: device.name, image: UIImage(systemName: "desktopcomputer"), attributes: voice.live ? .disabled : [], state: device.id == voice.selectedHost ? .on : .off) { _ in
+                    voice.selectedHost = device.id
+                }
+            }
+            let styles = ([nil] + voice.styles.map(Optional.some)).map { style in
+                UIAction(title: style?.capitalized ?? "Codex default", state: style == voice.selectedStyle ? .on : .off) { _ in
+                    voice.selectedStyle = style
+                }
+            }
+            var items: [UIMenuElement] = []
+            if !hosts.isEmpty { items.append(UIMenu(title: "Codex runs on", options: .displayInline, children: hosts)) }
+            items.append(UIMenu(title: "Voice", subtitle: voice.selectedStyle?.capitalized ?? "Codex default", image: UIImage(systemName: "person.wave.2"), children: styles))
+            items.append(UIAction(title: "Voice Settings", image: UIImage(systemName: "gearshape")) { _ in
+                self?.presentVoiceSettings(app: app)
+            })
+            completion(items)
+        }])
+    }
+}
+
+/// CADisplayLink retains its target; the proxy keeps the stage releasable.
+private final class CaptionLinkProxy: NSObject {
+    weak var stage: VoiceStageViewController?
+    init(_ stage: VoiceStageViewController) { self.stage = stage }
+    @objc func tick() { MainActor.assumeIsolated { stage?.captionTick() } }
+}
diff --git a/apps/ios/Zeron/Voice/VoiceViewController.swift b/apps/ios/Zeron/Voice/VoiceViewController.swift
new file mode 100644
index 0000000000..d4419b86df
--- /dev/null
+++ b/apps/ios/Zeron/Voice/VoiceViewController.swift
@@ -0,0 +1,251 @@
+import UIKit
+
+/// Voice settings, in the Settings list style: which registered device runs
+/// Codex for a call and which voice it speaks with. Calls start from the bar.
+final class VoiceViewController: UIViewController, UICollectionViewDelegate {
+    private let app: AppModel
+    private var collectionView: UICollectionView!
+    private var dataSource: UICollectionViewDiffableDataSource<Section, Row>!
+    private var voiceToken: AnyObject?
+    private var appToken: AnyObject?
+    private var signature = ""
+
+    enum Section: Int, Hashable { case hero, hosts, voice, call }
+
+    struct Row: Hashable {
+        let id: String
+        let title: String
+        var subtitle: String?
+        var symbol: String?
+        var selected = false
+        var enabled = true
+        var status: UIColor?
+    }
+
+    init(app: AppModel) {
+        self.app = app
+        super.init(nibName: nil, bundle: nil)
+        title = "Voice"
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = Palette.background
+        navigationItem.largeTitleDisplayMode = .never
+        var config = UICollectionLayoutListConfiguration(appearance: .insetGrouped)
+        config.backgroundColor = .clear
+        config.headerMode = .supplementary
+        config.footerMode = .supplementary
+        let layout = UICollectionViewCompositionalLayout { index, environment in
+            var section = config
+            if Section(rawValue: index) == .hero {
+                section.headerMode = .none
+                section.footerMode = .none
+            }
+            return .list(using: section, layoutEnvironment: environment)
+        }
+        collectionView = UICollectionView(frame: view.bounds, collectionViewLayout: layout)
+        collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        collectionView.backgroundColor = .clear
+        collectionView.delegate = self
+        view.addSubview(collectionView)
+
+        let hero = UICollectionView.CellRegistration<VoiceHeroCell, Row> { cell, _, _ in
+            cell.backgroundConfiguration = .clear()
+        }
+        let cell = UICollectionView.CellRegistration<UICollectionViewListCell, Row> { [weak self] cell, _, row in
+            var c = row.id == "style" ? UIListContentConfiguration.valueCell() : UIListContentConfiguration.subtitleCell()
+            c.text = row.title
+            c.textProperties.font = Fonts.ui(.sansMedium, 16)
+            c.textProperties.color = row.enabled ? Palette.text : Palette.tertiary
+            c.secondaryText = row.subtitle
+            c.secondaryTextProperties.font = Fonts.ui(.sans, 13)
+            c.secondaryTextProperties.color = Palette.secondary
+            if let symbol = row.symbol {
+                c.image = UIImage(systemName: symbol)
+                c.imageProperties.tintColor = row.enabled ? Palette.secondary : Palette.tertiary
+            }
+            cell.contentConfiguration = c
+            var bg = UIBackgroundConfiguration.listGroupedCell()
+            bg.backgroundColor = Palette.elevated
+            cell.backgroundConfiguration = bg
+            var accessories: [UICellAccessory] = []
+            if let status = row.status {
+                let dot = UIView(frame: CGRect(x: 0, y: 0, width: 8, height: 8))
+                dot.backgroundColor = status
+                dot.layer.cornerRadius = 4
+                accessories.append(.customView(configuration: .init(customView: dot, placement: .trailing())))
+            }
+            if row.selected { accessories.append(.checkmark(options: .init(tintColor: Palette.accent))) }
+            if row.id == "style", let menu = self?.styleMenu() {
+                accessories.append(.popUpMenu(menu, options: .init(tintColor: Palette.secondary)))
+            }
+            cell.accessories = accessories
+            cell.accessibilityIdentifier = "voice-\(row.id)"
+            cell.accessibilityTraits = row.selected ? [.button, .selected] : row.enabled ? .button : .notEnabled
+        }
+        let header = UICollectionView.SupplementaryRegistration<UICollectionViewListCell>(elementKind: UICollectionView.elementKindSectionHeader) { view, _, path in
+            var c = UIListContentConfiguration.groupedHeader()
+            c.text = Self.header(Section(rawValue: path.section))
+            view.contentConfiguration = c
+        }
+        let footer = UICollectionView.SupplementaryRegistration<UICollectionViewListCell>(elementKind: UICollectionView.elementKindSectionFooter) { [weak self] view, _, path in
+            var c = UIListContentConfiguration.groupedFooter()
+            c.text = self?.footer(Section(rawValue: path.section))
+            c.textProperties.font = Fonts.ui(.sans, 13)
+            c.textProperties.color = Palette.secondary
+            view.contentConfiguration = c
+        }
+        dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) { cv, path, row in
+            if Section(rawValue: path.section) == .hero {
+                return cv.dequeueConfiguredReusableCell(using: hero, for: path, item: row)
+            }
+            return cv.dequeueConfiguredReusableCell(using: cell, for: path, item: row)
+        }
+        dataSource.supplementaryViewProvider = { cv, kind, path in
+            kind == UICollectionView.elementKindSectionHeader
+                ? cv.dequeueConfiguredReusableSupplementary(using: header, for: path)
+                : cv.dequeueConfiguredReusableSupplementary(using: footer, for: path)
+        }
+        voiceToken = app.voice.observe { [weak self] in self?.reload() }
+        appToken = app.observe { [weak self] in self?.reload() }
+        reload()
+    }
+
+    private static func header(_ section: Section?) -> String? {
+        switch section {
+        case .hosts: "Codex runs on"
+        case .voice: "Voice"
+        case .call: "During a call"
+        default: nil
+        }
+    }
+
+    private func footer(_ section: Section?) -> String? {
+        switch section {
+        case .hosts: app.voice.live
+            ? "End the call to change devices."
+            : "Audio stays on this iPhone. Codex, its sign-in and its tools run on the device you choose."
+        case .voice: "Applies to your next call."
+        default: nil
+        }
+    }
+
+    /// Phones can't host Codex; only machines that can are listed.
+    private var devices: [DeviceView] { (app.client?.devices() ?? []).filter(\.isExecutionHost) }
+
+    private func reload() {
+        let voice = app.voice
+        let devices = self.devices
+        // Level frames during a call must not rebuild the list.
+        let signature = "\(voice.live)|\(voice.selectedHost ?? "")|\(voice.selectedStyle ?? "")|\(voice.styles)|"
+            + devices.map { "\($0.id):\($0.online):\($0.capabilities)" }.joined()
+        guard signature != self.signature else { return }
+        self.signature = signature
+
+        var s = NSDiffableDataSourceSnapshot<Section, Row>()
+        s.appendSections([.hero, .hosts, .voice, .call])
+        s.appendItems([Row(id: "hero", title: "")], toSection: .hero)
+        let chosen = voice.startHost?.id
+        if devices.isEmpty {
+            s.appendItems([Row(id: "no-hosts", title: "No Mac or server yet", subtitle: "Open Zeron on your Mac or server with remote voice enabled.", symbol: "desktopcomputer", enabled: false)], toSection: .hosts)
+        } else {
+            s.appendItems(devices.map { device in
+                let compatible = RemoteVoiceController.compatible(device)
+                let ready = device.online && compatible
+                return Row(
+                    id: "host-\(device.id)",
+                    title: device.name,
+                    subtitle: !device.online ? "Offline" : !compatible ? "Update Zeron and enable remote voice" : "Ready",
+                    symbol: Self.symbol(for: device.platform),
+                    selected: device.id == chosen,
+                    enabled: ready && !voice.live,
+                    status: ready ? Palette.success : Palette.tertiary
+                )
+            }, toSection: .hosts)
+        }
+        s.appendItems([Row(id: "style", title: "Voice", symbol: "person.wave.2")], toSection: .voice)
+        s.appendItems([
+            Row(id: "tip-ear", title: "Hold it to your ear", subtitle: "The screen turns off and Codex plays through the earpiece.", symbol: "ear", enabled: true),
+            Row(id: "tip-lock", title: "Lock your iPhone", subtitle: "The call keeps going. An incoming call ends it.", symbol: "lock", enabled: true),
+            Row(id: "tip-bar", title: "Start from the bottom bar", subtitle: "Tap the waveform; hold it to switch device or voice.", symbol: "waveform", enabled: true),
+        ], toSection: .call)
+        dataSource.apply(s, animatingDifferences: view.window != nil)
+    }
+
+    private static func symbol(for platform: String) -> String {
+        switch platform.lowercased() {
+        case let p where p.contains("mac") || p.contains("darwin"): "laptopcomputer"
+        case let p where p.contains("win"): "pc"
+        default: "server.rack"
+        }
+    }
+
+    func collectionView(_ collectionView: UICollectionView, shouldHighlightItemAt path: IndexPath) -> Bool {
+        guard let row = dataSource.itemIdentifier(for: path) else { return false }
+        return (row.id.hasPrefix("host-") && row.enabled) || row.id == "style"
+    }
+
+    func collectionView(_ collectionView: UICollectionView, didSelectItemAt path: IndexPath) {
+        collectionView.deselectItem(at: path, animated: true)
+        guard let row = dataSource.itemIdentifier(for: path) else { return }
+        let voice = app.voice
+        guard row.id.hasPrefix("host-"), row.enabled else { return }
+        voice.selectedHost = String(row.id.dropFirst("host-".count))
+        UISelectionFeedbackGenerator().selectionChanged()
+    }
+
+    /// Every voice the host offers, the current one checked.
+    private func styleMenu() -> UIMenu {
+        let voice = app.voice
+        let styles: [String?] = [nil] + voice.styles.map(Optional.some)
+        return UIMenu(options: .singleSelection, children: styles.map { style in
+            UIAction(title: style?.capitalized ?? "Codex default", state: style == voice.selectedStyle ? .on : .off) { _ in
+                voice.selectedStyle = style
+                UISelectionFeedbackGenerator().selectionChanged()
+            }
+        })
+    }
+}
+
+/// The settings hero: the desktop orb at rest over a one-line explanation.
+private final class VoiceHeroCell: UICollectionViewCell {
+    private let orb = OrbView(preset: .large, orb: .idle)
+    private let title = UILabel()
+    private let detail = UILabel()
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        title.text = "Talk with Codex"
+        title.font = Fonts.ui(.sansSemibold, 20)
+        title.textColor = Palette.text
+        title.textAlignment = .center
+        detail.text = "A voice orchestrator that starts sessions, checks on them and reports back."
+        detail.font = Fonts.ui(.sans, 14)
+        detail.textColor = Palette.secondary
+        detail.textAlignment = .center
+        detail.numberOfLines = 0
+        let stack = UIStackView(arrangedSubviews: [orb, title, detail])
+        stack.axis = .vertical
+        stack.alignment = .center
+        stack.spacing = 6
+        stack.setCustomSpacing(10, after: orb)
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        contentView.addSubview(stack)
+        NSLayoutConstraint.activate([
+            orb.widthAnchor.constraint(equalToConstant: 112),
+            orb.heightAnchor.constraint(equalToConstant: 112),
+            stack.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 4),
+            stack.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -8),
+            stack.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 24),
+            stack.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -24),
+            detail.widthAnchor.constraint(lessThanOrEqualToConstant: 320),
+        ])
+        isAccessibilityElement = true
+        accessibilityLabel = "Talk with Codex. " + (detail.text ?? "")
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+}
diff --git a/apps/ios/Zeron/Voice/WebRTC-LICENSE.txt b/apps/ios/Zeron/Voice/WebRTC-LICENSE.txt
new file mode 100644
index 0000000000..4c41b7b251
--- /dev/null
+++ b/apps/ios/Zeron/Voice/WebRTC-LICENSE.txt
@@ -0,0 +1,29 @@
+Copyright (c) 2011, The WebRTC project authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Neither the name of Google nor the names of its contributors may
+    be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/Contents.json
new file mode 100644
index 0000000000..d8b757af05
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/Contents.json
@@ -0,0 +1,3 @@
+{
+  "info" : { "author" : "xcode", "version" : 1 }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/Contents.json
new file mode 100644
index 0000000000..b85128079a
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-awaiting-avatar.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/orb-awaiting-avatar.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/orb-awaiting-avatar.svg
new file mode 100644
index 0000000000..f8e2f6c67c
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-avatar.imageset/orb-awaiting-avatar.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><circle cx="36.56" cy="29.13" r="0.30" fill="#000" fill-opacity="0.224"/><circle cx="25.36" cy="36.64" r="0.30" fill="#000" fill-opacity="0.229"/><circle cx="35.75" cy="39.83" r="0.30" fill="#000" fill-opacity="0.231"/><circle cx="23.53" cy="27.68" r="0.30" fill="#000" fill-opacity="0.233"/><circle cx="41.81" cy="36.40" r="0.30" fill="#000" fill-opacity="0.237"/><circle cx="39.18" cy="23.12" r="0.30" fill="#000" fill-opacity="0.239"/><circle cx="29.03" cy="44.98" r="0.30" fill="#000" fill-opacity="0.246"/><circle cx="19.25" cy="37.67" r="0.30" fill="#000" fill-opacity="0.249"/><circle cx="44.85" cy="37.69" r="0.30" fill="#000" fill-opacity="0.249"/><circle cx="17.50" cy="28.74" r="0.31" fill="#000" fill-opacity="0.253"/><circle cx="23.53" cy="19.15" r="0.32" fill="#000" fill-opacity="0.256"/><circle cx="36.56" cy="17.25" r="0.32" fill="#000" fill-opacity="0.256"/><circle cx="32.75" cy="48.57" r="0.33" fill="#000" fill-opacity="0.263"/><circle cx="39.34" cy="46.99" r="0.33" fill="#000" fill-opacity="0.263"/><circle cx="22.54" cy="45.91" r="0.33" fill="#000" fill-opacity="0.264"/><circle cx="48.91" cy="29.39" r="0.33" fill="#000" fill-opacity="0.266"/><circle cx="30.23" cy="14.95" r="0.34" fill="#000" fill-opacity="0.266"/><circle cx="17.50" cy="20.21" r="0.35" fill="#000" fill-opacity="0.277"/><circle cx="14.27" cy="39.28" r="0.36" fill="#000" fill-opacity="0.280"/><circle cx="49.81" cy="39.32" r="0.36" fill="#000" fill-opacity="0.281"/><circle cx="12.46" cy="30.32" r="0.37" fill="#000" fill-opacity="0.284"/><circle cx="48.91" cy="20.86" r="0.38" fill="#000" fill-opacity="0.290"/><circle cx="25.36" cy="12.08" r="0.39" fill="#000" fill-opacity="0.297"/><circle cx="17.68" cy="47.69" r="0.40" fill="#000" fill-opacity="0.299"/><circle cx="53.39" cy="31.17" r="0.40" fill="#000" fill-opacity="0.301"/><circle cx="41.81" cy="12.93" r="0.40" fill="#000" fill-opacity="0.301"/><circle cx="46.88" cy="48.02" r="0.41" fill="#000" fill-opacity="0.306"/><circle cx="12.46" cy="21.79" r="0.41" fill="#000" fill-opacity="0.308"/><circle cx="25.21" cy="53.02" r="0.41" fill="#000" fill-opacity="0.309"/><circle cx="38.34" cy="53.60" r="0.42" fill="#000" fill-opacity="0.314"/><circle cx="35.75" cy="9.80" r="0.42" fill="#000" fill-opacity="0.314"/><circle cx="19.25" cy="13.10" r="0.43" fill="#000" fill-opacity="0.318"/><circle cx="44.56" cy="51.02" r="0.43" fill="#000" fill-opacity="0.318"/><circle cx="44.85" cy="13.13" r="0.43" fill="#000" fill-opacity="0.318"/><circle cx="10.87" cy="41.34" r="0.44" fill="#000" fill-opacity="0.322"/><circle cx="53.18" cy="41.38" r="0.44" fill="#000" fill-opacity="0.323"/><circle cx="8.75" cy="32.30" r="0.44" fill="#000" fill-opacity="0.324"/><circle cx="53.39" cy="22.64" r="0.44" fill="#000" fill-opacity="0.326"/><circle cx="56.42" cy="33.29" r="0.47" fill="#000" fill-opacity="0.345"/><circle cx="15.29" cy="50.00" r="0.48" fill="#000" fill-opacity="0.347"/><circle cx="32.00" cy="56.56" r="0.48" fill="#000" fill-opacity="0.347"/><circle cx="8.75" cy="23.77" r="0.48" fill="#000" fill-opacity="0.349"/><circle cx="14.27" cy="14.72" r="0.49" fill="#000" fill-opacity="0.351"/><circle cx="49.81" cy="14.75" r="0.49" fill="#000" fill-opacity="0.352"/><circle cx="29.03" cy="7.34" r="0.49" fill="#000" fill-opacity="0.353"/><circle cx="48.82" cy="50.39" r="0.49" fill="#000" fill-opacity="0.355"/><circle cx="23.05" cy="55.31" r="0.49" fill="#000" fill-opacity="0.356"/><circle cx="56.42" cy="24.76" r="0.52" fill="#000" fill-opacity="0.370"/><circle cx="9.34" cy="43.66" r="0.52" fill="#000" fill-opacity="0.371"/><circle cx="6.62" cy="34.55" r="0.52" fill="#000" fill-opacity="0.372"/><circle cx="54.67" cy="43.71" r="0.52" fill="#000" fill-opacity="0.372"/><circle cx="22.54" cy="8.27" r="0.52" fill="#000" fill-opacity="0.373"/><circle cx="39.34" cy="7.39" r="0.53" fill="#000" fill-opacity="0.378"/><circle cx="39.00" cy="56.80" r="0.54" fill="#000" fill-opacity="0.381"/><circle cx="45.21" cy="54.22" r="0.54" fill="#000" fill-opacity="0.385"/><circle cx="32.75" cy="6.14" r="0.54" fill="#000" fill-opacity="0.386"/><circle cx="57.77" cy="35.61" r="0.56" fill="#000" fill-opacity="0.395"/><circle cx="10.87" cy="16.78" r="0.56" fill="#000" fill-opacity="0.396"/><circle cx="53.18" cy="16.82" r="0.56" fill="#000" fill-opacity="0.397"/><circle cx="6.62" cy="26.02" r="0.56" fill="#000" fill-opacity="0.398"/><circle cx="15.80" cy="52.46" r="0.57" fill="#000" fill-opacity="0.400"/><circle cx="26.13" cy="57.47" r="0.57" fill="#000" fill-opacity="0.403"/><circle cx="47.86" cy="52.83" r="0.58" fill="#000" fill-opacity="0.408"/><circle cx="17.68" cy="10.05" r="0.59" fill="#000" fill-opacity="0.412"/><circle cx="46.88" cy="10.39" r="0.60" fill="#000" fill-opacity="0.419"/><circle cx="32.65" cy="58.23" r="0.60" fill="#000" fill-opacity="0.420"/><circle cx="57.77" cy="27.08" r="0.60" fill="#000" fill-opacity="0.421"/><circle cx="9.83" cy="46.04" r="0.60" fill="#000" fill-opacity="0.423"/><circle cx="6.23" cy="36.92" r="0.60" fill="#000" fill-opacity="0.424"/><circle cx="54.14" cy="46.08" r="0.60" fill="#000" fill-opacity="0.424"/><circle cx="44.56" cy="9.13" r="0.64" fill="#000" fill-opacity="0.446"/><circle cx="57.38" cy="37.98" r="0.64" fill="#000" fill-opacity="0.448"/><circle cx="9.34" cy="19.10" r="0.64" fill="#000" fill-opacity="0.448"/><circle cx="54.67" cy="19.14" r="0.64" fill="#000" fill-opacity="0.449"/><circle cx="19.10" cy="54.64" r="0.64" fill="#000" fill-opacity="0.449"/><circle cx="25.21" cy="6.85" r="0.65" fill="#000" fill-opacity="0.449"/><circle cx="6.23" cy="28.39" r="0.65" fill="#000" fill-opacity="0.451"/><circle cx="38.34" cy="6.87" r="0.66" fill="#000" fill-opacity="0.457"/><circle cx="34.64" cy="57.77" r="0.66" fill="#000" fill-opacity="0.458"/><circle cx="41.22" cy="56.19" r="0.66" fill="#000" fill-opacity="0.459"/><circle cx="31.67" cy="6.21" r="0.67" fill="#000" fill-opacity="0.464"/><circle cx="15.29" cy="12.37" r="0.67" fill="#000" fill-opacity="0.464"/><circle cx="48.82" cy="12.76" r="0.68" fill="#000" fill-opacity="0.473"/><circle cx="12.29" cy="48.26" r="0.68" fill="#000" fill-opacity="0.474"/><circle cx="51.65" cy="48.30" r="0.68" fill="#000" fill-opacity="0.475"/><circle cx="57.38" cy="29.45" r="0.69" fill="#000" fill-opacity="0.475"/><circle cx="7.58" cy="39.24" r="0.69" fill="#000" fill-opacity="0.477"/><circle cx="24.53" cy="56.11" r="0.79" fill="#000" fill-opacity="0.611"/><circle cx="31.34" cy="56.74" r="0.81" fill="#000" fill-opacity="0.627"/><circle cx="55.25" cy="40.23" r="0.72" fill="#000" fill-opacity="0.500"/><circle cx="32.00" cy="7.44" r="0.73" fill="#000" fill-opacity="0.503"/><circle cx="23.05" cy="9.14" r="0.73" fill="#000" fill-opacity="0.503"/><circle cx="9.83" cy="21.47" r="0.73" fill="#000" fill-opacity="0.503"/><circle cx="54.14" cy="21.52" r="0.73" fill="#000" fill-opacity="0.504"/><circle cx="7.58" cy="30.71" r="0.73" fill="#000" fill-opacity="0.505"/><circle cx="16.43" cy="50.04" r="0.84" fill="#000" fill-opacity="0.649"/><circle cx="47.34" cy="50.23" r="0.84" fill="#000" fill-opacity="0.650"/><circle cx="45.21" cy="12.32" r="0.75" fill="#000" fill-opacity="0.521"/><circle cx="15.80" cy="14.83" r="0.76" fill="#000" fill-opacity="0.523"/><circle cx="10.61" cy="41.36" r="0.76" fill="#000" fill-opacity="0.527"/><circle cx="55.25" cy="31.70" r="0.77" fill="#000" fill-opacity="0.529"/><circle cx="47.86" cy="15.20" r="0.77" fill="#000" fill-opacity="0.531"/><circle cx="39.00" cy="10.06" r="0.77" fill="#000" fill-opacity="0.533"/><circle cx="38.56" cy="53.96" r="0.86" fill="#000" fill-opacity="0.668"/><circle cx="32.33" cy="9.41" r="0.78" fill="#000" fill-opacity="0.540"/><circle cx="44.63" cy="50.56" r="0.87" fill="#000" fill-opacity="0.676"/><circle cx="51.51" cy="42.31" r="0.88" fill="#000" fill-opacity="0.682"/><circle cx="22.01" cy="51.42" r="0.88" fill="#000" fill-opacity="0.686"/><circle cx="26.13" cy="11.30" r="0.80" fill="#000" fill-opacity="0.555"/><circle cx="10.61" cy="32.83" r="0.81" fill="#000" fill-opacity="0.557"/><circle cx="12.29" cy="23.69" r="0.81" fill="#000" fill-opacity="0.557"/><circle cx="51.65" cy="23.73" r="0.81" fill="#000" fill-opacity="0.558"/><circle cx="28.48" cy="52.16" r="0.91" fill="#000" fill-opacity="0.706"/><circle cx="15.06" cy="43.04" r="0.91" fill="#000" fill-opacity="0.709"/><circle cx="32.65" cy="12.07" r="0.83" fill="#000" fill-opacity="0.574"/><circle cx="19.10" cy="17.01" r="0.83" fill="#000" fill-opacity="0.576"/><circle cx="51.56" cy="33.77" r="0.92" fill="#000" fill-opacity="0.716"/><circle cx="41.34" cy="16.63" r="0.95" fill="#000" fill-opacity="0.734"/><circle cx="15.11" cy="34.51" r="0.96" fill="#000" fill-opacity="0.743"/><circle cx="34.76" cy="15.35" r="0.96" fill="#000" fill-opacity="0.744"/><circle cx="20.70" cy="44.38" r="0.96" fill="#000" fill-opacity="0.746"/><circle cx="16.57" cy="25.47" r="0.96" fill="#000" fill-opacity="0.746"/><circle cx="47.48" cy="25.66" r="0.96" fill="#000" fill-opacity="0.746"/><circle cx="40.07" cy="46.46" r="0.96" fill="#000" fill-opacity="0.747"/><circle cx="24.75" cy="18.47" r="0.98" fill="#000" fill-opacity="0.757"/><circle cx="27.10" cy="45.16" r="0.99" fill="#000" fill-opacity="0.767"/><circle cx="44.77" cy="27.09" r="0.99" fill="#000" fill-opacity="0.769"/><circle cx="42.73" cy="40.47" r="0.99" fill="#000" fill-opacity="0.769"/><circle cx="33.83" cy="45.33" r="0.99" fill="#000" fill-opacity="0.771"/><circle cx="31.56" cy="19.10" r="1.00" fill="#000" fill-opacity="0.774"/><circle cx="20.75" cy="35.84" r="1.00" fill="#000" fill-opacity="0.780"/><circle cx="22.15" cy="26.85" r="1.01" fill="#000" fill-opacity="0.784"/><circle cx="38.73" cy="23.93" r="1.01" fill="#000" fill-opacity="0.787"/><circle cx="40.14" cy="34.58" r="1.02" fill="#000" fill-opacity="0.796"/><circle cx="27.15" cy="36.62" r="1.03" fill="#000" fill-opacity="0.802"/><circle cx="28.62" cy="27.59" r="1.03" fill="#000" fill-opacity="0.805"/><circle cx="33.88" cy="36.80" r="1.03" fill="#000" fill-opacity="0.806"/><circle cx="33.82" cy="32.25" r="1.04" fill="#000" fill-opacity="0.810"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/Contents.json
new file mode 100644
index 0000000000..63cc1cf1f3
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-awaiting-inline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/orb-awaiting-inline.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/orb-awaiting-inline.svg
new file mode 100644
index 0000000000..45b703d6e7
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-awaiting-inline.imageset/orb-awaiting-inline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><circle cx="13.67" cy="11.70" r="0.30" fill="#000" fill-opacity="0.245"/><circle cx="5.40" cy="7.61" r="0.30" fill="#000" fill-opacity="0.263"/><circle cx="13.79" cy="13.89" r="0.30" fill="#000" fill-opacity="0.268"/><circle cx="5.62" cy="14.09" r="0.33" fill="#000" fill-opacity="0.281"/><circle cx="16.79" cy="8.38" r="0.38" fill="#000" fill-opacity="0.312"/><circle cx="9.58" cy="2.54" r="0.41" fill="#000" fill-opacity="0.335"/><circle cx="2.62" cy="8.74" r="0.41" fill="#000" fill-opacity="0.335"/><circle cx="10.00" cy="17.68" r="0.43" fill="#000" fill-opacity="0.347"/><circle cx="14.09" cy="16.54" r="0.44" fill="#000" fill-opacity="0.350"/><circle cx="15.78" cy="15.28" r="0.45" fill="#000" fill-opacity="0.359"/><circle cx="13.79" cy="3.03" r="0.46" fill="#000" fill-opacity="0.368"/><circle cx="4.22" cy="15.57" r="0.48" fill="#000" fill-opacity="0.379"/><circle cx="5.62" cy="3.24" r="0.48" fill="#000" fill-opacity="0.382"/><circle cx="18.18" cy="9.79" r="0.52" fill="#000" fill-opacity="0.408"/><circle cx="1.82" cy="10.21" r="0.56" fill="#000" fill-opacity="0.437"/><circle cx="15.78" cy="4.43" r="0.61" fill="#000" fill-opacity="0.468"/><circle cx="6.21" cy="16.97" r="0.62" fill="#000" fill-opacity="0.479"/><circle cx="14.09" cy="3.25" r="0.63" fill="#000" fill-opacity="0.484"/><circle cx="4.22" cy="4.72" r="0.64" fill="#000" fill-opacity="0.490"/><circle cx="10.00" cy="2.32" r="0.65" fill="#000" fill-opacity="0.503"/><circle cx="10.00" cy="2.32" r="0.65" fill="#000" fill-opacity="0.503"/><circle cx="17.38" cy="11.29" r="0.75" fill="#000" fill-opacity="0.646"/><circle cx="10.39" cy="17.46" r="0.75" fill="#000" fill-opacity="0.648"/><circle cx="3.21" cy="11.58" r="0.79" fill="#000" fill-opacity="0.679"/><circle cx="14.42" cy="5.93" r="0.84" fill="#000" fill-opacity="0.721"/><circle cx="6.24" cy="6.09" r="0.86" fill="#000" fill-opacity="0.740"/><circle cx="6.42" cy="12.57" r="0.89" fill="#000" fill-opacity="0.766"/><circle cx="10.45" cy="6.61" r="0.91" fill="#000" fill-opacity="0.785"/><circle cx="10.45" cy="6.61" r="0.91" fill="#000" fill-opacity="0.785"/><circle cx="10.59" cy="12.88" r="0.84" fill="#000" fill-opacity="0.645"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/Contents.json
new file mode 100644
index 0000000000..c827327941
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-connecting-avatar.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/orb-connecting-avatar.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/orb-connecting-avatar.svg
new file mode 100644
index 0000000000..0ed680178b
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-avatar.imageset/orb-connecting-avatar.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><line x1="38.07" y1="8.80" x2="25.86" y2="13.27" stroke="#000" stroke-width="0.60" stroke-opacity="0.078"/><line x1="38.07" y1="8.80" x2="34.07" y2="6.89" stroke="#000" stroke-width="0.60" stroke-opacity="0.080"/><line x1="38.07" y1="8.80" x2="44.86" y2="13.21" stroke="#000" stroke-width="0.60" stroke-opacity="0.213"/><line x1="38.07" y1="8.80" x2="46.84" y2="11.26" stroke="#000" stroke-width="0.60" stroke-opacity="0.077"/><line x1="38.07" y1="8.80" x2="32.84" y2="16.15" stroke="#000" stroke-width="0.60" stroke-opacity="0.094"/><line x1="38.07" y1="8.80" x2="51.43" y2="15.95" stroke="#000" stroke-width="0.60" stroke-opacity="0.054"/><line x1="25.86" y1="13.27" x2="32.84" y2="16.15" stroke="#000" stroke-width="0.60" stroke-opacity="0.242"/><line x1="34.07" y1="6.89" x2="18.74" y2="10.21" stroke="#000" stroke-width="0.60" stroke-opacity="0.044"/><line x1="34.07" y1="6.89" x2="46.84" y2="11.26" stroke="#000" stroke-width="0.60" stroke-opacity="0.080"/><line x1="34.07" y1="6.89" x2="25.26" y2="13.69" stroke="#000" stroke-width="0.60" stroke-opacity="0.029"/><line x1="34.07" y1="6.89" x2="36.01" y2="13.72" stroke="#000" stroke-width="0.60" stroke-opacity="0.053"/><line x1="44.86" y1="13.21" x2="46.84" y2="11.26" stroke="#000" stroke-width="0.60" stroke-opacity="0.084"/><line x1="44.86" y1="13.21" x2="32.84" y2="16.15" stroke="#000" stroke-width="0.60" stroke-opacity="0.082"/><line x1="44.86" y1="13.21" x2="55.38" y2="23.83" stroke="#000" stroke-width="0.60" stroke-opacity="0.055"/><line x1="44.86" y1="13.21" x2="51.43" y2="15.95" stroke="#000" stroke-width="0.60" stroke-opacity="0.173"/><line x1="18.74" y1="10.21" x2="25.26" y2="13.69" stroke="#000" stroke-width="0.60" stroke-opacity="0.033"/><line x1="18.74" y1="10.21" x2="11.11" y2="19.63" stroke="#000" stroke-width="0.60" stroke-opacity="0.049"/><line x1="18.74" y1="10.21" x2="9.61" y2="20.00" stroke="#000" stroke-width="0.60" stroke-opacity="0.086"/><line x1="46.84" y1="11.26" x2="51.43" y2="15.95" stroke="#000" stroke-width="0.60" stroke-opacity="0.167"/><line x1="32.84" y1="16.15" x2="36.62" y2="24.96" stroke="#000" stroke-width="0.60" stroke-opacity="0.205"/><line x1="25.26" y1="13.69" x2="36.01" y2="13.72" stroke="#000" stroke-width="0.60" stroke-opacity="0.094"/><line x1="25.26" y1="13.69" x2="22.41" y2="20.10" stroke="#000" stroke-width="0.60" stroke-opacity="0.123"/><line x1="25.26" y1="13.69" x2="31.73" y2="24.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.037"/><line x1="55.38" y1="23.83" x2="51.43" y2="15.95" stroke="#000" stroke-width="0.60" stroke-opacity="0.187"/><line x1="55.38" y1="23.83" x2="53.10" y2="30.33" stroke="#000" stroke-width="0.60" stroke-opacity="0.172"/><line x1="55.38" y1="23.83" x2="57.01" y2="36.12" stroke="#000" stroke-width="0.60" stroke-opacity="0.113"/><line x1="11.11" y1="19.63" x2="9.61" y2="20.00" stroke="#000" stroke-width="0.60" stroke-opacity="0.134"/><line x1="11.11" y1="19.63" x2="6.57" y2="29.06" stroke="#000" stroke-width="0.60" stroke-opacity="0.104"/><line x1="11.11" y1="19.63" x2="6.45" y2="32.80" stroke="#000" stroke-width="0.60" stroke-opacity="0.030"/><line x1="36.01" y1="13.72" x2="22.41" y2="20.10" stroke="#000" stroke-width="0.60" stroke-opacity="0.036"/><line x1="36.01" y1="13.72" x2="45.46" y2="26.28" stroke="#000" stroke-width="0.60" stroke-opacity="0.027"/><line x1="36.01" y1="13.72" x2="31.73" y2="24.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.051"/><line x1="36.62" y1="24.96" x2="45.15" y2="37.55" stroke="#000" stroke-width="0.60" stroke-opacity="0.076"/><line x1="9.61" y1="20.00" x2="6.57" y2="29.06" stroke="#000" stroke-width="0.60" stroke-opacity="0.146"/><line x1="9.61" y1="20.00" x2="6.45" y2="32.80" stroke="#000" stroke-width="0.60" stroke-opacity="0.089"/><line x1="17.83" y1="30.60" x2="12.97" y2="38.25" stroke="#000" stroke-width="0.60" stroke-opacity="0.193"/><line x1="22.41" y1="20.10" x2="14.36" y2="29.09" stroke="#000" stroke-width="0.60" stroke-opacity="0.071"/><line x1="22.41" y1="20.10" x2="31.73" y2="24.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.076"/><line x1="53.10" y1="30.33" x2="57.01" y2="36.12" stroke="#000" stroke-width="0.60" stroke-opacity="0.117"/><line x1="53.10" y1="30.33" x2="45.15" y2="37.55" stroke="#000" stroke-width="0.60" stroke-opacity="0.137"/><line x1="6.57" y1="29.06" x2="6.45" y2="32.80" stroke="#000" stroke-width="0.60" stroke-opacity="0.257"/><line x1="45.46" y1="26.28" x2="31.73" y2="24.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.043"/><line x1="45.46" y1="26.28" x2="53.39" y2="38.30" stroke="#000" stroke-width="0.60" stroke-opacity="0.022"/><line x1="31.55" y1="45.24" x2="45.15" y2="37.55" stroke="#000" stroke-width="0.60" stroke-opacity="0.071"/><line x1="31.55" y1="45.24" x2="29.18" y2="50.13" stroke="#000" stroke-width="0.60" stroke-opacity="0.289"/><line x1="31.55" y1="45.24" x2="33.15" y2="53.61" stroke="#000" stroke-width="0.60" stroke-opacity="0.159"/><line x1="14.36" y1="29.09" x2="25.42" y2="39.08" stroke="#000" stroke-width="0.60" stroke-opacity="0.028"/><line x1="57.01" y1="36.12" x2="53.39" y2="38.30" stroke="#000" stroke-width="0.60" stroke-opacity="0.029"/><line x1="57.01" y1="36.12" x2="52.95" y2="46.02" stroke="#000" stroke-width="0.60" stroke-opacity="0.150"/><line x1="31.73" y1="24.75" x2="25.42" y2="39.08" stroke="#000" stroke-width="0.60" stroke-opacity="0.027"/><line x1="6.45" y1="32.80" x2="12.25" y2="48.05" stroke="#000" stroke-width="0.60" stroke-opacity="0.036"/><line x1="53.39" y1="38.30" x2="41.01" y2="44.79" stroke="#000" stroke-width="0.60" stroke-opacity="0.031"/><line x1="53.39" y1="38.30" x2="47.61" y2="48.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.090"/><line x1="29.18" y1="50.13" x2="33.15" y2="53.61" stroke="#000" stroke-width="0.60" stroke-opacity="0.274"/><line x1="29.18" y1="50.13" x2="20.94" y2="53.02" stroke="#000" stroke-width="0.60" stroke-opacity="0.145"/><line x1="25.42" y1="39.08" x2="28.10" y2="50.67" stroke="#000" stroke-width="0.60" stroke-opacity="0.054"/><line x1="52.95" y1="46.02" x2="47.61" y2="48.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.024"/><line x1="52.95" y1="46.02" x2="39.98" y2="56.27" stroke="#000" stroke-width="0.60" stroke-opacity="0.032"/><line x1="12.25" y1="48.05" x2="14.33" y2="46.33" stroke="#000" stroke-width="0.60" stroke-opacity="0.141"/><line x1="12.25" y1="48.05" x2="20.94" y2="53.02" stroke="#000" stroke-width="0.60" stroke-opacity="0.050"/><line x1="12.25" y1="48.05" x2="22.84" y2="53.68" stroke="#000" stroke-width="0.60" stroke-opacity="0.070"/><line x1="41.01" y1="44.79" x2="47.61" y2="48.75" stroke="#000" stroke-width="0.60" stroke-opacity="0.086"/><line x1="41.01" y1="44.79" x2="28.10" y2="50.67" stroke="#000" stroke-width="0.60" stroke-opacity="0.046"/><line x1="41.01" y1="44.79" x2="39.47" y2="49.51" stroke="#000" stroke-width="0.60" stroke-opacity="0.148"/><line x1="33.15" y1="53.61" x2="20.94" y2="53.02" stroke="#000" stroke-width="0.60" stroke-opacity="0.122"/><line x1="33.15" y1="53.61" x2="39.98" y2="56.27" stroke="#000" stroke-width="0.60" stroke-opacity="0.090"/><line x1="14.33" y1="46.33" x2="28.10" y2="50.67" stroke="#000" stroke-width="0.60" stroke-opacity="0.040"/><line x1="14.33" y1="46.33" x2="22.84" y2="53.68" stroke="#000" stroke-width="0.60" stroke-opacity="0.102"/><line x1="47.61" y1="48.75" x2="39.98" y2="56.27" stroke="#000" stroke-width="0.60" stroke-opacity="0.025"/><line x1="47.61" y1="48.75" x2="39.47" y2="49.51" stroke="#000" stroke-width="0.60" stroke-opacity="0.113"/><line x1="28.10" y1="50.67" x2="22.84" y2="53.68" stroke="#000" stroke-width="0.60" stroke-opacity="0.124"/><line x1="28.10" y1="50.67" x2="39.47" y2="49.51" stroke="#000" stroke-width="0.60" stroke-opacity="0.086"/><line x1="28.10" y1="50.67" x2="32.81" y2="57.34" stroke="#000" stroke-width="0.60" stroke-opacity="0.038"/><line x1="39.98" y1="56.27" x2="32.81" y2="57.34" stroke="#000" stroke-width="0.60" stroke-opacity="0.169"/><line x1="22.84" y1="53.68" x2="32.81" y2="57.34" stroke="#000" stroke-width="0.60" stroke-opacity="0.094"/><line x1="39.47" y1="49.51" x2="32.81" y2="57.34" stroke="#000" stroke-width="0.60" stroke-opacity="0.020"/><circle cx="31.73" cy="24.75" r="0.55" fill="#000" fill-opacity="0.459"/><circle cx="25.42" cy="39.08" r="0.67" fill="#000" fill-opacity="0.467"/><circle cx="45.46" cy="26.28" r="0.48" fill="#000" fill-opacity="0.490"/><circle cx="22.41" cy="20.10" r="0.52" fill="#000" fill-opacity="0.495"/><circle cx="41.01" cy="44.79" r="0.64" fill="#000" fill-opacity="0.497"/><circle cx="17.54" cy="31.97" r="0.87" fill="#000" fill-opacity="0.415"/><circle cx="14.36" cy="29.09" r="0.47" fill="#000" fill-opacity="0.514"/><circle cx="36.01" cy="13.72" r="0.70" fill="#000" fill-opacity="0.522"/><circle cx="39.47" cy="49.51" r="0.54" fill="#000" fill-opacity="0.525"/><circle cx="28.10" cy="50.67" r="0.54" fill="#000" fill-opacity="0.525"/><circle cx="25.26" cy="13.69" r="0.77" fill="#000" fill-opacity="0.529"/><circle cx="53.39" cy="38.30" r="0.86" fill="#000" fill-opacity="0.564"/><circle cx="49.53" cy="45.28" r="0.97" fill="#000" fill-opacity="0.521"/><circle cx="14.33" cy="46.33" r="0.87" fill="#000" fill-opacity="0.572"/><circle cx="47.61" cy="48.75" r="0.54" fill="#000" fill-opacity="0.574"/><circle cx="22.84" cy="53.68" r="0.77" fill="#000" fill-opacity="0.586"/><circle cx="34.07" cy="6.89" r="0.80" fill="#000" fill-opacity="0.635"/><circle cx="32.81" cy="57.34" r="1.00" fill="#000" fill-opacity="0.644"/><circle cx="9.61" cy="20.00" r="1.02" fill="#000" fill-opacity="0.647"/><circle cx="12.25" cy="48.05" r="0.86" fill="#000" fill-opacity="0.651"/><circle cx="16.84" cy="12.25" r="1.10" fill="#000" fill-opacity="0.420"/><circle cx="46.84" cy="11.26" r="1.04" fill="#000" fill-opacity="0.656"/><circle cx="18.74" cy="10.21" r="0.67" fill="#000" fill-opacity="0.656"/><circle cx="6.45" cy="32.80" r="0.70" fill="#000" fill-opacity="0.663"/><circle cx="6.57" cy="29.06" r="0.95" fill="#000" fill-opacity="0.677"/><circle cx="39.98" cy="56.27" r="0.93" fill="#000" fill-opacity="0.689"/><circle cx="8.88" cy="25.92" r="1.18" fill="#000" fill-opacity="0.744"/><circle cx="57.01" cy="36.12" r="1.10" fill="#000" fill-opacity="0.707"/><circle cx="52.95" cy="46.02" r="0.79" fill="#000" fill-opacity="0.714"/><circle cx="51.43" cy="15.95" r="0.70" fill="#000" fill-opacity="0.714"/><circle cx="55.38" cy="23.83" r="0.85" fill="#000" fill-opacity="0.732"/><circle cx="11.11" cy="19.63" r="0.97" fill="#000" fill-opacity="0.746"/><circle cx="38.07" cy="8.80" r="1.17" fill="#000" fill-opacity="0.754"/><circle cx="20.94" cy="53.02" r="1.21" fill="#000" fill-opacity="0.759"/><circle cx="44.86" cy="13.21" r="1.14" fill="#000" fill-opacity="0.778"/><circle cx="33.15" cy="53.61" r="0.87" fill="#000" fill-opacity="0.795"/><circle cx="53.17" cy="30.43" r="1.32" fill="#000" fill-opacity="0.048"/><circle cx="53.10" cy="30.33" r="1.07" fill="#000" fill-opacity="0.802"/><circle cx="12.97" cy="38.25" r="0.94" fill="#000" fill-opacity="0.815"/><circle cx="25.86" cy="13.27" r="0.98" fill="#000" fill-opacity="0.819"/><circle cx="29.18" cy="50.13" r="0.83" fill="#000" fill-opacity="0.832"/><circle cx="32.84" cy="16.15" r="0.86" fill="#000" fill-opacity="0.852"/><circle cx="45.64" cy="37.10" r="1.40" fill="#000" fill-opacity="0.175"/><circle cx="45.15" cy="37.55" r="1.24" fill="#000" fill-opacity="0.862"/><circle cx="17.83" cy="30.60" r="1.38" fill="#000" fill-opacity="0.862"/><circle cx="41.72" cy="39.49" r="1.41" fill="#000" fill-opacity="0.648"/><circle cx="31.55" cy="45.24" r="1.43" fill="#000" fill-opacity="0.868"/><circle cx="36.62" cy="24.96" r="0.96" fill="#000" fill-opacity="0.887"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/Contents.json
new file mode 100644
index 0000000000..ebc309f47d
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-connecting-inline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/orb-connecting-inline.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/orb-connecting-inline.svg
new file mode 100644
index 0000000000..4f91d383c2
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-connecting-inline.imageset/orb-connecting-inline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><circle cx="9.33" cy="15.51" r="0.59" fill="#000" fill-opacity="0.513"/><circle cx="10.71" cy="4.39" r="0.49" fill="#000" fill-opacity="0.516"/><circle cx="16.71" cy="10.03" r="0.67" fill="#000" fill-opacity="0.552"/><circle cx="2.76" cy="10.38" r="0.46" fill="#000" fill-opacity="0.580"/><circle cx="14.45" cy="3.75" r="0.91" fill="#000" fill-opacity="0.739"/><circle cx="16.59" cy="10.33" r="0.94" fill="#000" fill-opacity="0.802"/><circle cx="10.28" cy="16.09" r="0.65" fill="#000" fill-opacity="0.821"/><circle cx="6.00" cy="7.25" r="0.82" fill="#000" fill-opacity="0.854"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/Contents.json
new file mode 100644
index 0000000000..f418908fe8
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-listening-avatar.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/orb-listening-avatar.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/orb-listening-avatar.svg
new file mode 100644
index 0000000000..7c83c4bf68
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-avatar.imageset/orb-listening-avatar.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><circle cx="29.76" cy="35.47" r="0.30" fill="#000" fill-opacity="0.384"/><circle cx="36.25" cy="35.59" r="0.30" fill="#000" fill-opacity="0.387"/><circle cx="35.39" cy="44.31" r="0.35" fill="#000" fill-opacity="0.435"/><circle cx="28.51" cy="44.31" r="0.35" fill="#000" fill-opacity="0.435"/><circle cx="23.50" cy="36.10" r="0.31" fill="#000" fill-opacity="0.400"/><circle cx="34.13" cy="27.47" r="0.31" fill="#000" fill-opacity="0.402"/><circle cx="28.13" cy="27.56" r="0.31" fill="#000" fill-opacity="0.404"/><circle cx="42.31" cy="36.45" r="0.32" fill="#000" fill-opacity="0.408"/><circle cx="39.97" cy="27.99" r="0.33" fill="#000" fill-opacity="0.415"/><circle cx="22.42" cy="28.25" r="0.33" fill="#000" fill-opacity="0.421"/><circle cx="41.68" cy="45.34" r="0.39" fill="#000" fill-opacity="0.461"/><circle cx="22.23" cy="45.36" r="0.39" fill="#000" fill-opacity="0.461"/><circle cx="18.07" cy="37.42" r="0.35" fill="#000" fill-opacity="0.433"/><circle cx="34.07" cy="20.59" r="0.35" fill="#000" fill-opacity="0.436"/><circle cx="28.24" cy="20.67" r="0.36" fill="#000" fill-opacity="0.438"/><circle cx="31.01" cy="52.12" r="0.47" fill="#000" fill-opacity="0.521"/><circle cx="45.22" cy="29.07" r="0.36" fill="#000" fill-opacity="0.442"/><circle cx="47.37" cy="37.95" r="0.36" fill="#000" fill-opacity="0.446"/><circle cx="39.75" cy="21.09" r="0.37" fill="#000" fill-opacity="0.448"/><circle cx="17.42" cy="29.48" r="0.37" fill="#000" fill-opacity="0.452"/><circle cx="22.70" cy="21.34" r="0.38" fill="#000" fill-opacity="0.455"/><circle cx="37.78" cy="52.86" r="0.50" fill="#000" fill-opacity="0.539"/><circle cx="46.30" cy="47.23" r="0.45" fill="#000" fill-opacity="0.508"/><circle cx="17.64" cy="47.26" r="0.45" fill="#000" fill-opacity="0.509"/><circle cx="24.82" cy="53.38" r="0.52" fill="#000" fill-opacity="0.552"/><circle cx="44.84" cy="22.14" r="0.40" fill="#000" fill-opacity="0.475"/><circle cx="14.00" cy="39.30" r="0.41" fill="#000" fill-opacity="0.480"/><circle cx="49.49" cy="30.63" r="0.41" fill="#000" fill-opacity="0.481"/><circle cx="29.92" cy="14.53" r="0.41" fill="#000" fill-opacity="0.483"/><circle cx="17.84" cy="22.54" r="0.41" fill="#000" fill-opacity="0.485"/><circle cx="35.95" cy="14.64" r="0.41" fill="#000" fill-opacity="0.486"/><circle cx="13.50" cy="31.16" r="0.42" fill="#000" fill-opacity="0.494"/><circle cx="50.92" cy="39.97" r="0.43" fill="#000" fill-opacity="0.497"/><circle cx="24.09" cy="15.12" r="0.43" fill="#000" fill-opacity="0.498"/><circle cx="41.60" cy="15.44" r="0.44" fill="#000" fill-opacity="0.506"/><circle cx="48.99" cy="23.66" r="0.45" fill="#000" fill-opacity="0.513"/><circle cx="41.17" cy="55.15" r="0.59" fill="#000" fill-opacity="0.596"/><circle cx="32.00" cy="57.18" r="0.61" fill="#000" fill-opacity="0.605"/><circle cx="14.03" cy="24.17" r="0.46" fill="#000" fill-opacity="0.526"/><circle cx="19.04" cy="16.34" r="0.46" fill="#000" fill-opacity="0.528"/><circle cx="52.46" cy="32.57" r="0.46" fill="#000" fill-opacity="0.529"/><circle cx="48.45" cy="49.65" r="0.54" fill="#000" fill-opacity="0.569"/><circle cx="15.54" cy="49.69" r="0.54" fill="#000" fill-opacity="0.570"/><circle cx="22.83" cy="55.89" r="0.62" fill="#000" fill-opacity="0.615"/><circle cx="11.70" cy="41.55" r="0.47" fill="#000" fill-opacity="0.536"/><circle cx="46.30" cy="16.84" r="0.48" fill="#000" fill-opacity="0.541"/><circle cx="10.96" cy="33.18" r="0.48" fill="#000" fill-opacity="0.545"/><circle cx="35.11" cy="9.63" r="0.49" fill="#000" fill-opacity="0.549"/><circle cx="28.79" cy="9.64" r="0.49" fill="#000" fill-opacity="0.549"/><circle cx="52.62" cy="42.29" r="0.50" fill="#000" fill-opacity="0.555"/><circle cx="51.88" cy="25.54" r="0.50" fill="#000" fill-opacity="0.560"/><circle cx="15.25" cy="18.09" r="0.52" fill="#000" fill-opacity="0.572"/><circle cx="40.90" cy="10.58" r="0.52" fill="#000" fill-opacity="0.573"/><circle cx="23.02" cy="10.60" r="0.52" fill="#000" fill-opacity="0.573"/><circle cx="11.55" cy="26.13" r="0.52" fill="#000" fill-opacity="0.575"/><circle cx="39.18" cy="57.67" r="0.69" fill="#000" fill-opacity="0.659"/><circle cx="53.91" cy="34.73" r="0.53" fill="#000" fill-opacity="0.583"/><circle cx="49.61" cy="18.72" r="0.54" fill="#000" fill-opacity="0.588"/><circle cx="26.22" cy="58.19" r="0.71" fill="#000" fill-opacity="0.673"/><circle cx="47.76" cy="52.19" r="0.63" fill="#000" fill-opacity="0.632"/><circle cx="16.28" cy="52.23" r="0.63" fill="#000" fill-opacity="0.633"/><circle cx="11.38" cy="43.95" r="0.55" fill="#000" fill-opacity="0.596"/><circle cx="9.97" cy="35.38" r="0.55" fill="#000" fill-opacity="0.600"/><circle cx="32.99" cy="58.92" r="0.74" fill="#000" fill-opacity="0.691"/><circle cx="53.29" cy="27.64" r="0.56" fill="#000" fill-opacity="0.613"/><circle cx="52.30" cy="44.70" r="0.57" fill="#000" fill-opacity="0.615"/><circle cx="45.15" cy="12.32" r="0.57" fill="#000" fill-opacity="0.616"/><circle cx="18.80" cy="12.35" r="0.57" fill="#000" fill-opacity="0.617"/><circle cx="13.10" cy="20.18" r="0.58" fill="#000" fill-opacity="0.625"/><circle cx="31.07" cy="6.85" r="0.63" fill="#000" fill-opacity="0.648"/><circle cx="10.59" cy="28.27" r="0.58" fill="#000" fill-opacity="0.628"/><circle cx="53.74" cy="36.95" r="0.60" fill="#000" fill-opacity="0.639"/><circle cx="51.19" cy="20.88" r="0.60" fill="#000" fill-opacity="0.642"/><circle cx="37.40" cy="7.54" r="0.65" fill="#000" fill-opacity="0.665"/><circle cx="44.33" cy="54.41" r="0.70" fill="#000" fill-opacity="0.688"/><circle cx="19.74" cy="54.44" r="0.70" fill="#000" fill-opacity="0.689"/><circle cx="13.08" cy="46.27" r="0.62" fill="#000" fill-opacity="0.655"/><circle cx="10.62" cy="37.59" r="0.62" fill="#000" fill-opacity="0.655"/><circle cx="25.29" cy="8.02" r="0.67" fill="#000" fill-opacity="0.677"/><circle cx="53.12" cy="29.80" r="0.63" fill="#000" fill-opacity="0.667"/><circle cx="50.00" cy="46.95" r="0.64" fill="#000" fill-opacity="0.671"/><circle cx="47.13" cy="14.55" r="0.64" fill="#000" fill-opacity="0.672"/><circle cx="16.86" cy="14.59" r="0.64" fill="#000" fill-opacity="0.673"/><circle cx="12.81" cy="22.42" r="0.65" fill="#000" fill-opacity="0.681"/><circle cx="11.22" cy="30.42" r="0.65" fill="#000" fill-opacity="0.682"/><circle cx="38.78" cy="55.91" r="0.76" fill="#000" fill-opacity="0.726"/><circle cx="25.32" cy="55.93" r="0.76" fill="#000" fill-opacity="0.726"/><circle cx="51.96" cy="39.08" r="0.66" fill="#000" fill-opacity="0.693"/><circle cx="50.90" cy="23.11" r="0.67" fill="#000" fill-opacity="0.698"/><circle cx="40.56" cy="9.68" r="0.72" fill="#000" fill-opacity="0.719"/><circle cx="32.05" cy="56.45" r="0.77" fill="#000" fill-opacity="0.739"/><circle cx="16.63" cy="48.29" r="0.68" fill="#000" fill-opacity="0.705"/><circle cx="12.85" cy="39.65" r="0.68" fill="#000" fill-opacity="0.707"/><circle cx="23.44" cy="10.37" r="0.74" fill="#000" fill-opacity="0.736"/><circle cx="32.00" cy="7.72" r="0.84" fill="#000" fill-opacity="0.769"/><circle cx="45.93" cy="48.82" r="0.69" fill="#000" fill-opacity="0.718"/><circle cx="51.39" cy="31.86" r="0.69" fill="#000" fill-opacity="0.719"/><circle cx="46.49" cy="16.89" r="0.71" fill="#000" fill-opacity="0.731"/><circle cx="17.54" cy="16.92" r="0.71" fill="#000" fill-opacity="0.732"/><circle cx="13.39" cy="32.42" r="0.71" fill="#000" fill-opacity="0.733"/><circle cx="14.39" cy="24.58" r="0.71" fill="#000" fill-opacity="0.735"/><circle cx="48.69" cy="40.95" r="0.72" fill="#000" fill-opacity="0.739"/><circle cx="21.69" cy="49.80" r="0.72" fill="#000" fill-opacity="0.743"/><circle cx="48.75" cy="25.21" r="0.73" fill="#000" fill-opacity="0.751"/><circle cx="16.50" cy="41.42" r="0.73" fill="#000" fill-opacity="0.751"/><circle cx="40.50" cy="50.14" r="0.73" fill="#000" fill-opacity="0.751"/><circle cx="38.71" cy="12.03" r="0.80" fill="#000" fill-opacity="0.777"/><circle cx="48.22" cy="33.68" r="0.75" fill="#000" fill-opacity="0.764"/><circle cx="27.75" cy="50.65" r="0.75" fill="#000" fill-opacity="0.764"/><circle cx="34.24" cy="50.77" r="0.75" fill="#000" fill-opacity="0.767"/><circle cx="26.60" cy="12.52" r="0.81" fill="#000" fill-opacity="0.790"/><circle cx="16.94" cy="34.14" r="0.76" fill="#000" fill-opacity="0.776"/><circle cx="44.19" cy="42.42" r="0.76" fill="#000" fill-opacity="0.776"/><circle cx="43.34" cy="18.92" r="0.77" fill="#000" fill-opacity="0.782"/><circle cx="17.70" cy="26.46" r="0.77" fill="#000" fill-opacity="0.782"/><circle cx="20.73" cy="18.95" r="0.77" fill="#000" fill-opacity="0.782"/><circle cx="21.31" cy="42.76" r="0.77" fill="#000" fill-opacity="0.785"/><circle cx="32.93" cy="13.20" r="0.84" fill="#000" fill-opacity="0.807"/><circle cx="44.96" cy="26.95" r="0.78" fill="#000" fill-opacity="0.794"/><circle cx="43.84" cy="35.11" r="0.79" fill="#000" fill-opacity="0.800"/><circle cx="38.78" cy="43.39" r="0.79" fill="#000" fill-opacity="0.801"/><circle cx="26.90" cy="43.56" r="0.80" fill="#000" fill-opacity="0.805"/><circle cx="21.61" cy="35.44" r="0.80" fill="#000" fill-opacity="0.808"/><circle cx="32.87" cy="43.78" r="0.80" fill="#000" fill-opacity="0.810"/><circle cx="38.23" cy="20.31" r="0.81" fill="#000" fill-opacity="0.816"/><circle cx="25.86" cy="20.32" r="0.81" fill="#000" fill-opacity="0.817"/><circle cx="22.40" cy="27.86" r="0.81" fill="#000" fill-opacity="0.817"/><circle cx="38.59" cy="36.05" r="0.82" fill="#000" fill-opacity="0.823"/><circle cx="39.91" cy="28.18" r="0.82" fill="#000" fill-opacity="0.825"/><circle cx="27.05" cy="36.22" r="0.82" fill="#000" fill-opacity="0.828"/><circle cx="32.05" cy="20.80" r="0.82" fill="#000" fill-opacity="0.829"/><circle cx="32.85" cy="36.43" r="0.83" fill="#000" fill-opacity="0.833"/><circle cx="28.05" cy="28.66" r="0.83" fill="#000" fill-opacity="0.837"/><circle cx="34.08" cy="28.77" r="0.84" fill="#000" fill-opacity="0.840"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/Contents.json
new file mode 100644
index 0000000000..fdb96bd857
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-listening-inline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/orb-listening-inline.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/orb-listening-inline.svg
new file mode 100644
index 0000000000..ff5ad21856
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-listening-inline.imageset/orb-listening-inline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><circle cx="9.18" cy="9.49" r="0.30" fill="#000" fill-opacity="0.403"/><circle cx="13.09" cy="9.71" r="0.30" fill="#000" fill-opacity="0.421"/><circle cx="9.47" cy="14.50" r="0.32" fill="#000" fill-opacity="0.472"/><circle cx="5.48" cy="10.02" r="0.30" fill="#000" fill-opacity="0.445"/><circle cx="13.10" cy="14.90" r="0.36" fill="#000" fill-opacity="0.504"/><circle cx="9.23" cy="5.23" r="0.30" fill="#000" fill-opacity="0.437"/><circle cx="6.14" cy="15.18" r="0.38" fill="#000" fill-opacity="0.526"/><circle cx="12.87" cy="5.44" r="0.30" fill="#000" fill-opacity="0.454"/><circle cx="16.18" cy="10.63" r="0.35" fill="#000" fill-opacity="0.495"/><circle cx="5.80" cy="5.72" r="0.32" fill="#000" fill-opacity="0.477"/><circle cx="3.00" cy="11.16" r="0.39" fill="#000" fill-opacity="0.537"/><circle cx="10.00" cy="17.87" r="0.48" fill="#000" fill-opacity="0.605"/><circle cx="15.75" cy="6.29" r="0.36" fill="#000" fill-opacity="0.522"/><circle cx="14.92" cy="16.13" r="0.48" fill="#000" fill-opacity="0.603"/><circle cx="5.08" cy="16.53" r="0.52" fill="#000" fill-opacity="0.635"/><circle cx="3.49" cy="6.79" r="0.40" fill="#000" fill-opacity="0.562"/><circle cx="9.56" cy="3.23" r="0.40" fill="#000" fill-opacity="0.566"/><circle cx="17.61" cy="12.00" r="0.47" fill="#000" fill-opacity="0.604"/><circle cx="12.58" cy="3.56" r="0.43" fill="#000" fill-opacity="0.592"/><circle cx="6.80" cy="3.79" r="0.45" fill="#000" fill-opacity="0.611"/><circle cx="2.39" cy="12.61" r="0.52" fill="#000" fill-opacity="0.654"/><circle cx="17.08" cy="7.57" r="0.46" fill="#000" fill-opacity="0.625"/><circle cx="13.86" cy="17.48" r="0.62" fill="#000" fill-opacity="0.711"/><circle cx="6.90" cy="17.76" r="0.65" fill="#000" fill-opacity="0.734"/><circle cx="2.92" cy="8.14" r="0.51" fill="#000" fill-opacity="0.670"/><circle cx="14.09" cy="4.58" r="0.51" fill="#000" fill-opacity="0.674"/><circle cx="17.00" cy="13.45" r="0.60" fill="#000" fill-opacity="0.721"/><circle cx="10.53" cy="18.15" r="0.69" fill="#000" fill-opacity="0.765"/><circle cx="5.91" cy="4.91" r="0.53" fill="#000" fill-opacity="0.700"/><circle cx="10.00" cy="3.69" r="0.53" fill="#000" fill-opacity="0.701"/><circle cx="3.82" cy="13.98" r="0.64" fill="#000" fill-opacity="0.763"/><circle cx="16.51" cy="8.92" r="0.56" fill="#000" fill-opacity="0.733"/><circle cx="13.20" cy="5.70" r="0.59" fill="#000" fill-opacity="0.764"/><circle cx="4.25" cy="9.41" r="0.60" fill="#000" fill-opacity="0.773"/><circle cx="14.52" cy="14.60" r="0.70" fill="#000" fill-opacity="0.813"/><circle cx="7.42" cy="5.93" r="0.61" fill="#000" fill-opacity="0.783"/><circle cx="6.91" cy="14.91" r="0.72" fill="#000" fill-opacity="0.837"/><circle cx="10.44" cy="6.26" r="0.64" fill="#000" fill-opacity="0.809"/><circle cx="10.82" cy="15.13" r="0.74" fill="#000" fill-opacity="0.855"/><circle cx="14.20" cy="9.98" r="0.65" fill="#000" fill-opacity="0.818"/><circle cx="7.13" cy="10.27" r="0.67" fill="#000" fill-opacity="0.841"/><circle cx="10.77" cy="10.48" r="0.68" fill="#000" fill-opacity="0.858"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/Contents.json
new file mode 100644
index 0000000000..3ef3570ee0
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-muted-avatar.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/orb-muted-avatar.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/orb-muted-avatar.svg
new file mode 100644
index 0000000000..9d5e45517e
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-avatar.imageset/orb-muted-avatar.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><circle cx="41.96" cy="53.82" r="0.49" fill="#000" fill-opacity="0.290"/><circle cx="9.11" cy="25.28" r="0.49" fill="#000" fill-opacity="0.290"/><circle cx="38.70" cy="54.83" r="0.49" fill="#000" fill-opacity="0.291"/><circle cx="10.38" cy="22.13" r="0.49" fill="#000" fill-opacity="0.291"/><circle cx="44.85" cy="52.00" r="0.49" fill="#000" fill-opacity="0.291"/><circle cx="8.64" cy="28.64" r="0.49" fill="#000" fill-opacity="0.291"/><circle cx="12.38" cy="19.39" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="35.32" cy="55.07" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="41.67" cy="10.83" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="44.56" cy="12.46" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="47.19" cy="49.53" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="38.53" cy="9.76" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="8.86" cy="32.00" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="47.15" cy="14.52" r="0.49" fill="#000" fill-opacity="0.292"/><circle cx="49.43" cy="16.89" r="0.49" fill="#000" fill-opacity="0.293"/><circle cx="51.37" cy="19.55" r="0.49" fill="#000" fill-opacity="0.293"/><circle cx="52.88" cy="22.46" r="0.50" fill="#000" fill-opacity="0.293"/><circle cx="35.25" cy="9.38" r="0.50" fill="#000" fill-opacity="0.293"/><circle cx="53.83" cy="25.59" r="0.50" fill="#000" fill-opacity="0.294"/><circle cx="32.00" cy="54.71" r="0.50" fill="#000" fill-opacity="0.294"/><circle cx="9.57" cy="35.22" r="0.50" fill="#000" fill-opacity="0.294"/><circle cx="14.92" cy="17.20" r="0.50" fill="#000" fill-opacity="0.294"/><circle cx="48.96" cy="46.69" r="0.50" fill="#000" fill-opacity="0.295"/><circle cx="54.16" cy="28.81" r="0.50" fill="#000" fill-opacity="0.295"/><circle cx="32.00" cy="9.67" r="0.50" fill="#000" fill-opacity="0.295"/><circle cx="10.61" cy="38.28" r="0.50" fill="#000" fill-opacity="0.295"/><circle cx="28.84" cy="53.96" r="0.50" fill="#000" fill-opacity="0.295"/><circle cx="11.91" cy="41.18" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="13.48" cy="43.90" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="15.39" cy="46.39" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="17.65" cy="48.56" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="53.90" cy="32.00" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="25.84" cy="52.98" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="17.69" cy="15.49" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="20.20" cy="50.36" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="22.96" cy="51.80" r="0.50" fill="#000" fill-opacity="0.296"/><circle cx="28.91" cy="10.49" r="0.50" fill="#000" fill-opacity="0.297"/><circle cx="50.28" cy="43.75" r="0.50" fill="#000" fill-opacity="0.297"/><circle cx="53.23" cy="35.05" r="0.50" fill="#000" fill-opacity="0.297"/><circle cx="20.50" cy="14.10" r="0.50" fill="#000" fill-opacity="0.298"/><circle cx="51.35" cy="40.84" r="0.50" fill="#000" fill-opacity="0.298"/><circle cx="26.01" cy="11.61" r="0.50" fill="#000" fill-opacity="0.298"/><circle cx="52.33" cy="37.97" r="0.50" fill="#000" fill-opacity="0.298"/><circle cx="23.25" cy="12.84" r="0.50" fill="#000" fill-opacity="0.299"/><circle cx="9.90" cy="21.91" r="0.56" fill="#000" fill-opacity="0.343"/><circle cx="8.70" cy="25.16" r="0.56" fill="#000" fill-opacity="0.343"/><circle cx="42.09" cy="54.09" r="0.56" fill="#000" fill-opacity="0.343"/><circle cx="38.82" cy="55.21" r="0.56" fill="#000" fill-opacity="0.343"/><circle cx="44.97" cy="52.18" r="0.56" fill="#000" fill-opacity="0.344"/><circle cx="8.32" cy="28.59" r="0.56" fill="#000" fill-opacity="0.344"/><circle cx="11.89" cy="19.08" r="0.56" fill="#000" fill-opacity="0.344"/><circle cx="35.39" cy="55.56" r="0.56" fill="#000" fill-opacity="0.344"/><circle cx="51.83" cy="19.26" r="0.56" fill="#000" fill-opacity="0.344"/><circle cx="53.42" cy="22.22" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="49.77" cy="16.60" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="47.38" cy="14.25" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="44.70" cy="12.25" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="41.74" cy="10.66" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="8.63" cy="32.00" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="54.41" cy="25.42" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="47.29" cy="49.65" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="38.57" cy="9.63" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="32.00" cy="55.26" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="14.46" cy="16.80" r="0.56" fill="#000" fill-opacity="0.345"/><circle cx="35.27" cy="9.24" r="0.56" fill="#000" fill-opacity="0.346"/><circle cx="54.72" cy="28.73" r="0.56" fill="#000" fill-opacity="0.346"/><circle cx="9.42" cy="35.25" r="0.56" fill="#000" fill-opacity="0.346"/><circle cx="28.76" cy="54.55" r="0.56" fill="#000" fill-opacity="0.346"/><circle cx="49.05" cy="46.78" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="32.00" cy="9.49" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="25.67" cy="53.54" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="17.32" cy="15.05" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="10.49" cy="38.32" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="54.40" cy="32.00" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="22.73" cy="52.30" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="19.95" cy="50.75" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="17.40" cy="48.84" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="15.18" cy="46.57" r="0.56" fill="#000" fill-opacity="0.347"/><circle cx="11.78" cy="41.23" r="0.56" fill="#000" fill-opacity="0.348"/><circle cx="13.32" cy="44.01" r="0.56" fill="#000" fill-opacity="0.348"/><circle cx="28.87" cy="10.25" r="0.56" fill="#000" fill-opacity="0.348"/><circle cx="50.40" cy="43.82" r="0.56" fill="#000" fill-opacity="0.348"/><circle cx="53.62" cy="35.11" r="0.56" fill="#000" fill-opacity="0.348"/><circle cx="20.22" cy="13.67" r="0.56" fill="#000" fill-opacity="0.349"/><circle cx="25.92" cy="11.30" r="0.56" fill="#000" fill-opacity="0.349"/><circle cx="23.07" cy="12.45" r="0.56" fill="#000" fill-opacity="0.349"/><circle cx="52.61" cy="38.05" r="0.56" fill="#000" fill-opacity="0.349"/><circle cx="51.54" cy="40.92" r="0.56" fill="#000" fill-opacity="0.349"/><circle cx="9.57" cy="21.76" r="0.63" fill="#000" fill-opacity="0.399"/><circle cx="8.44" cy="25.08" r="0.63" fill="#000" fill-opacity="0.399"/><circle cx="38.88" cy="55.43" r="0.63" fill="#000" fill-opacity="0.399"/><circle cx="42.14" cy="54.21" r="0.63" fill="#000" fill-opacity="0.399"/><circle cx="11.52" cy="18.84" r="0.63" fill="#000" fill-opacity="0.399"/><circle cx="35.43" cy="55.88" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="8.16" cy="28.57" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="45.00" cy="52.23" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="53.83" cy="22.03" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="52.15" cy="19.05" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="54.88" cy="25.28" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="49.99" cy="16.41" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="14.09" cy="16.49" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="32.00" cy="55.67" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="47.50" cy="14.11" r="0.63" fill="#000" fill-opacity="0.400"/><circle cx="44.75" cy="12.16" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="41.76" cy="10.63" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="8.56" cy="32.00" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="55.20" cy="28.66" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="47.30" cy="49.66" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="38.57" cy="9.61" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="28.69" cy="55.01" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="35.28" cy="9.20" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="25.54" cy="54.01" r="0.63" fill="#000" fill-opacity="0.401"/><circle cx="17.00" cy="14.69" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="9.40" cy="35.25" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="54.83" cy="32.00" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="22.54" cy="52.72" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="19.73" cy="51.09" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="17.19" cy="49.09" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="32.00" cy="9.40" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="49.07" cy="46.79" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="15.02" cy="46.72" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="10.48" cy="38.32" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="13.22" cy="44.07" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="11.74" cy="41.25" r="0.63" fill="#000" fill-opacity="0.402"/><circle cx="19.98" cy="13.30" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="53.97" cy="35.16" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="28.85" cy="10.07" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="50.45" cy="43.86" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="22.92" cy="12.12" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="25.84" cy="11.03" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="52.85" cy="38.12" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="51.67" cy="40.98" r="0.63" fill="#000" fill-opacity="0.403"/><circle cx="9.41" cy="21.68" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="8.37" cy="25.06" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="11.29" cy="18.69" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="38.89" cy="55.48" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="42.13" cy="54.18" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="54.11" cy="21.90" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="35.45" cy="56.02" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="55.23" cy="25.18" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="52.33" cy="18.94" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="8.17" cy="28.57" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="13.84" cy="16.26" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="44.95" cy="52.15" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="32.00" cy="55.92" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="50.07" cy="16.34" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="55.57" cy="28.61" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="47.51" cy="14.10" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="28.65" cy="55.32" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="44.71" cy="12.22" r="0.70" fill="#000" fill-opacity="0.459"/><circle cx="41.72" cy="10.72" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="8.64" cy="32.00" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="25.43" cy="54.36" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="16.76" cy="14.41" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="47.23" cy="49.58" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="38.55" cy="9.71" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="55.18" cy="32.00" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="22.39" cy="53.05" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="19.55" cy="51.37" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="35.27" cy="9.26" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="17.03" cy="49.27" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="9.51" cy="35.23" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="14.90" cy="46.81" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="32.00" cy="9.38" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="19.79" cy="13.00" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="49.01" cy="46.74" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="54.24" cy="35.20" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="13.18" cy="44.10" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="10.57" cy="38.29" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="28.83" cy="9.96" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="11.78" cy="41.24" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="22.80" cy="11.84" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="25.78" cy="10.83" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="50.44" cy="43.85" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="53.02" cy="38.17" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="51.74" cy="41.01" r="0.70" fill="#000" fill-opacity="0.460"/><circle cx="51.75" cy="41.02" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="50.36" cy="43.80" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="53.12" cy="38.20" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="11.89" cy="41.19" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="10.76" cy="38.24" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="25.74" cy="10.69" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="28.82" cy="9.92" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="48.87" cy="46.62" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="13.20" cy="44.08" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="22.71" cy="11.66" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="9.74" cy="35.20" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="32.00" cy="9.44" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="54.42" cy="35.22" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="14.85" cy="46.86" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="35.25" cy="9.41" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="19.66" cy="12.80" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="38.49" cy="9.91" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="16.93" cy="49.40" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="47.08" cy="49.41" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="8.87" cy="32.00" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="41.62" cy="10.94" r="0.72" fill="#000" fill-opacity="0.484"/><circle cx="19.43" cy="51.55" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="44.59" cy="12.40" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="22.29" cy="53.27" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="55.41" cy="32.00" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="16.61" cy="14.24" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="47.40" cy="14.23" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="25.37" cy="54.57" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="44.82" cy="51.95" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="28.63" cy="55.47" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="50.02" cy="16.39" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="8.36" cy="28.60" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="32.00" cy="55.97" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="55.81" cy="28.58" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="42.04" cy="53.99" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="52.35" cy="18.92" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="13.70" cy="16.15" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="35.45" cy="55.98" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="38.85" cy="55.35" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="55.42" cy="25.12" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="54.22" cy="21.85" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="8.47" cy="25.09" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="11.21" cy="18.64" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="9.41" cy="21.69" r="0.72" fill="#000" fill-opacity="0.485"/><circle cx="51.69" cy="40.99" r="0.69" fill="#000" fill-opacity="0.470"/><circle cx="50.23" cy="43.71" r="0.69" fill="#000" fill-opacity="0.470"/><circle cx="11.04" cy="38.16" r="0.69" fill="#000" fill-opacity="0.470"/><circle cx="12.07" cy="41.10" r="0.69" fill="#000" fill-opacity="0.470"/><circle cx="53.15" cy="38.21" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="48.68" cy="46.45" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="10.08" cy="35.15" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="13.28" cy="44.03" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="25.73" cy="10.64" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="28.83" cy="9.95" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="32.00" cy="9.57" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="22.67" cy="11.56" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="35.22" cy="9.64" r="0.69" fill="#000" fill-opacity="0.471"/><circle cx="14.85" cy="46.86" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="46.87" cy="49.16" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="38.40" cy="10.21" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="54.51" cy="35.24" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="9.24" cy="32.00" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="41.47" cy="11.27" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="44.40" cy="12.71" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="19.60" cy="12.71" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="16.88" cy="49.45" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="47.19" cy="14.48" r="0.69" fill="#000" fill-opacity="0.472"/><circle cx="44.62" cy="51.64" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="19.38" cy="51.64" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="22.24" cy="53.36" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="55.52" cy="32.00" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="8.70" cy="28.65" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="25.36" cy="54.62" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="16.56" cy="14.18" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="49.82" cy="16.56" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="28.63" cy="55.45" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="41.89" cy="53.66" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="32.00" cy="55.85" r="0.69" fill="#000" fill-opacity="0.473"/><circle cx="35.42" cy="55.75" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="38.77" cy="55.05" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="52.21" cy="19.01" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="55.89" cy="28.57" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="13.70" cy="16.15" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="8.75" cy="25.17" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="54.16" cy="21.88" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="55.44" cy="25.12" r="0.69" fill="#000" fill-opacity="0.474"/><circle cx="11.29" cy="18.69" r="0.69" fill="#000" fill-opacity="0.475"/><circle cx="9.60" cy="21.77" r="0.69" fill="#000" fill-opacity="0.475"/><circle cx="50.04" cy="43.59" r="0.65" fill="#000" fill-opacity="0.454"/><circle cx="11.38" cy="38.05" r="0.65" fill="#000" fill-opacity="0.454"/><circle cx="51.57" cy="40.94" r="0.65" fill="#000" fill-opacity="0.454"/><circle cx="12.30" cy="40.99" r="0.65" fill="#000" fill-opacity="0.455"/><circle cx="10.51" cy="35.09" r="0.65" fill="#000" fill-opacity="0.455"/><circle cx="48.43" cy="46.24" r="0.65" fill="#000" fill-opacity="0.455"/><circle cx="53.10" cy="38.20" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="13.42" cy="43.94" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="28.84" cy="10.05" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="25.74" cy="10.68" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="32.00" cy="9.77" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="9.72" cy="32.00" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="46.59" cy="48.84" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="35.17" cy="9.94" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="38.29" cy="10.59" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="41.28" cy="11.69" r="0.65" fill="#000" fill-opacity="0.456"/><circle cx="44.13" cy="13.12" r="0.65" fill="#000" fill-opacity="0.457"/><circle cx="22.67" cy="11.57" r="0.65" fill="#000" fill-opacity="0.457"/><circle cx="14.91" cy="46.81" r="0.65" fill="#000" fill-opacity="0.457"/><circle cx="46.88" cy="14.83" r="0.65" fill="#000" fill-opacity="0.457"/><circle cx="54.49" cy="35.23" r="0.65" fill="#000" fill-opacity="0.457"/><circle cx="44.36" cy="51.23" r="0.65" fill="#000" fill-opacity="0.458"/><circle cx="19.61" cy="12.73" r="0.65" fill="#000" fill-opacity="0.458"/><circle cx="9.19" cy="28.72" r="0.65" fill="#000" fill-opacity="0.458"/><circle cx="16.90" cy="49.42" r="0.65" fill="#000" fill-opacity="0.458"/><circle cx="49.50" cy="16.83" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="41.69" cy="53.21" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="19.39" cy="51.63" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="22.26" cy="53.32" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="25.39" cy="54.51" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="28.66" cy="55.24" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="16.62" cy="14.25" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="55.49" cy="32.00" r="0.65" fill="#000" fill-opacity="0.459"/><circle cx="32.00" cy="55.54" r="0.65" fill="#000" fill-opacity="0.460"/><circle cx="38.64" cy="54.60" r="0.65" fill="#000" fill-opacity="0.460"/><circle cx="35.36" cy="55.36" r="0.65" fill="#000" fill-opacity="0.460"/><circle cx="51.93" cy="19.19" r="0.65" fill="#000" fill-opacity="0.460"/><circle cx="9.18" cy="25.30" r="0.65" fill="#000" fill-opacity="0.460"/><circle cx="13.84" cy="16.26" r="0.65" fill="#000" fill-opacity="0.461"/><circle cx="55.82" cy="28.58" r="0.65" fill="#000" fill-opacity="0.461"/><circle cx="53.94" cy="21.98" r="0.65" fill="#000" fill-opacity="0.461"/><circle cx="9.94" cy="21.92" r="0.65" fill="#000" fill-opacity="0.461"/><circle cx="55.30" cy="25.16" r="0.65" fill="#000" fill-opacity="0.462"/><circle cx="11.53" cy="18.84" r="0.65" fill="#000" fill-opacity="0.462"/><circle cx="11.78" cy="37.94" r="0.61" fill="#000" fill-opacity="0.436"/><circle cx="49.80" cy="43.44" r="0.61" fill="#000" fill-opacity="0.436"/><circle cx="11.01" cy="35.02" r="0.61" fill="#000" fill-opacity="0.436"/><circle cx="51.40" cy="40.86" r="0.61" fill="#000" fill-opacity="0.437"/><circle cx="12.59" cy="40.86" r="0.61" fill="#000" fill-opacity="0.437"/><circle cx="48.14" cy="45.99" r="0.61" fill="#000" fill-opacity="0.437"/><circle cx="10.29" cy="32.00" r="0.61" fill="#000" fill-opacity="0.438"/><circle cx="46.27" cy="48.47" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="41.06" cy="12.17" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="52.96" cy="38.16" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="38.16" cy="11.03" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="13.61" cy="43.82" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="43.82" cy="13.61" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="35.12" cy="10.29" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="32.00" cy="10.03" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="28.87" cy="10.23" r="0.61" fill="#000" fill-opacity="0.439"/><circle cx="25.78" cy="10.81" r="0.61" fill="#000" fill-opacity="0.440"/><circle cx="46.49" cy="15.28" r="0.61" fill="#000" fill-opacity="0.440"/><circle cx="44.06" cy="50.76" r="0.61" fill="#000" fill-opacity="0.440"/><circle cx="22.72" cy="11.69" r="0.61" fill="#000" fill-opacity="0.440"/><circle cx="15.04" cy="46.70" r="0.61" fill="#000" fill-opacity="0.441"/><circle cx="9.78" cy="28.81" r="0.61" fill="#000" fill-opacity="0.441"/><circle cx="54.36" cy="35.22" r="0.61" fill="#000" fill-opacity="0.441"/><circle cx="49.08" cy="17.20" r="0.61" fill="#000" fill-opacity="0.441"/><circle cx="41.44" cy="52.66" r="0.61" fill="#000" fill-opacity="0.442"/><circle cx="19.70" cy="12.87" r="0.61" fill="#000" fill-opacity="0.442"/><circle cx="16.99" cy="49.32" r="0.61" fill="#000" fill-opacity="0.443"/><circle cx="38.47" cy="54.03" r="0.61" fill="#000" fill-opacity="0.443"/><circle cx="35.28" cy="54.81" r="0.61" fill="#000" fill-opacity="0.443"/><circle cx="32.00" cy="55.08" r="0.61" fill="#000" fill-opacity="0.443"/><circle cx="28.71" cy="54.88" r="0.61" fill="#000" fill-opacity="0.443"/><circle cx="19.47" cy="51.50" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="51.51" cy="19.46" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="25.47" cy="54.25" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="9.75" cy="25.47" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="22.34" cy="53.14" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="16.78" cy="14.43" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="55.33" cy="32.00" r="0.61" fill="#000" fill-opacity="0.444"/><circle cx="14.10" cy="16.49" r="0.61" fill="#000" fill-opacity="0.445"/><circle cx="53.57" cy="22.15" r="0.61" fill="#000" fill-opacity="0.445"/><circle cx="10.43" cy="22.15" r="0.61" fill="#000" fill-opacity="0.445"/><circle cx="55.60" cy="28.61" r="0.61" fill="#000" fill-opacity="0.446"/><circle cx="11.91" cy="19.09" r="0.61" fill="#000" fill-opacity="0.446"/><circle cx="54.99" cy="25.25" r="0.61" fill="#000" fill-opacity="0.446"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/Contents.json
new file mode 100644
index 0000000000..778a9172d1
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-muted-inline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/orb-muted-inline.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/orb-muted-inline.svg
new file mode 100644
index 0000000000..eb38bc06f3
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-muted-inline.imageset/orb-muted-inline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><circle cx="12.33" cy="17.17" r="0.43" fill="#000" fill-opacity="0.310"/><circle cx="2.68" cy="8.44" r="0.43" fill="#000" fill-opacity="0.310"/><circle cx="12.23" cy="3.13" r="0.43" fill="#000" fill-opacity="0.312"/><circle cx="14.81" cy="4.66" r="0.43" fill="#000" fill-opacity="0.312"/><circle cx="14.80" cy="15.33" r="0.43" fill="#000" fill-opacity="0.312"/><circle cx="4.21" cy="5.79" r="0.43" fill="#000" fill-opacity="0.313"/><circle cx="16.49" cy="7.11" r="0.43" fill="#000" fill-opacity="0.313"/><circle cx="3.27" cy="11.43" r="0.43" fill="#000" fill-opacity="0.315"/><circle cx="9.29" cy="16.77" r="0.43" fill="#000" fill-opacity="0.315"/><circle cx="4.61" cy="13.91" r="0.43" fill="#000" fill-opacity="0.316"/><circle cx="16.61" cy="10.00" r="0.43" fill="#000" fill-opacity="0.316"/><circle cx="9.31" cy="3.43" r="0.43" fill="#000" fill-opacity="0.316"/><circle cx="6.72" cy="15.68" r="0.44" fill="#000" fill-opacity="0.317"/><circle cx="15.76" cy="12.57" r="0.44" fill="#000" fill-opacity="0.319"/><circle cx="6.87" cy="4.58" r="0.44" fill="#000" fill-opacity="0.319"/><circle cx="12.35" cy="17.24" r="0.50" fill="#000" fill-opacity="0.379"/><circle cx="2.60" cy="8.43" r="0.50" fill="#000" fill-opacity="0.379"/><circle cx="4.06" cy="5.69" r="0.51" fill="#000" fill-opacity="0.380"/><circle cx="16.66" cy="7.04" r="0.51" fill="#000" fill-opacity="0.380"/><circle cx="14.86" cy="4.60" r="0.51" fill="#000" fill-opacity="0.380"/><circle cx="12.23" cy="3.15" r="0.51" fill="#000" fill-opacity="0.381"/><circle cx="14.78" cy="15.31" r="0.51" fill="#000" fill-opacity="0.381"/><circle cx="9.27" cy="16.95" r="0.51" fill="#000" fill-opacity="0.382"/><circle cx="3.30" cy="11.42" r="0.51" fill="#000" fill-opacity="0.382"/><circle cx="16.75" cy="10.00" r="0.51" fill="#000" fill-opacity="0.383"/><circle cx="6.65" cy="15.80" r="0.51" fill="#000" fill-opacity="0.383"/><circle cx="4.60" cy="13.92" r="0.51" fill="#000" fill-opacity="0.383"/><circle cx="9.31" cy="3.42" r="0.51" fill="#000" fill-opacity="0.383"/><circle cx="6.80" cy="4.46" r="0.51" fill="#000" fill-opacity="0.384"/><circle cx="15.77" cy="12.57" r="0.51" fill="#000" fill-opacity="0.385"/><circle cx="12.36" cy="17.26" r="0.58" fill="#000" fill-opacity="0.452"/><circle cx="2.59" cy="8.42" r="0.58" fill="#000" fill-opacity="0.452"/><circle cx="3.95" cy="5.61" r="0.58" fill="#000" fill-opacity="0.452"/><circle cx="16.78" cy="6.98" r="0.58" fill="#000" fill-opacity="0.452"/><circle cx="14.87" cy="4.59" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="12.20" cy="3.22" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="9.26" cy="17.08" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="14.74" cy="15.26" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="16.88" cy="10.00" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="6.59" cy="15.91" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="3.37" cy="11.41" r="0.58" fill="#000" fill-opacity="0.453"/><circle cx="4.61" cy="13.92" r="0.58" fill="#000" fill-opacity="0.454"/><circle cx="9.31" cy="3.42" r="0.58" fill="#000" fill-opacity="0.454"/><circle cx="6.74" cy="4.35" r="0.58" fill="#000" fill-opacity="0.454"/><circle cx="15.76" cy="12.57" r="0.58" fill="#000" fill-opacity="0.454"/><circle cx="15.75" cy="12.56" r="0.60" fill="#000" fill-opacity="0.476"/><circle cx="9.31" cy="3.44" r="0.60" fill="#000" fill-opacity="0.476"/><circle cx="6.69" cy="4.27" r="0.60" fill="#000" fill-opacity="0.476"/><circle cx="4.62" cy="13.91" r="0.60" fill="#000" fill-opacity="0.476"/><circle cx="3.48" cy="11.39" r="0.60" fill="#000" fill-opacity="0.476"/><circle cx="6.54" cy="16.00" r="0.60" fill="#000" fill-opacity="0.477"/><circle cx="14.66" cy="15.18" r="0.60" fill="#000" fill-opacity="0.477"/><circle cx="16.98" cy="10.00" r="0.60" fill="#000" fill-opacity="0.477"/><circle cx="12.17" cy="3.32" r="0.60" fill="#000" fill-opacity="0.477"/><circle cx="9.25" cy="17.16" r="0.60" fill="#000" fill-opacity="0.477"/><circle cx="14.83" cy="4.63" r="0.60" fill="#000" fill-opacity="0.477"/><circle cx="16.85" cy="6.95" r="0.60" fill="#000" fill-opacity="0.478"/><circle cx="2.64" cy="8.44" r="0.60" fill="#000" fill-opacity="0.478"/><circle cx="3.89" cy="5.56" r="0.60" fill="#000" fill-opacity="0.478"/><circle cx="12.34" cy="17.21" r="0.60" fill="#000" fill-opacity="0.478"/><circle cx="15.72" cy="12.55" r="0.55" fill="#000" fill-opacity="0.445"/><circle cx="3.62" cy="11.36" r="0.55" fill="#000" fill-opacity="0.446"/><circle cx="9.31" cy="3.47" r="0.55" fill="#000" fill-opacity="0.446"/><circle cx="4.65" cy="13.89" r="0.55" fill="#000" fill-opacity="0.447"/><circle cx="6.65" cy="4.21" r="0.55" fill="#000" fill-opacity="0.447"/><circle cx="14.57" cy="15.07" r="0.55" fill="#000" fill-opacity="0.448"/><circle cx="12.13" cy="3.46" r="0.55" fill="#000" fill-opacity="0.448"/><circle cx="6.50" cy="16.06" r="0.55" fill="#000" fill-opacity="0.449"/><circle cx="17.05" cy="10.00" r="0.55" fill="#000" fill-opacity="0.449"/><circle cx="14.76" cy="4.71" r="0.55" fill="#000" fill-opacity="0.449"/><circle cx="9.25" cy="17.18" r="0.55" fill="#000" fill-opacity="0.450"/><circle cx="2.75" cy="8.46" r="0.55" fill="#000" fill-opacity="0.451"/><circle cx="12.31" cy="17.10" r="0.55" fill="#000" fill-opacity="0.451"/><circle cx="16.87" cy="6.94" r="0.55" fill="#000" fill-opacity="0.451"/><circle cx="3.88" cy="5.55" r="0.55" fill="#000" fill-opacity="0.451"/><circle cx="15.69" cy="12.53" r="0.50" fill="#000" fill-opacity="0.412"/><circle cx="3.78" cy="11.32" r="0.50" fill="#000" fill-opacity="0.413"/><circle cx="9.32" cy="3.51" r="0.50" fill="#000" fill-opacity="0.414"/><circle cx="4.68" cy="13.87" r="0.50" fill="#000" fill-opacity="0.415"/><circle cx="14.46" cy="14.95" r="0.50" fill="#000" fill-opacity="0.415"/><circle cx="12.07" cy="3.62" r="0.50" fill="#000" fill-opacity="0.416"/><circle cx="6.64" cy="4.17" r="0.50" fill="#000" fill-opacity="0.416"/><circle cx="14.65" cy="4.84" r="0.50" fill="#000" fill-opacity="0.418"/><circle cx="6.49" cy="16.08" r="0.50" fill="#000" fill-opacity="0.418"/><circle cx="17.08" cy="10.00" r="0.50" fill="#000" fill-opacity="0.419"/><circle cx="9.25" cy="17.13" r="0.50" fill="#000" fill-opacity="0.419"/><circle cx="2.91" cy="8.49" r="0.50" fill="#000" fill-opacity="0.420"/><circle cx="12.26" cy="16.94" r="0.50" fill="#000" fill-opacity="0.420"/><circle cx="16.83" cy="6.96" r="0.50" fill="#000" fill-opacity="0.422"/><circle cx="3.91" cy="5.58" r="0.50" fill="#000" fill-opacity="0.422"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/Contents.json
new file mode 100644
index 0000000000..f626a07b99
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-speaking-avatar.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/orb-speaking-avatar.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/orb-speaking-avatar.svg
new file mode 100644
index 0000000000..3ae34b2601
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-avatar.imageset/orb-speaking-avatar.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><circle cx="37.32" cy="30.66" r="0.32" fill="#000" fill-opacity="0.023"/><circle cx="24.68" cy="37.91" r="0.32" fill="#000" fill-opacity="0.024"/><circle cx="28.65" cy="41.19" r="0.30" fill="#000" fill-opacity="0.135"/><circle cx="25.47" cy="39.74" r="0.30" fill="#000" fill-opacity="0.136"/><circle cx="32.00" cy="42.98" r="0.30" fill="#000" fill-opacity="0.139"/><circle cx="22.42" cy="38.68" r="0.30" fill="#000" fill-opacity="0.142"/><circle cx="28.55" cy="43.45" r="0.33" fill="#000" fill-opacity="0.162"/><circle cx="28.85" cy="20.42" r="0.32" fill="#000" fill-opacity="0.025"/><circle cx="25.24" cy="41.98" r="0.33" fill="#000" fill-opacity="0.163"/><circle cx="32.00" cy="45.12" r="0.34" fill="#000" fill-opacity="0.168"/><circle cx="35.50" cy="44.71" r="0.31" fill="#000" fill-opacity="0.148"/><circle cx="22.10" cy="40.76" r="0.34" fill="#000" fill-opacity="0.169"/><circle cx="19.50" cy="37.79" r="0.31" fill="#000" fill-opacity="0.151"/><circle cx="25.08" cy="44.26" r="0.37" fill="#000" fill-opacity="0.194"/><circle cx="28.48" cy="45.66" r="0.37" fill="#000" fill-opacity="0.194"/><circle cx="21.84" cy="42.96" r="0.37" fill="#000" fill-opacity="0.199"/><circle cx="19.12" cy="39.61" r="0.35" fill="#000" fill-opacity="0.179"/><circle cx="42.17" cy="43.02" r="0.32" fill="#000" fill-opacity="0.027"/><circle cx="35.54" cy="46.57" r="0.35" fill="#000" fill-opacity="0.179"/><circle cx="32.00" cy="47.09" r="0.37" fill="#000" fill-opacity="0.200"/><circle cx="38.99" cy="45.71" r="0.32" fill="#000" fill-opacity="0.161"/><circle cx="16.78" cy="36.75" r="0.33" fill="#000" fill-opacity="0.165"/><circle cx="24.99" cy="46.46" r="0.41" fill="#000" fill-opacity="0.229"/><circle cx="28.45" cy="47.70" r="0.41" fill="#000" fill-opacity="0.229"/><circle cx="18.81" cy="41.61" r="0.38" fill="#000" fill-opacity="0.210"/><circle cx="16.06" cy="28.24" r="0.32" fill="#000" fill-opacity="0.028"/><circle cx="35.55" cy="48.20" r="0.39" fill="#000" fill-opacity="0.212"/><circle cx="21.68" cy="45.18" r="0.42" fill="#000" fill-opacity="0.235"/><circle cx="39.03" cy="47.22" r="0.36" fill="#000" fill-opacity="0.192"/><circle cx="16.40" cy="38.27" r="0.36" fill="#000" fill-opacity="0.192"/><circle cx="32.00" cy="48.83" r="0.42" fill="#000" fill-opacity="0.236"/><circle cx="42.34" cy="45.45" r="0.33" fill="#000" fill-opacity="0.172"/><circle cx="45.41" cy="43.69" r="0.34" fill="#000" fill-opacity="0.179"/><circle cx="18.59" cy="43.70" r="0.43" fill="#000" fill-opacity="0.245"/><circle cx="16.06" cy="39.97" r="0.40" fill="#000" fill-opacity="0.223"/><circle cx="28.46" cy="49.49" r="0.46" fill="#000" fill-opacity="0.268"/><circle cx="24.97" cy="48.48" r="0.46" fill="#000" fill-opacity="0.269"/><circle cx="14.38" cy="35.38" r="0.34" fill="#000" fill-opacity="0.180"/><circle cx="35.54" cy="49.59" r="0.43" fill="#000" fill-opacity="0.247"/><circle cx="39.03" cy="48.52" r="0.40" fill="#000" fill-opacity="0.225"/><circle cx="42.37" cy="46.65" r="0.37" fill="#000" fill-opacity="0.203"/><circle cx="48.03" cy="40.57" r="0.35" fill="#000" fill-opacity="0.183"/><circle cx="32.00" cy="50.31" r="0.46" fill="#000" fill-opacity="0.273"/><circle cx="21.63" cy="47.30" r="0.46" fill="#000" fill-opacity="0.275"/><circle cx="45.47" cy="44.67" r="0.38" fill="#000" fill-opacity="0.208"/><circle cx="14.03" cy="36.58" r="0.38" fill="#000" fill-opacity="0.209"/><circle cx="50.00" cy="36.70" r="0.35" fill="#000" fill-opacity="0.187"/><circle cx="49.69" cy="26.17" r="0.32" fill="#000" fill-opacity="0.030"/><circle cx="48.15" cy="41.41" r="0.38" fill="#000" fill-opacity="0.210"/><circle cx="42.36" cy="47.68" r="0.41" fill="#000" fill-opacity="0.234"/><circle cx="39.00" cy="49.60" r="0.44" fill="#000" fill-opacity="0.258"/><circle cx="15.80" cy="41.82" r="0.44" fill="#000" fill-opacity="0.258"/><circle cx="50.20" cy="37.47" r="0.38" fill="#000" fill-opacity="0.214"/><circle cx="35.52" cy="50.74" r="0.47" fill="#000" fill-opacity="0.283"/><circle cx="32.05" cy="51.09" r="0.32" fill="#000" fill-opacity="0.031"/><circle cx="45.49" cy="45.54" r="0.41" fill="#000" fill-opacity="0.238"/><circle cx="41.46" cy="15.36" r="0.32" fill="#000" fill-opacity="0.031"/><circle cx="48.24" cy="42.20" r="0.41" fill="#000" fill-opacity="0.238"/><circle cx="13.69" cy="37.96" r="0.41" fill="#000" fill-opacity="0.239"/><circle cx="18.51" cy="45.79" r="0.47" fill="#000" fill-opacity="0.286"/><circle cx="28.49" cy="50.99" r="0.45" fill="#000" fill-opacity="0.263"/><circle cx="51.36" cy="32.95" r="0.36" fill="#000" fill-opacity="0.195"/><circle cx="50.38" cy="38.29" r="0.42" fill="#000" fill-opacity="0.241"/><circle cx="42.33" cy="48.56" r="0.45" fill="#000" fill-opacity="0.266"/><circle cx="25.03" cy="50.23" r="0.45" fill="#000" fill-opacity="0.266"/><circle cx="32.00" cy="51.52" r="0.45" fill="#000" fill-opacity="0.266"/><circle cx="48.30" cy="42.99" r="0.45" fill="#000" fill-opacity="0.268"/><circle cx="45.49" cy="46.32" r="0.45" fill="#000" fill-opacity="0.268"/><circle cx="12.35" cy="33.72" r="0.36" fill="#000" fill-opacity="0.199"/><circle cx="51.66" cy="33.74" r="0.39" fill="#000" fill-opacity="0.222"/><circle cx="38.95" cy="50.50" r="0.48" fill="#000" fill-opacity="0.292"/><circle cx="50.54" cy="39.17" r="0.45" fill="#000" fill-opacity="0.271"/><circle cx="19.25" cy="47.28" r="0.32" fill="#000" fill-opacity="0.032"/><circle cx="35.48" cy="51.68" r="0.45" fill="#000" fill-opacity="0.272"/><circle cx="21.71" cy="49.21" r="0.46" fill="#000" fill-opacity="0.273"/><circle cx="13.40" cy="39.50" r="0.46" fill="#000" fill-opacity="0.273"/><circle cx="15.67" cy="43.76" r="0.49" fill="#000" fill-opacity="0.298"/><circle cx="42.28" cy="49.31" r="0.49" fill="#000" fill-opacity="0.298"/><circle cx="51.96" cy="34.64" r="0.43" fill="#000" fill-opacity="0.251"/><circle cx="12.04" cy="34.65" r="0.40" fill="#000" fill-opacity="0.227"/><circle cx="48.34" cy="43.80" r="0.49" fill="#000" fill-opacity="0.298"/><circle cx="45.47" cy="47.04" r="0.49" fill="#000" fill-opacity="0.299"/><circle cx="50.69" cy="40.14" r="0.49" fill="#000" fill-opacity="0.302"/><circle cx="38.89" cy="51.24" r="0.46" fill="#000" fill-opacity="0.279"/><circle cx="32.00" cy="52.50" r="0.43" fill="#000" fill-opacity="0.256"/><circle cx="52.40" cy="29.92" r="0.37" fill="#000" fill-opacity="0.209"/><circle cx="28.54" cy="52.21" r="0.43" fill="#000" fill-opacity="0.256"/><circle cx="52.26" cy="35.67" r="0.46" fill="#000" fill-opacity="0.281"/><circle cx="11.72" cy="35.72" r="0.43" fill="#000" fill-opacity="0.258"/><circle cx="48.34" cy="44.65" r="0.46" fill="#000" fill-opacity="0.283"/><circle cx="42.22" cy="49.97" r="0.46" fill="#000" fill-opacity="0.283"/><circle cx="45.42" cy="47.74" r="0.46" fill="#000" fill-opacity="0.283"/><circle cx="18.58" cy="47.76" r="0.47" fill="#000" fill-opacity="0.283"/><circle cx="35.44" cy="52.44" r="0.43" fill="#000" fill-opacity="0.260"/><circle cx="25.16" cy="51.68" r="0.44" fill="#000" fill-opacity="0.262"/><circle cx="52.83" cy="30.81" r="0.41" fill="#000" fill-opacity="0.238"/><circle cx="13.20" cy="41.19" r="0.50" fill="#000" fill-opacity="0.311"/><circle cx="50.80" cy="41.22" r="0.47" fill="#000" fill-opacity="0.287"/><circle cx="38.82" cy="51.87" r="0.44" fill="#000" fill-opacity="0.264"/><circle cx="52.55" cy="36.85" r="0.50" fill="#000" fill-opacity="0.315"/><circle cx="11.43" cy="36.95" r="0.47" fill="#000" fill-opacity="0.291"/><circle cx="42.14" cy="50.57" r="0.44" fill="#000" fill-opacity="0.267"/><circle cx="45.35" cy="48.43" r="0.44" fill="#000" fill-opacity="0.267"/><circle cx="48.32" cy="45.55" r="0.44" fill="#000" fill-opacity="0.268"/><circle cx="32.00" cy="53.27" r="0.41" fill="#000" fill-opacity="0.244"/><circle cx="53.27" cy="31.86" r="0.44" fill="#000" fill-opacity="0.269"/><circle cx="15.69" cy="45.69" r="0.48" fill="#000" fill-opacity="0.294"/><circle cx="10.67" cy="31.99" r="0.38" fill="#000" fill-opacity="0.221"/><circle cx="35.40" cy="53.06" r="0.41" fill="#000" fill-opacity="0.245"/><circle cx="21.90" cy="50.84" r="0.44" fill="#000" fill-opacity="0.271"/><circle cx="28.61" cy="53.18" r="0.41" fill="#000" fill-opacity="0.247"/><circle cx="38.75" cy="52.41" r="0.41" fill="#000" fill-opacity="0.248"/><circle cx="50.86" cy="42.41" r="0.45" fill="#000" fill-opacity="0.274"/><circle cx="42.05" cy="51.14" r="0.42" fill="#000" fill-opacity="0.250"/><circle cx="10.39" cy="32.75" r="0.42" fill="#000" fill-opacity="0.250"/><circle cx="45.25" cy="49.14" r="0.42" fill="#000" fill-opacity="0.251"/><circle cx="22.84" cy="12.36" r="0.32" fill="#000" fill-opacity="0.034"/><circle cx="52.79" cy="38.19" r="0.48" fill="#000" fill-opacity="0.301"/><circle cx="53.72" cy="33.09" r="0.48" fill="#000" fill-opacity="0.302"/><circle cx="11.19" cy="38.33" r="0.52" fill="#000" fill-opacity="0.327"/><circle cx="48.24" cy="46.52" r="0.42" fill="#000" fill-opacity="0.253"/><circle cx="13.14" cy="42.97" r="0.48" fill="#000" fill-opacity="0.304"/><circle cx="53.41" cy="27.75" r="0.39" fill="#000" fill-opacity="0.229"/><circle cx="52.82" cy="38.57" r="0.32" fill="#000" fill-opacity="0.034"/><circle cx="35.35" cy="53.57" r="0.39" fill="#000" fill-opacity="0.229"/><circle cx="32.00" cy="53.88" r="0.39" fill="#000" fill-opacity="0.230"/><circle cx="25.31" cy="52.84" r="0.42" fill="#000" fill-opacity="0.255"/><circle cx="18.81" cy="49.51" r="0.45" fill="#000" fill-opacity="0.281"/><circle cx="38.68" cy="52.89" r="0.39" fill="#000" fill-opacity="0.231"/><circle cx="10.12" cy="33.59" r="0.45" fill="#000" fill-opacity="0.281"/><circle cx="41.94" cy="51.69" r="0.39" fill="#000" fill-opacity="0.233"/><circle cx="45.12" cy="49.87" r="0.39" fill="#000" fill-opacity="0.236"/><circle cx="50.84" cy="43.70" r="0.43" fill="#000" fill-opacity="0.261"/><circle cx="28.68" cy="53.93" r="0.39" fill="#000" fill-opacity="0.236"/><circle cx="53.98" cy="28.81" r="0.43" fill="#000" fill-opacity="0.262"/><circle cx="54.14" cy="34.50" r="0.53" fill="#000" fill-opacity="0.339"/><circle cx="9.85" cy="34.54" r="0.49" fill="#000" fill-opacity="0.314"/><circle cx="52.95" cy="39.68" r="0.46" fill="#000" fill-opacity="0.289"/><circle cx="15.90" cy="47.50" r="0.46" fill="#000" fill-opacity="0.290"/><circle cx="48.09" cy="47.54" r="0.40" fill="#000" fill-opacity="0.240"/><circle cx="11.03" cy="39.85" r="0.50" fill="#000" fill-opacity="0.316"/><circle cx="22.17" cy="52.16" r="0.43" fill="#000" fill-opacity="0.266"/><circle cx="54.55" cy="30.06" r="0.47" fill="#000" fill-opacity="0.297"/><circle cx="9.61" cy="35.62" r="0.54" fill="#000" fill-opacity="0.349"/><circle cx="25.49" cy="53.72" r="0.40" fill="#000" fill-opacity="0.246"/><circle cx="13.25" cy="44.76" r="0.47" fill="#000" fill-opacity="0.298"/><circle cx="9.29" cy="30.45" r="0.40" fill="#000" fill-opacity="0.248"/><circle cx="50.72" cy="45.05" r="0.41" fill="#000" fill-opacity="0.249"/><circle cx="54.47" cy="36.10" r="0.51" fill="#000" fill-opacity="0.328"/><circle cx="19.17" cy="50.97" r="0.44" fill="#000" fill-opacity="0.277"/><circle cx="52.99" cy="41.27" r="0.44" fill="#000" fill-opacity="0.278"/><circle cx="9.03" cy="31.15" r="0.44" fill="#000" fill-opacity="0.279"/><circle cx="11.01" cy="41.48" r="0.48" fill="#000" fill-opacity="0.307"/><circle cx="9.42" cy="36.85" r="0.51" fill="#000" fill-opacity="0.335"/><circle cx="55.10" cy="31.53" r="0.51" fill="#000" fill-opacity="0.335"/><circle cx="54.42" cy="26.25" r="0.41" fill="#000" fill-opacity="0.257"/><circle cx="9.66" cy="38.05" r="0.32" fill="#000" fill-opacity="0.037"/><circle cx="8.79" cy="31.87" r="0.48" fill="#000" fill-opacity="0.312"/><circle cx="22.48" cy="53.18" r="0.41" fill="#000" fill-opacity="0.259"/><circle cx="16.28" cy="49.11" r="0.45" fill="#000" fill-opacity="0.286"/><circle cx="11.71" cy="20.37" r="0.32" fill="#000" fill-opacity="0.038"/><circle cx="54.67" cy="37.84" r="0.49" fill="#000" fill-opacity="0.318"/><circle cx="8.57" cy="32.65" r="0.52" fill="#000" fill-opacity="0.346"/><circle cx="13.55" cy="46.46" r="0.45" fill="#000" fill-opacity="0.292"/><circle cx="55.10" cy="27.54" r="0.46" fill="#000" fill-opacity="0.295"/><circle cx="9.31" cy="38.22" r="0.49" fill="#000" fill-opacity="0.322"/><circle cx="52.87" cy="42.92" r="0.42" fill="#000" fill-opacity="0.269"/><circle cx="55.56" cy="33.19" r="0.56" fill="#000" fill-opacity="0.378"/><circle cx="11.16" cy="43.15" r="0.46" fill="#000" fill-opacity="0.298"/><circle cx="19.61" cy="52.15" r="0.42" fill="#000" fill-opacity="0.272"/><circle cx="8.37" cy="33.51" r="0.57" fill="#000" fill-opacity="0.381"/><circle cx="46.39" cy="51.10" r="0.32" fill="#000" fill-opacity="0.039"/><circle cx="55.73" cy="29.04" r="0.50" fill="#000" fill-opacity="0.336"/><circle cx="16.80" cy="50.47" r="0.43" fill="#000" fill-opacity="0.281"/><circle cx="8.21" cy="34.47" r="0.54" fill="#000" fill-opacity="0.364"/><circle cx="54.68" cy="39.67" r="0.47" fill="#000" fill-opacity="0.309"/><circle cx="9.32" cy="39.70" r="0.47" fill="#000" fill-opacity="0.310"/><circle cx="8.21" cy="29.21" r="0.43" fill="#000" fill-opacity="0.282"/><circle cx="55.86" cy="35.02" r="0.54" fill="#000" fill-opacity="0.370"/><circle cx="14.04" cy="48.00" r="0.43" fill="#000" fill-opacity="0.286"/><circle cx="7.95" cy="29.98" r="0.47" fill="#000" fill-opacity="0.317"/><circle cx="11.51" cy="44.79" r="0.44" fill="#000" fill-opacity="0.290"/><circle cx="8.09" cy="35.56" r="0.51" fill="#000" fill-opacity="0.347"/><circle cx="55.23" cy="25.13" r="0.44" fill="#000" fill-opacity="0.293"/><circle cx="7.75" cy="30.72" r="0.52" fill="#000" fill-opacity="0.353"/><circle cx="56.26" cy="30.76" r="0.55" fill="#000" fill-opacity="0.382"/><circle cx="9.49" cy="41.25" r="0.44" fill="#000" fill-opacity="0.298"/><circle cx="33.08" cy="7.65" r="0.32" fill="#000" fill-opacity="0.041"/><circle cx="54.46" cy="41.50" r="0.45" fill="#000" fill-opacity="0.301"/><circle cx="8.05" cy="36.78" r="0.48" fill="#000" fill-opacity="0.331"/><circle cx="7.58" cy="31.45" r="0.56" fill="#000" fill-opacity="0.389"/><circle cx="55.95" cy="36.96" r="0.52" fill="#000" fill-opacity="0.362"/><circle cx="55.93" cy="26.66" r="0.49" fill="#000" fill-opacity="0.337"/><circle cx="7.45" cy="32.20" r="0.60" fill="#000" fill-opacity="0.426"/><circle cx="56.61" cy="32.66" r="0.61" fill="#000" fill-opacity="0.432"/><circle cx="8.13" cy="38.11" r="0.46" fill="#000" fill-opacity="0.316"/><circle cx="7.36" cy="33.00" r="0.57" fill="#000" fill-opacity="0.406"/><circle cx="46.82" cy="12.27" r="0.32" fill="#000" fill-opacity="0.043"/><circle cx="7.56" cy="28.21" r="0.46" fill="#000" fill-opacity="0.324"/><circle cx="55.77" cy="38.90" r="0.50" fill="#000" fill-opacity="0.355"/><circle cx="35.82" cy="56.46" r="0.32" fill="#000" fill-opacity="0.043"/><circle cx="56.50" cy="28.42" r="0.54" fill="#000" fill-opacity="0.386"/><circle cx="7.30" cy="33.87" r="0.54" fill="#000" fill-opacity="0.386"/><circle cx="55.33" cy="23.58" r="0.32" fill="#000" fill-opacity="0.044"/><circle cx="7.33" cy="29.16" r="0.51" fill="#000" fill-opacity="0.364"/><circle cx="55.53" cy="24.04" r="0.47" fill="#000" fill-opacity="0.334"/><circle cx="56.70" cy="34.66" r="0.59" fill="#000" fill-opacity="0.425"/><circle cx="7.30" cy="34.84" r="0.51" fill="#000" fill-opacity="0.367"/><circle cx="7.18" cy="30.04" r="0.56" fill="#000" fill-opacity="0.404"/><circle cx="56.86" cy="30.35" r="0.60" fill="#000" fill-opacity="0.438"/><circle cx="55.33" cy="40.77" r="0.48" fill="#000" fill-opacity="0.347"/><circle cx="7.38" cy="35.91" r="0.48" fill="#000" fill-opacity="0.348"/><circle cx="7.09" cy="30.85" r="0.60" fill="#000" fill-opacity="0.444"/><circle cx="56.16" cy="25.78" r="0.53" fill="#000" fill-opacity="0.385"/><circle cx="56.51" cy="36.67" r="0.57" fill="#000" fill-opacity="0.419"/><circle cx="7.05" cy="31.61" r="0.65" fill="#000" fill-opacity="0.485"/><circle cx="7.04" cy="32.36" r="0.62" fill="#000" fill-opacity="0.463"/><circle cx="56.95" cy="32.39" r="0.66" fill="#000" fill-opacity="0.495"/><circle cx="12.79" cy="47.93" r="0.32" fill="#000" fill-opacity="0.047"/><circle cx="7.52" cy="27.12" r="0.50" fill="#000" fill-opacity="0.369"/><circle cx="55.15" cy="22.71" r="0.50" fill="#000" fill-opacity="0.375"/><circle cx="56.57" cy="27.70" r="0.58" fill="#000" fill-opacity="0.440"/><circle cx="7.08" cy="33.12" r="0.58" fill="#000" fill-opacity="0.440"/><circle cx="56.05" cy="38.59" r="0.54" fill="#000" fill-opacity="0.411"/><circle cx="7.36" cy="28.34" r="0.55" fill="#000" fill-opacity="0.415"/><circle cx="7.14" cy="30.42" r="0.32" fill="#000" fill-opacity="0.048"/><circle cx="7.17" cy="33.91" r="0.55" fill="#000" fill-opacity="0.418"/><circle cx="56.75" cy="34.43" r="0.64" fill="#000" fill-opacity="0.489"/><circle cx="56.52" cy="36.11" r="0.32" fill="#000" fill-opacity="0.048"/><circle cx="23.60" cy="55.39" r="0.32" fill="#000" fill-opacity="0.048"/><circle cx="7.31" cy="34.77" r="0.51" fill="#000" fill-opacity="0.395"/><circle cx="7.30" cy="29.45" r="0.60" fill="#000" fill-opacity="0.461"/><circle cx="55.67" cy="24.54" r="0.56" fill="#000" fill-opacity="0.431"/><circle cx="56.71" cy="29.74" r="0.64" fill="#000" fill-opacity="0.498"/><circle cx="55.35" cy="40.34" r="0.52" fill="#000" fill-opacity="0.400"/><circle cx="16.12" cy="12.97" r="0.32" fill="#000" fill-opacity="0.049"/><circle cx="7.32" cy="30.45" r="0.65" fill="#000" fill-opacity="0.507"/><circle cx="8.17" cy="25.54" r="0.52" fill="#000" fill-opacity="0.411"/><circle cx="54.10" cy="21.05" r="0.52" fill="#000" fill-opacity="0.413"/><circle cx="56.27" cy="36.38" r="0.61" fill="#000" fill-opacity="0.481"/><circle cx="7.39" cy="31.34" r="0.70" fill="#000" fill-opacity="0.552"/><circle cx="56.55" cy="31.80" r="0.71" fill="#000" fill-opacity="0.558"/><circle cx="55.92" cy="26.51" r="0.62" fill="#000" fill-opacity="0.490"/><circle cx="7.51" cy="32.16" r="0.67" fill="#000" fill-opacity="0.529"/><circle cx="8.05" cy="27.04" r="0.58" fill="#000" fill-opacity="0.463"/><circle cx="50.41" cy="48.04" r="0.32" fill="#000" fill-opacity="0.051"/><circle cx="55.58" cy="38.15" r="0.58" fill="#000" fill-opacity="0.469"/><circle cx="7.66" cy="32.91" r="0.63" fill="#000" fill-opacity="0.504"/><circle cx="54.52" cy="22.85" r="0.59" fill="#000" fill-opacity="0.472"/><circle cx="9.44" cy="23.12" r="0.54" fill="#000" fill-opacity="0.441"/><circle cx="7.84" cy="33.63" r="0.59" fill="#000" fill-opacity="0.478"/><circle cx="56.12" cy="33.77" r="0.68" fill="#000" fill-opacity="0.549"/><circle cx="8.09" cy="28.44" r="0.64" fill="#000" fill-opacity="0.515"/><circle cx="55.90" cy="28.53" r="0.68" fill="#000" fill-opacity="0.551"/><circle cx="52.49" cy="19.22" r="0.55" fill="#000" fill-opacity="0.447"/><circle cx="8.06" cy="34.36" r="0.55" fill="#000" fill-opacity="0.451"/><circle cx="54.75" cy="39.71" r="0.55" fill="#000" fill-opacity="0.453"/><circle cx="19.87" cy="11.32" r="0.55" fill="#000" fill-opacity="0.455"/><circle cx="16.83" cy="13.46" r="0.55" fill="#000" fill-opacity="0.456"/><circle cx="11.33" cy="19.92" r="0.55" fill="#000" fill-opacity="0.457"/><circle cx="37.69" cy="8.78" r="0.32" fill="#000" fill-opacity="0.053"/><circle cx="13.87" cy="16.46" r="0.55" fill="#000" fill-opacity="0.460"/><circle cx="8.23" cy="29.70" r="0.69" fill="#000" fill-opacity="0.566"/><circle cx="54.70" cy="24.73" r="0.65" fill="#000" fill-opacity="0.533"/><circle cx="9.30" cy="24.86" r="0.60" fill="#000" fill-opacity="0.499"/><circle cx="22.80" cy="10.05" r="0.56" fill="#000" fill-opacity="0.463"/><circle cx="55.50" cy="35.57" r="0.65" fill="#000" fill-opacity="0.536"/><circle cx="55.63" cy="30.49" r="0.75" fill="#000" fill-opacity="0.612"/><circle cx="52.84" cy="20.86" r="0.61" fill="#000" fill-opacity="0.506"/><circle cx="8.44" cy="30.81" r="0.75" fill="#000" fill-opacity="0.616"/><circle cx="50.43" cy="17.47" r="0.56" fill="#000" fill-opacity="0.477"/><circle cx="19.42" cy="12.30" r="0.61" fill="#000" fill-opacity="0.517"/><circle cx="25.69" cy="9.54" r="0.57" fill="#000" fill-opacity="0.482"/><circle cx="54.75" cy="37.16" r="0.62" fill="#000" fill-opacity="0.519"/><circle cx="11.06" cy="21.73" r="0.62" fill="#000" fill-opacity="0.519"/><circle cx="8.69" cy="31.79" r="0.71" fill="#000" fill-opacity="0.592"/><circle cx="16.32" cy="14.77" r="0.62" fill="#000" fill-opacity="0.520"/><circle cx="9.36" cy="26.54" r="0.66" fill="#000" fill-opacity="0.557"/><circle cx="54.64" cy="26.60" r="0.71" fill="#000" fill-opacity="0.594"/><circle cx="22.48" cy="10.80" r="0.62" fill="#000" fill-opacity="0.522"/><circle cx="13.43" cy="18.11" r="0.62" fill="#000" fill-opacity="0.524"/><circle cx="55.15" cy="32.31" r="0.72" fill="#000" fill-opacity="0.599"/><circle cx="8.96" cy="32.64" r="0.67" fill="#000" fill-opacity="0.566"/><circle cx="52.99" cy="22.52" r="0.67" fill="#000" fill-opacity="0.567"/><circle cx="53.96" cy="38.51" r="0.58" fill="#000" fill-opacity="0.498"/><circle cx="50.70" cy="18.86" r="0.63" fill="#000" fill-opacity="0.536"/><circle cx="9.23" cy="33.41" r="0.63" fill="#000" fill-opacity="0.538"/><circle cx="9.56" cy="28.10" r="0.72" fill="#000" fill-opacity="0.613"/><circle cx="25.52" cy="10.17" r="0.63" fill="#000" fill-opacity="0.539"/><circle cx="54.39" cy="28.38" r="0.78" fill="#000" fill-opacity="0.654"/><circle cx="48.00" cy="15.99" r="0.58" fill="#000" fill-opacity="0.506"/><circle cx="54.55" cy="33.94" r="0.68" fill="#000" fill-opacity="0.581"/><circle cx="11.01" cy="23.60" r="0.68" fill="#000" fill-opacity="0.582"/><circle cx="9.52" cy="34.11" r="0.58" fill="#000" fill-opacity="0.508"/><circle cx="19.02" cy="13.56" r="0.68" fill="#000" fill-opacity="0.584"/><circle cx="28.72" cy="9.71" r="0.58" fill="#000" fill-opacity="0.510"/><circle cx="22.18" cy="11.80" r="0.68" fill="#000" fill-opacity="0.587"/><circle cx="51.54" cy="20.93" r="0.32" fill="#000" fill-opacity="0.057"/><circle cx="15.92" cy="16.36" r="0.68" fill="#000" fill-opacity="0.588"/><circle cx="52.97" cy="24.15" r="0.73" fill="#000" fill-opacity="0.626"/><circle cx="13.18" cy="19.95" r="0.69" fill="#000" fill-opacity="0.590"/><circle cx="9.86" cy="29.50" r="0.78" fill="#000" fill-opacity="0.668"/><circle cx="34.97" cy="54.06" r="0.32" fill="#000" fill-opacity="0.057"/><circle cx="50.84" cy="20.25" r="0.69" fill="#000" fill-opacity="0.595"/><circle cx="53.90" cy="35.35" r="0.64" fill="#000" fill-opacity="0.559"/><circle cx="12.02" cy="22.51" r="0.32" fill="#000" fill-opacity="0.057"/><circle cx="54.00" cy="30.00" r="0.74" fill="#000" fill-opacity="0.636"/><circle cx="25.34" cy="11.02" r="0.69" fill="#000" fill-opacity="0.600"/><circle cx="48.20" cy="17.13" r="0.64" fill="#000" fill-opacity="0.563"/><circle cx="28.66" cy="10.30" r="0.64" fill="#000" fill-opacity="0.564"/><circle cx="11.86" cy="40.53" r="0.32" fill="#000" fill-opacity="0.058"/><circle cx="11.16" cy="25.43" r="0.74" fill="#000" fill-opacity="0.643"/><circle cx="10.22" cy="30.73" r="0.75" fill="#000" fill-opacity="0.644"/><circle cx="52.81" cy="25.67" r="0.80" fill="#000" fill-opacity="0.684"/><circle cx="53.24" cy="36.55" r="0.60" fill="#000" fill-opacity="0.533"/><circle cx="45.25" cy="14.82" r="0.60" fill="#000" fill-opacity="0.534"/><circle cx="50.86" cy="21.58" r="0.75" fill="#000" fill-opacity="0.652"/><circle cx="53.54" cy="31.44" r="0.70" fill="#000" fill-opacity="0.614"/><circle cx="32.00" cy="10.50" r="0.60" fill="#000" fill-opacity="0.538"/><circle cx="18.71" cy="15.12" r="0.75" fill="#000" fill-opacity="0.654"/><circle cx="21.91" cy="13.09" r="0.75" fill="#000" fill-opacity="0.655"/><circle cx="10.59" cy="31.79" r="0.70" fill="#000" fill-opacity="0.618"/><circle cx="13.15" cy="21.90" r="0.75" fill="#000" fill-opacity="0.657"/><circle cx="15.70" cy="18.20" r="0.75" fill="#000" fill-opacity="0.658"/><circle cx="48.30" cy="18.24" r="0.70" fill="#000" fill-opacity="0.620"/><circle cx="24.83" cy="11.98" r="0.32" fill="#000" fill-opacity="0.059"/><circle cx="28.59" cy="11.06" r="0.71" fill="#000" fill-opacity="0.623"/><circle cx="52.57" cy="27.05" r="0.76" fill="#000" fill-opacity="0.663"/><circle cx="11.45" cy="27.15" r="0.81" fill="#000" fill-opacity="0.703"/><circle cx="53.05" cy="32.68" r="0.66" fill="#000" fill-opacity="0.588"/><circle cx="45.37" cy="15.73" r="0.66" fill="#000" fill-opacity="0.588"/><circle cx="10.96" cy="32.71" r="0.66" fill="#000" fill-opacity="0.588"/><circle cx="25.18" cy="12.11" r="0.76" fill="#000" fill-opacity="0.667"/><circle cx="32.00" cy="11.07" r="0.66" fill="#000" fill-opacity="0.591"/><circle cx="50.80" cy="22.81" r="0.81" fill="#000" fill-opacity="0.708"/><circle cx="42.19" cy="13.83" r="0.61" fill="#000" fill-opacity="0.555"/><circle cx="11.32" cy="33.50" r="0.61" fill="#000" fill-opacity="0.557"/><circle cx="48.34" cy="19.28" r="0.76" fill="#000" fill-opacity="0.675"/><circle cx="35.45" cy="11.64" r="0.61" fill="#000" fill-opacity="0.559"/><circle cx="52.57" cy="33.74" r="0.61" fill="#000" fill-opacity="0.559"/><circle cx="52.28" cy="28.27" r="0.72" fill="#000" fill-opacity="0.638"/><circle cx="45.45" cy="16.60" r="0.72" fill="#000" fill-opacity="0.642"/><circle cx="11.84" cy="28.70" r="0.77" fill="#000" fill-opacity="0.682"/><circle cx="38.89" cy="12.80" r="0.62" fill="#000" fill-opacity="0.565"/><circle cx="13.31" cy="23.86" r="0.82" fill="#000" fill-opacity="0.722"/><circle cx="50.68" cy="23.92" r="0.77" fill="#000" fill-opacity="0.684"/><circle cx="28.53" cy="12.03" r="0.77" fill="#000" fill-opacity="0.686"/><circle cx="42.27" cy="14.56" r="0.67" fill="#000" fill-opacity="0.607"/><circle cx="32.00" cy="11.76" r="0.72" fill="#000" fill-opacity="0.647"/><circle cx="18.53" cy="16.96" r="0.82" fill="#000" fill-opacity="0.727"/><circle cx="15.66" cy="20.20" r="0.82" fill="#000" fill-opacity="0.728"/><circle cx="51.97" cy="29.34" r="0.67" fill="#000" fill-opacity="0.610"/><circle cx="21.72" cy="14.69" r="0.82" fill="#000" fill-opacity="0.728"/><circle cx="48.33" cy="20.24" r="0.83" fill="#000" fill-opacity="0.728"/><circle cx="35.48" cy="12.21" r="0.67" fill="#000" fill-opacity="0.611"/><circle cx="45.48" cy="17.42" r="0.78" fill="#000" fill-opacity="0.695"/><circle cx="38.94" cy="13.42" r="0.67" fill="#000" fill-opacity="0.616"/><circle cx="50.53" cy="24.92" r="0.73" fill="#000" fill-opacity="0.656"/><circle cx="12.27" cy="30.06" r="0.73" fill="#000" fill-opacity="0.656"/><circle cx="25.05" cy="13.50" r="0.83" fill="#000" fill-opacity="0.737"/><circle cx="51.65" cy="30.26" r="0.62" fill="#000" fill-opacity="0.579"/><circle cx="42.32" cy="15.27" r="0.73" fill="#000" fill-opacity="0.660"/><circle cx="48.29" cy="21.13" r="0.78" fill="#000" fill-opacity="0.701"/><circle cx="35.50" cy="12.85" r="0.73" fill="#000" fill-opacity="0.664"/><circle cx="13.63" cy="25.73" r="0.78" fill="#000" fill-opacity="0.705"/><circle cx="32.00" cy="12.63" r="0.78" fill="#000" fill-opacity="0.706"/><circle cx="50.36" cy="25.82" r="0.68" fill="#000" fill-opacity="0.626"/><circle cx="12.71" cy="31.23" r="0.68" fill="#000" fill-opacity="0.627"/><circle cx="45.49" cy="18.21" r="0.84" fill="#000" fill-opacity="0.748"/><circle cx="38.98" cy="14.06" r="0.73" fill="#000" fill-opacity="0.668"/><circle cx="42.35" cy="15.97" r="0.79" fill="#000" fill-opacity="0.712"/><circle cx="48.22" cy="21.97" r="0.74" fill="#000" fill-opacity="0.672"/><circle cx="28.48" cy="13.26" r="0.84" fill="#000" fill-opacity="0.752"/><circle cx="50.92" cy="33.57" r="0.32" fill="#000" fill-opacity="0.062"/><circle cx="50.17" cy="26.65" r="0.63" fill="#000" fill-opacity="0.594"/><circle cx="15.81" cy="22.26" r="0.79" fill="#000" fill-opacity="0.716"/><circle cx="13.14" cy="32.24" r="0.63" fill="#000" fill-opacity="0.595"/><circle cx="23.38" cy="48.75" r="0.32" fill="#000" fill-opacity="0.062"/><circle cx="45.48" cy="18.98" r="0.79" fill="#000" fill-opacity="0.719"/><circle cx="18.52" cy="19.00" r="0.79" fill="#000" fill-opacity="0.719"/><circle cx="35.53" cy="13.61" r="0.79" fill="#000" fill-opacity="0.719"/><circle cx="39.01" cy="14.75" r="0.79" fill="#000" fill-opacity="0.721"/><circle cx="21.63" cy="16.58" r="0.79" fill="#000" fill-opacity="0.722"/><circle cx="48.13" cy="22.77" r="0.69" fill="#000" fill-opacity="0.641"/><circle cx="14.04" cy="27.44" r="0.74" fill="#000" fill-opacity="0.682"/><circle cx="42.37" cy="16.70" r="0.85" fill="#000" fill-opacity="0.764"/><circle cx="40.78" cy="15.93" r="0.32" fill="#000" fill-opacity="0.063"/><circle cx="32.00" cy="13.69" r="0.85" fill="#000" fill-opacity="0.768"/><circle cx="24.98" cy="15.20" r="0.80" fill="#000" fill-opacity="0.729"/><circle cx="45.45" cy="19.76" r="0.75" fill="#000" fill-opacity="0.689"/><circle cx="48.01" cy="23.57" r="0.64" fill="#000" fill-opacity="0.609"/><circle cx="39.03" cy="15.52" r="0.86" fill="#000" fill-opacity="0.775"/><circle cx="42.37" cy="17.47" r="0.80" fill="#000" fill-opacity="0.736"/><circle cx="35.54" cy="14.51" r="0.86" fill="#000" fill-opacity="0.777"/><circle cx="14.49" cy="28.96" r="0.70" fill="#000" fill-opacity="0.655"/><circle cx="16.11" cy="24.27" r="0.75" fill="#000" fill-opacity="0.698"/><circle cx="43.88" cy="45.03" r="0.32" fill="#000" fill-opacity="0.063"/><circle cx="28.45" cy="14.76" r="0.81" fill="#000" fill-opacity="0.740"/><circle cx="45.39" cy="20.58" r="0.70" fill="#000" fill-opacity="0.658"/><circle cx="18.66" cy="21.15" r="0.76" fill="#000" fill-opacity="0.706"/><circle cx="42.35" cy="18.32" r="0.76" fill="#000" fill-opacity="0.707"/><circle cx="14.95" cy="30.28" r="0.65" fill="#000" fill-opacity="0.624"/><circle cx="39.03" cy="16.41" r="0.81" fill="#000" fill-opacity="0.749"/><circle cx="32.00" cy="14.99" r="0.81" fill="#000" fill-opacity="0.750"/><circle cx="45.31" cy="21.46" r="0.65" fill="#000" fill-opacity="0.627"/><circle cx="21.67" cy="18.68" r="0.76" fill="#000" fill-opacity="0.711"/><circle cx="35.55" cy="15.59" r="0.81" fill="#000" fill-opacity="0.754"/><circle cx="16.50" cy="26.14" r="0.71" fill="#000" fill-opacity="0.674"/><circle cx="24.98" cy="17.17" r="0.76" fill="#000" fill-opacity="0.718"/><circle cx="42.30" cy="19.27" r="0.71" fill="#000" fill-opacity="0.677"/><circle cx="39.02" cy="17.43" r="0.76" fill="#000" fill-opacity="0.722"/><circle cx="28.45" cy="16.54" r="0.77" fill="#000" fill-opacity="0.727"/><circle cx="18.93" cy="23.27" r="0.71" fill="#000" fill-opacity="0.687"/><circle cx="16.94" cy="27.82" r="0.66" fill="#000" fill-opacity="0.646"/><circle cx="35.55" cy="16.87" r="0.77" fill="#000" fill-opacity="0.731"/><circle cx="42.22" cy="20.36" r="0.66" fill="#000" fill-opacity="0.648"/><circle cx="32.00" cy="16.53" r="0.77" fill="#000" fill-opacity="0.732"/><circle cx="38.98" cy="18.63" r="0.72" fill="#000" fill-opacity="0.695"/><circle cx="21.83" cy="20.91" r="0.72" fill="#000" fill-opacity="0.696"/><circle cx="25.06" cy="19.35" r="0.72" fill="#000" fill-opacity="0.703"/><circle cx="19.30" cy="25.28" r="0.67" fill="#000" fill-opacity="0.662"/><circle cx="35.52" cy="18.36" r="0.72" fill="#000" fill-opacity="0.708"/><circle cx="18.05" cy="32.21" r="0.32" fill="#000" fill-opacity="0.066"/><circle cx="28.48" cy="18.56" r="0.73" fill="#000" fill-opacity="0.710"/><circle cx="38.91" cy="20.00" r="0.67" fill="#000" fill-opacity="0.668"/><circle cx="32.00" cy="18.32" r="0.73" fill="#000" fill-opacity="0.712"/><circle cx="22.08" cy="23.12" r="0.67" fill="#000" fill-opacity="0.673"/><circle cx="35.47" cy="20.05" r="0.68" fill="#000" fill-opacity="0.682"/><circle cx="25.21" cy="21.62" r="0.68" fill="#000" fill-opacity="0.683"/><circle cx="28.55" cy="20.75" r="0.68" fill="#000" fill-opacity="0.689"/><circle cx="32.00" cy="20.30" r="0.68" fill="#000" fill-opacity="0.689"/><circle cx="27.12" cy="21.68" r="0.32" fill="#000" fill-opacity="0.068"/><circle cx="30.85" cy="39.99" r="0.32" fill="#000" fill-opacity="0.069"/><circle cx="38.86" cy="29.05" r="0.32" fill="#000" fill-opacity="0.069"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/Contents.json
new file mode 100644
index 0000000000..525401af9b
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-speaking-inline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/orb-speaking-inline.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/orb-speaking-inline.svg
new file mode 100644
index 0000000000..6b3f646377
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-speaking-inline.imageset/orb-speaking-inline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><circle cx="7.71" cy="12.82" r="0.30" fill="#000" fill-opacity="0.141"/><circle cx="10.00" cy="13.92" r="0.30" fill="#000" fill-opacity="0.145"/><circle cx="7.65" cy="13.52" r="0.30" fill="#000" fill-opacity="0.177"/><circle cx="10.00" cy="14.58" r="0.30" fill="#000" fill-opacity="0.184"/><circle cx="7.60" cy="14.22" r="0.30" fill="#000" fill-opacity="0.218"/><circle cx="5.64" cy="12.15" r="0.30" fill="#000" fill-opacity="0.162"/><circle cx="10.63" cy="5.08" r="0.30" fill="#000" fill-opacity="0.028"/><circle cx="10.00" cy="15.17" r="0.30" fill="#000" fill-opacity="0.226"/><circle cx="5.54" cy="12.69" r="0.30" fill="#000" fill-opacity="0.198"/><circle cx="12.41" cy="14.76" r="0.30" fill="#000" fill-opacity="0.173"/><circle cx="7.59" cy="14.89" r="0.30" fill="#000" fill-opacity="0.264"/><circle cx="5.46" cy="13.28" r="0.30" fill="#000" fill-opacity="0.239"/><circle cx="10.00" cy="15.68" r="0.30" fill="#000" fill-opacity="0.271"/><circle cx="12.41" cy="15.19" r="0.30" fill="#000" fill-opacity="0.214"/><circle cx="8.26" cy="15.53" r="0.30" fill="#000" fill-opacity="0.030"/><circle cx="14.57" cy="13.77" r="0.30" fill="#000" fill-opacity="0.190"/><circle cx="7.60" cy="15.49" r="0.30" fill="#000" fill-opacity="0.254"/><circle cx="5.42" cy="13.90" r="0.30" fill="#000" fill-opacity="0.285"/><circle cx="12.39" cy="15.55" r="0.30" fill="#000" fill-opacity="0.256"/><circle cx="10.00" cy="16.10" r="0.30" fill="#000" fill-opacity="0.258"/><circle cx="14.58" cy="14.05" r="0.30" fill="#000" fill-opacity="0.228"/><circle cx="16.04" cy="11.18" r="0.30" fill="#000" fill-opacity="0.198"/><circle cx="3.96" cy="11.19" r="0.30" fill="#000" fill-opacity="0.198"/><circle cx="16.10" cy="11.43" r="0.30" fill="#000" fill-opacity="0.234"/><circle cx="14.58" cy="14.29" r="0.30" fill="#000" fill-opacity="0.266"/><circle cx="12.37" cy="15.84" r="0.31" fill="#000" fill-opacity="0.299"/><circle cx="3.88" cy="11.52" r="0.30" fill="#000" fill-opacity="0.236"/><circle cx="16.10" cy="11.65" r="0.30" fill="#000" fill-opacity="0.032"/><circle cx="16.17" cy="11.71" r="0.30" fill="#000" fill-opacity="0.272"/><circle cx="5.42" cy="14.51" r="0.30" fill="#000" fill-opacity="0.273"/><circle cx="10.00" cy="16.43" r="0.30" fill="#000" fill-opacity="0.242"/><circle cx="14.58" cy="14.52" r="0.31" fill="#000" fill-opacity="0.305"/><circle cx="7.64" cy="16.00" r="0.30" fill="#000" fill-opacity="0.242"/><circle cx="3.80" cy="11.90" r="0.30" fill="#000" fill-opacity="0.276"/><circle cx="12.35" cy="16.08" r="0.30" fill="#000" fill-opacity="0.278"/><circle cx="16.22" cy="12.01" r="0.31" fill="#000" fill-opacity="0.311"/><circle cx="14.56" cy="14.74" r="0.30" fill="#000" fill-opacity="0.281"/><circle cx="3.73" cy="12.32" r="0.32" fill="#000" fill-opacity="0.320"/><circle cx="12.32" cy="16.28" r="0.30" fill="#000" fill-opacity="0.255"/><circle cx="10.00" cy="16.70" r="0.30" fill="#000" fill-opacity="0.222"/><circle cx="16.27" cy="12.36" r="0.30" fill="#000" fill-opacity="0.288"/><circle cx="14.54" cy="14.96" r="0.30" fill="#000" fill-opacity="0.257"/><circle cx="5.48" cy="15.08" r="0.30" fill="#000" fill-opacity="0.261"/><circle cx="7.70" cy="16.41" r="0.30" fill="#000" fill-opacity="0.229"/><circle cx="12.30" cy="16.45" r="0.30" fill="#000" fill-opacity="0.230"/><circle cx="14.51" cy="15.18" r="0.30" fill="#000" fill-opacity="0.232"/><circle cx="16.82" cy="9.16" r="0.30" fill="#000" fill-opacity="0.232"/><circle cx="16.30" cy="12.74" r="0.30" fill="#000" fill-opacity="0.266"/><circle cx="3.69" cy="12.79" r="0.30" fill="#000" fill-opacity="0.301"/><circle cx="16.97" cy="9.50" r="0.30" fill="#000" fill-opacity="0.274"/><circle cx="16.31" cy="13.15" r="0.30" fill="#000" fill-opacity="0.244"/><circle cx="3.70" cy="13.29" r="0.30" fill="#000" fill-opacity="0.282"/><circle cx="5.58" cy="15.58" r="0.30" fill="#000" fill-opacity="0.248"/><circle cx="17.12" cy="9.90" r="0.31" fill="#000" fill-opacity="0.318"/><circle cx="2.83" cy="10.02" r="0.30" fill="#000" fill-opacity="0.252"/><circle cx="2.77" cy="10.25" r="0.30" fill="#000" fill-opacity="0.293"/><circle cx="17.26" cy="10.35" r="0.35" fill="#000" fill-opacity="0.367"/><circle cx="2.71" cy="10.49" r="0.32" fill="#000" fill-opacity="0.335"/><circle cx="3.75" cy="13.79" r="0.30" fill="#000" fill-opacity="0.264"/><circle cx="2.66" cy="10.74" r="0.35" fill="#000" fill-opacity="0.379"/><circle cx="17.36" cy="10.87" r="0.33" fill="#000" fill-opacity="0.347"/><circle cx="2.62" cy="11.03" r="0.33" fill="#000" fill-opacity="0.352"/><circle cx="2.59" cy="11.34" r="0.30" fill="#000" fill-opacity="0.325"/><circle cx="17.42" cy="11.43" r="0.31" fill="#000" fill-opacity="0.328"/><circle cx="2.58" cy="11.70" r="0.30" fill="#000" fill-opacity="0.299"/><circle cx="2.38" cy="10.53" r="0.30" fill="#000" fill-opacity="0.041"/><circle cx="17.43" cy="8.22" r="0.30" fill="#000" fill-opacity="0.305"/><circle cx="17.40" cy="12.02" r="0.30" fill="#000" fill-opacity="0.309"/><circle cx="17.61" cy="8.73" r="0.32" fill="#000" fill-opacity="0.360"/><circle cx="2.27" cy="9.24" r="0.30" fill="#000" fill-opacity="0.338"/><circle cx="17.74" cy="9.30" r="0.36" fill="#000" fill-opacity="0.421"/><circle cx="2.22" cy="9.54" r="0.34" fill="#000" fill-opacity="0.389"/><circle cx="2.20" cy="9.82" r="0.37" fill="#000" fill-opacity="0.441"/><circle cx="17.80" cy="9.92" r="0.41" fill="#000" fill-opacity="0.487"/><circle cx="2.20" cy="10.08" r="0.41" fill="#000" fill-opacity="0.493"/><circle cx="2.21" cy="10.32" r="0.38" fill="#000" fill-opacity="0.460"/><circle cx="2.23" cy="10.55" r="0.35" fill="#000" fill-opacity="0.427"/><circle cx="17.76" cy="10.56" r="0.39" fill="#000" fill-opacity="0.470"/><circle cx="2.27" cy="10.78" r="0.32" fill="#000" fill-opacity="0.392"/><circle cx="17.30" cy="7.39" r="0.32" fill="#000" fill-opacity="0.399"/><circle cx="17.64" cy="11.18" r="0.36" fill="#000" fill-opacity="0.451"/><circle cx="17.40" cy="7.99" r="0.37" fill="#000" fill-opacity="0.469"/><circle cx="17.44" cy="11.76" r="0.34" fill="#000" fill-opacity="0.428"/><circle cx="2.58" cy="8.28" r="0.34" fill="#000" fill-opacity="0.435"/><circle cx="17.41" cy="8.63" r="0.42" fill="#000" fill-opacity="0.541"/><circle cx="13.78" cy="3.48" r="0.30" fill="#000" fill-opacity="0.052"/><circle cx="2.60" cy="8.78" r="0.38" fill="#000" fill-opacity="0.501"/><circle cx="2.65" cy="9.24" r="0.43" fill="#000" fill-opacity="0.566"/><circle cx="17.34" cy="9.26" r="0.47" fill="#000" fill-opacity="0.615"/><circle cx="5.72" cy="4.01" r="0.35" fill="#000" fill-opacity="0.474"/><circle cx="16.24" cy="6.16" r="0.36" fill="#000" fill-opacity="0.478"/><circle cx="3.75" cy="6.17" r="0.36" fill="#000" fill-opacity="0.478"/><circle cx="2.74" cy="9.65" r="0.48" fill="#000" fill-opacity="0.631"/><circle cx="17.20" cy="9.85" r="0.44" fill="#000" fill-opacity="0.590"/><circle cx="2.84" cy="10.00" r="0.44" fill="#000" fill-opacity="0.596"/><circle cx="7.78" cy="3.19" r="0.36" fill="#000" fill-opacity="0.498"/><circle cx="16.30" cy="6.68" r="0.40" fill="#000" fill-opacity="0.550"/><circle cx="5.59" cy="4.41" r="0.40" fill="#000" fill-opacity="0.551"/><circle cx="3.69" cy="6.76" r="0.41" fill="#000" fill-opacity="0.554"/><circle cx="2.95" cy="10.31" r="0.41" fill="#000" fill-opacity="0.558"/><circle cx="17.02" cy="10.39" r="0.41" fill="#000" fill-opacity="0.560"/><circle cx="3.06" cy="10.57" r="0.37" fill="#000" fill-opacity="0.517"/><circle cx="7.73" cy="3.44" r="0.41" fill="#000" fill-opacity="0.569"/><circle cx="16.31" cy="7.19" r="0.45" fill="#000" fill-opacity="0.623"/><circle cx="16.81" cy="10.86" r="0.37" fill="#000" fill-opacity="0.526"/><circle cx="3.70" cy="7.38" r="0.46" fill="#000" fill-opacity="0.632"/><circle cx="5.48" cy="4.90" r="0.46" fill="#000" fill-opacity="0.632"/><circle cx="16.27" cy="7.68" r="0.50" fill="#000" fill-opacity="0.695"/><circle cx="7.67" cy="3.76" r="0.46" fill="#000" fill-opacity="0.646"/><circle cx="14.55" cy="5.14" r="0.38" fill="#000" fill-opacity="0.544"/><circle cx="8.42" cy="16.39" r="0.30" fill="#000" fill-opacity="0.059"/><circle cx="3.78" cy="7.99" r="0.51" fill="#000" fill-opacity="0.708"/><circle cx="16.20" cy="8.12" r="0.47" fill="#000" fill-opacity="0.661"/><circle cx="5.42" cy="5.48" r="0.51" fill="#000" fill-opacity="0.717"/><circle cx="14.58" cy="5.48" r="0.43" fill="#000" fill-opacity="0.613"/><circle cx="10.00" cy="3.57" r="0.39" fill="#000" fill-opacity="0.561"/><circle cx="7.63" cy="4.16" r="0.52" fill="#000" fill-opacity="0.727"/><circle cx="16.11" cy="8.51" r="0.43" fill="#000" fill-opacity="0.623"/><circle cx="3.90" cy="8.56" r="0.48" fill="#000" fill-opacity="0.677"/><circle cx="10.00" cy="3.77" r="0.43" fill="#000" fill-opacity="0.628"/><circle cx="14.58" cy="5.80" r="0.48" fill="#000" fill-opacity="0.681"/><circle cx="16.02" cy="8.86" r="0.39" fill="#000" fill-opacity="0.581"/><circle cx="12.39" cy="4.44" r="0.39" fill="#000" fill-opacity="0.586"/><circle cx="4.04" cy="9.07" r="0.44" fill="#000" fill-opacity="0.641"/><circle cx="14.58" cy="6.10" r="0.53" fill="#000" fill-opacity="0.748"/><circle cx="5.42" cy="6.12" r="0.48" fill="#000" fill-opacity="0.696"/><circle cx="10.00" cy="4.02" r="0.48" fill="#000" fill-opacity="0.698"/><circle cx="12.40" cy="4.65" r="0.44" fill="#000" fill-opacity="0.651"/><circle cx="7.60" cy="4.66" r="0.49" fill="#000" fill-opacity="0.705"/><circle cx="14.57" cy="6.38" r="0.49" fill="#000" fill-opacity="0.707"/><circle cx="4.20" cy="9.52" r="0.40" fill="#000" fill-opacity="0.600"/><circle cx="10.00" cy="4.32" r="0.54" fill="#000" fill-opacity="0.771"/><circle cx="12.41" cy="4.87" r="0.49" fill="#000" fill-opacity="0.717"/><circle cx="5.51" cy="6.56" r="0.30" fill="#000" fill-opacity="0.063"/><circle cx="14.55" cy="6.64" r="0.45" fill="#000" fill-opacity="0.663"/><circle cx="5.47" cy="6.79" r="0.45" fill="#000" fill-opacity="0.669"/><circle cx="14.52" cy="6.89" r="0.40" fill="#000" fill-opacity="0.618"/><circle cx="12.41" cy="5.11" r="0.54" fill="#000" fill-opacity="0.784"/><circle cx="7.59" cy="5.24" r="0.45" fill="#000" fill-opacity="0.681"/><circle cx="10.00" cy="4.69" r="0.50" fill="#000" fill-opacity="0.737"/><circle cx="12.41" cy="5.36" r="0.50" fill="#000" fill-opacity="0.741"/><circle cx="5.56" cy="7.46" r="0.41" fill="#000" fill-opacity="0.636"/><circle cx="12.40" cy="5.64" r="0.46" fill="#000" fill-opacity="0.698"/><circle cx="10.00" cy="5.13" r="0.46" fill="#000" fill-opacity="0.702"/><circle cx="14.71" cy="10.88" r="0.30" fill="#000" fill-opacity="0.065"/><circle cx="7.61" cy="5.90" r="0.42" fill="#000" fill-opacity="0.652"/><circle cx="12.39" cy="5.96" r="0.42" fill="#000" fill-opacity="0.654"/><circle cx="10.00" cy="5.63" r="0.42" fill="#000" fill-opacity="0.666"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/Contents.json
new file mode 100644
index 0000000000..e104c24b4c
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-working-avatar.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/orb-working-avatar.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/orb-working-avatar.svg
new file mode 100644
index 0000000000..b9c0c7d235
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-avatar.imageset/orb-working-avatar.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><circle cx="29.27" cy="32.43" r="0.36" fill="#000" fill-opacity="0.056"/><circle cx="33.23" cy="32.27" r="0.36" fill="#000" fill-opacity="0.056"/><circle cx="30.62" cy="29.32" r="0.36" fill="#000" fill-opacity="0.056"/><circle cx="29.07" cy="28.47" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="29.54" cy="36.38" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="33.31" cy="27.34" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="35.81" cy="35.21" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="36.94" cy="28.85" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="29.64" cy="25.95" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="28.04" cy="26.43" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="32.11" cy="31.00" r="0.36" fill="#000" fill-opacity="0.056"/><circle cx="33.49" cy="27.91" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="28.94" cy="24.59" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="35.70" cy="32.21" r="0.36" fill="#000" fill-opacity="0.056"/><circle cx="29.87" cy="40.23" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="29.73" cy="27.17" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="28.51" cy="29.83" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="27.15" cy="25.44" r="0.49" fill="#000" fill-opacity="0.706"/><circle cx="37.21" cy="28.76" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="40.45" cy="30.43" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="38.30" cy="38.08" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="26.03" cy="24.71" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="26.02" cy="26.54" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="39.20" cy="33.40" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="25.75" cy="37.10" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="25.01" cy="28.70" r="0.36" fill="#000" fill-opacity="0.058"/><circle cx="25.56" cy="23.68" r="0.36" fill="#000" fill-opacity="0.060"/><circle cx="40.81" cy="29.69" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="23.45" cy="34.07" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="28.21" cy="40.01" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="28.88" cy="20.90" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="30.26" cy="43.87" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="43.76" cy="32.06" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="40.63" cy="40.80" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="21.36" cy="30.98" r="0.36" fill="#000" fill-opacity="0.060"/><circle cx="21.32" cy="30.92" r="0.51" fill="#000" fill-opacity="0.711"/><circle cx="30.76" cy="42.72" r="0.36" fill="#000" fill-opacity="0.060"/><circle cx="22.47" cy="26.04" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="22.57" cy="23.65" r="0.36" fill="#000" fill-opacity="0.062"/><circle cx="42.52" cy="34.57" r="0.36" fill="#000" fill-opacity="0.060"/><circle cx="21.67" cy="27.66" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="44.19" cy="30.67" r="0.36" fill="#000" fill-opacity="0.062"/><circle cx="23.24" cy="21.14" r="0.36" fill="#000" fill-opacity="0.063"/><circle cx="28.91" cy="17.48" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="19.53" cy="27.92" r="0.36" fill="#000" fill-opacity="0.063"/><circle cx="33.34" cy="45.16" r="0.36" fill="#000" fill-opacity="0.063"/><circle cx="46.77" cy="33.68" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="30.68" cy="47.22" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="19.14" cy="25.70" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="42.75" cy="43.30" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="45.58" cy="35.67" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="19.34" cy="22.79" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="18.59" cy="26.72" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="47.26" cy="31.69" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="20.93" cy="41.22" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="20.74" cy="41.02" r="0.54" fill="#000" fill-opacity="0.723"/><circle cx="23.60" cy="43.79" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="18.00" cy="24.96" r="0.36" fill="#000" fill-opacity="0.066"/><circle cx="35.89" cy="47.29" r="0.36" fill="#000" fill-opacity="0.066"/><circle cx="21.14" cy="18.86" r="0.36" fill="#000" fill-opacity="0.067"/><circle cx="38.65" cy="31.76" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="18.54" cy="38.43" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="38.58" cy="34.81" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="26.47" cy="46.07" r="0.36" fill="#000" fill-opacity="0.066"/><circle cx="38.55" cy="28.71" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="29.00" cy="14.42" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="49.42" cy="35.25" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="31.14" cy="50.19" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="38.35" cy="37.80" r="0.36" fill="#000" fill-opacity="0.060"/><circle cx="16.14" cy="25.50" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="16.48" cy="35.47" r="0.36" fill="#000" fill-opacity="0.067"/><circle cx="38.29" cy="25.74" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="48.31" cy="36.67" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="29.47" cy="48.00" r="0.36" fill="#000" fill-opacity="0.067"/><circle cx="16.43" cy="22.16" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="44.60" cy="45.52" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="15.84" cy="25.92" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="38.08" cy="24.19" r="0.52" fill="#000" fill-opacity="0.715"/><circle cx="49.97" cy="32.71" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="37.97" cy="40.64" r="0.36" fill="#000" fill-opacity="0.063"/><circle cx="16.82" cy="22.18" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="31.36" cy="51.45" r="0.59" fill="#000" fill-opacity="0.740"/><circle cx="37.88" cy="22.93" r="0.36" fill="#000" fill-opacity="0.063"/><circle cx="38.34" cy="49.03" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="14.80" cy="32.43" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="32.54" cy="49.54" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="19.30" cy="16.91" r="0.36" fill="#000" fill-opacity="0.072"/><circle cx="29.17" cy="11.79" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="37.43" cy="43.27" r="0.36" fill="#000" fill-opacity="0.066"/><circle cx="51.64" cy="36.75" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="37.32" cy="20.34" r="0.36" fill="#000" fill-opacity="0.066"/><circle cx="13.52" cy="25.47" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="31.62" cy="52.72" r="0.36" fill="#000" fill-opacity="0.074"/><circle cx="13.55" cy="29.38" r="0.36" fill="#000" fill-opacity="0.072"/><circle cx="50.64" cy="37.57" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="51.85" cy="33.54" r="0.61" fill="#000" fill-opacity="0.746"/><circle cx="13.89" cy="21.77" r="0.36" fill="#000" fill-opacity="0.074"/><circle cx="13.49" cy="25.26" r="0.36" fill="#000" fill-opacity="0.074"/><circle cx="35.60" cy="50.65" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="46.15" cy="47.41" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="52.23" cy="33.72" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="16.02" cy="19.63" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="40.64" cy="50.36" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="36.77" cy="45.62" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="13.15" cy="21.70" r="0.63" fill="#000" fill-opacity="0.753"/><circle cx="36.63" cy="18.03" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="12.75" cy="26.40" r="0.36" fill="#000" fill-opacity="0.076"/><circle cx="12.46" cy="24.99" r="0.63" fill="#000" fill-opacity="0.754"/><circle cx="17.77" cy="15.33" r="0.36" fill="#000" fill-opacity="0.077"/><circle cx="34.21" cy="32.57" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="34.49" cy="30.64" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="34.50" cy="30.59" r="0.48" fill="#000" fill-opacity="0.703"/><circle cx="33.87" cy="34.49" r="0.36" fill="#000" fill-opacity="0.057"/><circle cx="38.57" cy="51.29" r="0.36" fill="#000" fill-opacity="0.077"/><circle cx="52.21" cy="38.20" r="0.64" fill="#000" fill-opacity="0.757"/><circle cx="34.71" cy="28.75" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="29.42" cy="9.65" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="53.38" cy="38.14" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="53.38" cy="38.14" r="0.64" fill="#000" fill-opacity="0.759"/><circle cx="33.48" cy="36.34" r="0.36" fill="#000" fill-opacity="0.059"/><circle cx="11.36" cy="25.60" r="0.36" fill="#000" fill-opacity="0.078"/><circle cx="32.11" cy="54.74" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="52.51" cy="38.33" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="34.87" cy="26.93" r="0.36" fill="#000" fill-opacity="0.061"/><circle cx="35.99" cy="47.64" r="0.36" fill="#000" fill-opacity="0.074"/><circle cx="33.06" cy="38.09" r="0.36" fill="#000" fill-opacity="0.062"/><circle cx="11.59" cy="24.77" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="11.81" cy="21.64" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="35.83" cy="16.08" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="15.61" cy="17.39" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="47.34" cy="48.92" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="53.99" cy="34.69" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="42.72" cy="51.24" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="12.42" cy="23.55" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="34.96" cy="25.24" r="0.36" fill="#000" fill-opacity="0.064"/><circle cx="32.61" cy="39.68" r="0.36" fill="#000" fill-opacity="0.065"/><circle cx="10.44" cy="25.73" r="0.67" fill="#000" fill-opacity="0.766"/><circle cx="39.98" cy="26.75" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="40.96" cy="28.64" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="41.37" cy="51.46" r="0.36" fill="#000" fill-opacity="0.081"/><circle cx="38.81" cy="24.99" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="41.71" cy="30.62" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="37.47" cy="23.40" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="42.23" cy="32.63" r="0.36" fill="#000" fill-opacity="0.070"/><circle cx="34.97" cy="23.72" r="0.36" fill="#000" fill-opacity="0.068"/><circle cx="16.60" cy="14.16" r="0.36" fill="#000" fill-opacity="0.083"/><circle cx="29.68" cy="8.26" r="0.68" fill="#000" fill-opacity="0.773"/><circle cx="35.11" cy="49.27" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="32.15" cy="41.09" r="0.36" fill="#000" fill-opacity="0.069"/><circle cx="35.99" cy="22.02" r="0.36" fill="#000" fill-opacity="0.072"/><circle cx="42.50" cy="34.62" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="34.93" cy="14.51" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="54.59" cy="39.37" r="0.36" fill="#000" fill-opacity="0.084"/><circle cx="29.72" cy="8.07" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="9.71" cy="25.89" r="0.36" fill="#000" fill-opacity="0.084"/><circle cx="18.02" cy="35.73" r="0.36" fill="#000" fill-opacity="0.078"/><circle cx="17.56" cy="33.19" r="0.36" fill="#000" fill-opacity="0.078"/><circle cx="53.87" cy="38.93" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="18.83" cy="38.17" r="0.36" fill="#000" fill-opacity="0.078"/><circle cx="17.46" cy="30.62" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="32.59" cy="56.19" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="12.58" cy="20.91" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="34.42" cy="20.89" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="34.91" cy="22.40" r="0.36" fill="#000" fill-opacity="0.073"/><circle cx="19.95" cy="40.47" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="42.50" cy="36.55" r="0.36" fill="#000" fill-opacity="0.075"/><circle cx="10.20" cy="24.46" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="34.19" cy="20.75" r="0.62" fill="#000" fill-opacity="0.751"/><circle cx="15.60" cy="15.51" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="17.71" cy="28.08" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="10.21" cy="21.76" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="44.54" cy="51.64" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="31.68" cy="42.27" r="0.36" fill="#000" fill-opacity="0.074"/><circle cx="55.21" cy="35.59" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="43.95" cy="51.16" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="21.38" cy="42.55" r="0.36" fill="#000" fill-opacity="0.081"/><circle cx="48.16" cy="50.01" r="0.36" fill="#000" fill-opacity="0.087"/><circle cx="18.32" cy="25.65" r="0.36" fill="#000" fill-opacity="0.081"/><circle cx="32.78" cy="20.03" r="0.36" fill="#000" fill-opacity="0.078"/><circle cx="42.25" cy="38.36" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="23.06" cy="44.38" r="0.36" fill="#000" fill-opacity="0.082"/><circle cx="34.15" cy="50.48" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="19.26" cy="23.36" r="0.36" fill="#000" fill-opacity="0.083"/><circle cx="34.78" cy="21.31" r="0.36" fill="#000" fill-opacity="0.079"/><circle cx="24.02" cy="45.20" r="0.68" fill="#000" fill-opacity="0.772"/><circle cx="33.96" cy="13.37" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="31.22" cy="43.21" r="0.36" fill="#000" fill-opacity="0.080"/><circle cx="24.97" cy="45.90" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="31.13" cy="19.47" r="0.36" fill="#000" fill-opacity="0.082"/><circle cx="41.75" cy="40.02" r="0.36" fill="#000" fill-opacity="0.083"/><circle cx="15.80" cy="13.42" r="0.36" fill="#000" fill-opacity="0.090"/><circle cx="20.52" cy="21.30" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="13.21" cy="18.54" r="0.36" fill="#000" fill-opacity="0.090"/><circle cx="8.61" cy="26.33" r="0.36" fill="#000" fill-opacity="0.090"/><circle cx="55.25" cy="40.42" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="27.05" cy="47.08" r="0.36" fill="#000" fill-opacity="0.087"/><circle cx="30.08" cy="7.08" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="46.23" cy="50.38" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="54.69" cy="39.36" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="34.58" cy="20.49" r="0.36" fill="#000" fill-opacity="0.085"/><circle cx="22.06" cy="19.49" r="0.36" fill="#000" fill-opacity="0.088"/><circle cx="29.50" cy="19.21" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="33.06" cy="57.06" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="16.00" cy="14.04" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="41.00" cy="41.49" r="0.36" fill="#000" fill-opacity="0.087"/><circle cx="30.78" cy="43.86" r="0.36" fill="#000" fill-opacity="0.086"/><circle cx="9.34" cy="24.33" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="17.36" cy="36.94" r="0.36" fill="#000" fill-opacity="0.089"/><circle cx="16.75" cy="34.53" r="0.36" fill="#000" fill-opacity="0.089"/><circle cx="46.05" cy="51.55" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="18.32" cy="39.23" r="0.36" fill="#000" fill-opacity="0.089"/><circle cx="16.51" cy="32.05" r="0.36" fill="#000" fill-opacity="0.089"/><circle cx="9.16" cy="22.13" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="19.63" cy="41.34" r="0.36" fill="#000" fill-opacity="0.089"/><circle cx="16.66" cy="29.57" r="0.36" fill="#000" fill-opacity="0.089"/><circle cx="29.25" cy="47.89" r="0.36" fill="#000" fill-opacity="0.090"/><circle cx="55.86" cy="36.40" r="0.36" fill="#000" fill-opacity="0.093"/><circle cx="21.24" cy="43.23" r="0.36" fill="#000" fill-opacity="0.090"/><circle cx="33.14" cy="51.23" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="17.19" cy="27.16" r="0.36" fill="#000" fill-opacity="0.090"/><circle cx="48.58" cy="50.66" r="0.36" fill="#000" fill-opacity="0.093"/><circle cx="23.12" cy="44.83" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="23.84" cy="17.99" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="32.94" cy="12.69" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="18.08" cy="24.86" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="25.21" cy="46.12" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="18.69" cy="23.72" r="0.74" fill="#000" fill-opacity="0.793"/><circle cx="27.93" cy="19.27" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="19.31" cy="22.74" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="40.04" cy="42.71" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="34.32" cy="19.96" r="0.36" fill="#000" fill-opacity="0.091"/><circle cx="31.52" cy="48.31" r="0.36" fill="#000" fill-opacity="0.093"/><circle cx="27.47" cy="47.07" r="0.36" fill="#000" fill-opacity="0.093"/><circle cx="39.83" cy="42.92" r="0.75" fill="#000" fill-opacity="0.795"/><circle cx="14.31" cy="16.51" r="0.36" fill="#000" fill-opacity="0.095"/><circle cx="25.46" cy="17.02" r="0.76" fill="#000" fill-opacity="0.798"/><circle cx="20.86" cy="20.85" r="0.36" fill="#000" fill-opacity="0.093"/><circle cx="30.37" cy="44.22" r="0.36" fill="#000" fill-opacity="0.092"/><circle cx="25.83" cy="16.84" r="0.36" fill="#000" fill-opacity="0.094"/><circle cx="29.84" cy="47.64" r="0.36" fill="#000" fill-opacity="0.094"/><circle cx="22.68" cy="19.23" r="0.36" fill="#000" fill-opacity="0.095"/><circle cx="48.16" cy="49.15" r="0.36" fill="#000" fill-opacity="0.096"/><circle cx="31.80" cy="47.82" r="0.77" fill="#000" fill-opacity="0.802"/><circle cx="15.41" cy="13.15" r="0.36" fill="#000" fill-opacity="0.096"/><circle cx="32.27" cy="47.83" r="0.36" fill="#000" fill-opacity="0.095"/><circle cx="33.80" cy="48.32" r="0.36" fill="#000" fill-opacity="0.096"/><circle cx="26.46" cy="19.64" r="0.36" fill="#000" fill-opacity="0.095"/><circle cx="24.73" cy="17.92" r="0.36" fill="#000" fill-opacity="0.096"/><circle cx="38.87" cy="43.68" r="0.36" fill="#000" fill-opacity="0.096"/><circle cx="8.08" cy="26.90" r="0.36" fill="#000" fill-opacity="0.097"/><circle cx="55.33" cy="41.26" r="0.36" fill="#000" fill-opacity="0.097"/><circle cx="34.69" cy="47.62" r="0.36" fill="#000" fill-opacity="0.097"/><circle cx="27.96" cy="16.06" r="0.36" fill="#000" fill-opacity="0.097"/><circle cx="30.49" cy="6.70" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="32.10" cy="51.51" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="33.99" cy="19.72" r="0.36" fill="#000" fill-opacity="0.097"/><circle cx="54.96" cy="39.61" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="26.96" cy="16.96" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="16.79" cy="13.01" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="47.21" cy="50.99" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="37.04" cy="47.04" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="9.04" cy="24.39" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="30.01" cy="44.28" r="0.36" fill="#000" fill-opacity="0.099"/><circle cx="31.90" cy="12.49" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="33.51" cy="57.30" r="0.36" fill="#000" fill-opacity="0.098"/><circle cx="36.04" cy="47.94" r="0.36" fill="#000" fill-opacity="0.099"/><circle cx="29.31" cy="16.38" r="0.36" fill="#000" fill-opacity="0.099"/><circle cx="8.67" cy="22.74" r="0.36" fill="#000" fill-opacity="0.099"/><circle cx="55.92" cy="37.10" r="0.36" fill="#000" fill-opacity="0.099"/><circle cx="25.13" cy="20.32" r="0.36" fill="#000" fill-opacity="0.100"/><circle cx="39.27" cy="46.08" r="0.36" fill="#000" fill-opacity="0.100"/><circle cx="37.54" cy="44.36" r="0.36" fill="#000" fill-opacity="0.101"/><circle cx="30.20" cy="15.68" r="0.36" fill="#000" fill-opacity="0.100"/><circle cx="31.73" cy="16.17" r="0.36" fill="#000" fill-opacity="0.101"/><circle cx="48.59" cy="50.85" r="0.36" fill="#000" fill-opacity="0.100"/><circle cx="15.84" cy="14.85" r="0.36" fill="#000" fill-opacity="0.100"/><circle cx="41.32" cy="44.77" r="0.36" fill="#000" fill-opacity="0.101"/><circle cx="34.16" cy="16.36" r="0.36" fill="#000" fill-opacity="0.102"/><circle cx="38.17" cy="47.16" r="0.36" fill="#000" fill-opacity="0.102"/><circle cx="33.63" cy="19.78" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="43.14" cy="43.15" r="0.36" fill="#000" fill-opacity="0.103"/><circle cx="49.69" cy="47.49" r="0.36" fill="#000" fill-opacity="0.101"/><circle cx="36.53" cy="16.93" r="0.36" fill="#000" fill-opacity="0.103"/><circle cx="31.28" cy="51.39" r="0.82" fill="#000" fill-opacity="0.822"/><circle cx="32.48" cy="15.69" r="0.36" fill="#000" fill-opacity="0.103"/><circle cx="29.68" cy="44.04" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="23.96" cy="21.29" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="44.69" cy="41.26" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="36.07" cy="44.73" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="38.79" cy="17.88" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="45.92" cy="39.14" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="31.06" cy="51.31" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="40.16" cy="46.01" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="40.88" cy="19.17" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="15.42" cy="13.34" r="0.36" fill="#000" fill-opacity="0.103"/><circle cx="46.81" cy="36.84" r="0.36" fill="#000" fill-opacity="0.106"/><circle cx="30.86" cy="12.77" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="42.76" cy="20.77" r="0.36" fill="#000" fill-opacity="0.106"/><circle cx="8.14" cy="27.60" r="0.36" fill="#000" fill-opacity="0.103"/><circle cx="34.75" cy="16.11" r="0.36" fill="#000" fill-opacity="0.106"/><circle cx="47.34" cy="34.43" r="0.36" fill="#000" fill-opacity="0.107"/><circle cx="44.37" cy="22.66" r="0.36" fill="#000" fill-opacity="0.107"/><circle cx="54.84" cy="41.87" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="47.49" cy="31.95" r="0.36" fill="#000" fill-opacity="0.107"/><circle cx="45.51" cy="24.46" r="0.86" fill="#000" fill-opacity="0.834"/><circle cx="45.68" cy="24.77" r="0.36" fill="#000" fill-opacity="0.107"/><circle cx="17.95" cy="12.45" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="47.25" cy="29.47" r="0.36" fill="#000" fill-opacity="0.107"/><circle cx="46.64" cy="27.06" r="0.36" fill="#000" fill-opacity="0.107"/><circle cx="54.66" cy="39.67" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="33.22" cy="20.14" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="23.00" cy="22.51" r="0.36" fill="#000" fill-opacity="0.109"/><circle cx="48.00" cy="49.96" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="30.94" cy="6.94" r="0.36" fill="#000" fill-opacity="0.104"/><circle cx="34.50" cy="44.79" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="41.94" cy="44.51" r="0.36" fill="#000" fill-opacity="0.108"/><circle cx="29.42" cy="43.51" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="9.31" cy="24.64" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="17.77" cy="13.62" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="33.92" cy="56.92" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="36.95" cy="16.92" r="0.36" fill="#000" fill-opacity="0.109"/><circle cx="8.75" cy="23.58" r="0.36" fill="#000" fill-opacity="0.105"/><circle cx="55.39" cy="37.67" r="0.36" fill="#000" fill-opacity="0.106"/><circle cx="29.35" cy="43.28" r="0.91" fill="#000" fill-opacity="0.850"/><circle cx="50.79" cy="45.46" r="0.36" fill="#000" fill-opacity="0.106"/><circle cx="48.17" cy="49.54" r="0.85" fill="#000" fill-opacity="0.832"/><circle cx="48.21" cy="50.59" r="0.85" fill="#000" fill-opacity="0.831"/><circle cx="43.48" cy="42.70" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="48.20" cy="50.58" r="0.36" fill="#000" fill-opacity="0.106"/><circle cx="22.25" cy="23.98" r="0.36" fill="#000" fill-opacity="0.113"/><circle cx="32.87" cy="44.53" r="0.36" fill="#000" fill-opacity="0.114"/><circle cx="39.03" cy="18.10" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="32.78" cy="20.79" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="30.04" cy="50.63" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="29.22" cy="42.69" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="44.74" cy="40.64" r="0.36" fill="#000" fill-opacity="0.113"/><circle cx="29.85" cy="13.52" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="40.94" cy="19.62" r="0.36" fill="#000" fill-opacity="0.114"/><circle cx="21.75" cy="25.64" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="31.22" cy="43.97" r="0.36" fill="#000" fill-opacity="0.118"/><circle cx="45.68" cy="38.35" r="0.36" fill="#000" fill-opacity="0.115"/><circle cx="15.84" cy="13.99" r="0.36" fill="#000" fill-opacity="0.109"/><circle cx="42.62" cy="21.45" r="0.36" fill="#000" fill-opacity="0.115"/><circle cx="20.05" cy="12.84" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="8.79" cy="28.41" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="32.32" cy="21.73" r="0.36" fill="#000" fill-opacity="0.122"/><circle cx="19.46" cy="12.36" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="53.79" cy="42.24" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="46.29" cy="35.92" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="48.40" cy="48.49" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="53.80" cy="39.54" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="21.50" cy="27.45" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="44.05" cy="23.53" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="29.09" cy="41.60" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="29.58" cy="43.11" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="51.42" cy="43.09" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="46.52" cy="33.78" r="0.94" fill="#000" fill-opacity="0.860"/><circle cx="31.41" cy="7.81" r="0.36" fill="#000" fill-opacity="0.110"/><circle cx="46.54" cy="33.38" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="32.15" cy="22.12" r="0.98" fill="#000" fill-opacity="0.877"/><circle cx="45.17" cy="25.83" r="0.36" fill="#000" fill-opacity="0.118"/><circle cx="10.13" cy="25.07" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="46.44" cy="30.81" r="0.36" fill="#000" fill-opacity="0.118"/><circle cx="45.98" cy="28.27" r="0.36" fill="#000" fill-opacity="0.118"/><circle cx="54.29" cy="38.11" r="0.36" fill="#000" fill-opacity="0.112"/><circle cx="34.28" cy="55.93" r="0.36" fill="#000" fill-opacity="0.111"/><circle cx="9.41" cy="24.63" r="0.36" fill="#000" fill-opacity="0.112"/><circle cx="29.07" cy="49.49" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="51.51" cy="42.43" r="0.90" fill="#000" fill-opacity="0.848"/><circle cx="21.50" cy="29.38" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="28.01" cy="41.98" r="0.36" fill="#000" fill-opacity="0.124"/><circle cx="31.85" cy="22.91" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="28.89" cy="14.73" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="47.40" cy="49.84" r="0.36" fill="#000" fill-opacity="0.113"/><circle cx="29.03" cy="40.28" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="21.77" cy="31.37" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="26.53" cy="40.60" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="21.98" cy="32.33" r="1.00" fill="#000" fill-opacity="0.884"/><circle cx="22.29" cy="33.38" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="25.19" cy="39.01" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="22.63" cy="12.54" r="0.36" fill="#000" fill-opacity="0.115"/><circle cx="23.04" cy="35.36" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="24.02" cy="37.25" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="31.39" cy="24.32" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="29.04" cy="38.76" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="51.58" cy="40.45" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="21.28" cy="12.76" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="10.01" cy="29.31" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="23.75" cy="12.55" r="0.93" fill="#000" fill-opacity="0.859"/><circle cx="16.66" cy="15.08" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="48.39" cy="46.61" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="28.17" cy="47.92" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="52.19" cy="42.36" r="0.36" fill="#000" fill-opacity="0.116"/><circle cx="52.41" cy="39.23" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="30.94" cy="25.91" r="0.36" fill="#000" fill-opacity="0.134"/><circle cx="28.01" cy="16.36" r="0.36" fill="#000" fill-opacity="0.122"/><circle cx="29.13" cy="37.07" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="11.49" cy="25.67" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="31.89" cy="9.26" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="52.64" cy="38.40" r="0.36" fill="#000" fill-opacity="0.118"/><circle cx="30.52" cy="27.66" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="10.62" cy="25.86" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="34.58" cy="54.35" r="0.36" fill="#000" fill-opacity="0.117"/><circle cx="29.29" cy="35.25" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="25.43" cy="12.71" r="0.36" fill="#000" fill-opacity="0.119"/><circle cx="30.13" cy="29.51" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="29.51" cy="33.36" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="29.79" cy="31.43" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="46.23" cy="48.67" r="0.36" fill="#000" fill-opacity="0.119"/><circle cx="51.25" cy="37.60" r="0.36" fill="#000" fill-opacity="0.120"/><circle cx="27.37" cy="45.97" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="27.23" cy="18.38" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="23.36" cy="13.64" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="47.98" cy="44.37" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="11.77" cy="30.28" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="17.85" cy="16.59" r="0.36" fill="#000" fill-opacity="0.121"/><circle cx="28.40" cy="13.35" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="50.51" cy="38.74" r="0.36" fill="#000" fill-opacity="0.122"/><circle cx="50.11" cy="42.23" r="0.36" fill="#000" fill-opacity="0.122"/><circle cx="13.36" cy="26.43" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="50.45" cy="34.62" r="0.36" fill="#000" fill-opacity="0.124"/><circle cx="32.38" cy="11.28" r="0.36" fill="#000" fill-opacity="0.122"/><circle cx="50.48" cy="38.53" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="26.68" cy="43.66" r="0.36" fill="#000" fill-opacity="0.130"/><circle cx="26.64" cy="20.43" r="1.03" fill="#000" fill-opacity="0.893"/><circle cx="12.36" cy="27.25" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="26.57" cy="20.73" r="0.36" fill="#000" fill-opacity="0.130"/><circle cx="34.83" cy="52.21" r="0.36" fill="#000" fill-opacity="0.123"/><circle cx="44.70" cy="47.09" r="0.36" fill="#000" fill-opacity="0.124"/><circle cx="31.46" cy="14.46" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="49.20" cy="31.57" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="25.66" cy="14.97" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="26.12" cy="41.07" r="0.36" fill="#000" fill-opacity="0.133"/><circle cx="47.18" cy="41.82" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="26.03" cy="23.36" r="0.36" fill="#000" fill-opacity="0.133"/><circle cx="14.03" cy="31.29" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="48.16" cy="38.08" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="19.40" cy="18.48" r="0.36" fill="#000" fill-opacity="0.126"/><circle cx="47.57" cy="41.84" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="26.51" cy="15.54" r="1.01" fill="#000" fill-opacity="0.887"/><circle cx="34.53" cy="16.00" r="0.36" fill="#000" fill-opacity="0.129"/><circle cx="15.69" cy="27.33" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="25.71" cy="38.26" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="47.52" cy="28.53" r="0.36" fill="#000" fill-opacity="0.129"/><circle cx="47.86" cy="38.50" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="25.65" cy="26.20" r="0.36" fill="#000" fill-opacity="0.136"/><circle cx="32.86" cy="13.81" r="0.36" fill="#000" fill-opacity="0.127"/><circle cx="14.58" cy="28.75" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="35.00" cy="49.58" r="0.36" fill="#000" fill-opacity="0.128"/><circle cx="25.45" cy="35.29" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="37.53" cy="17.93" r="0.36" fill="#000" fill-opacity="0.130"/><circle cx="25.42" cy="29.19" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="45.46" cy="25.57" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="25.35" cy="32.24" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="42.86" cy="45.14" r="0.36" fill="#000" fill-opacity="0.129"/><circle cx="28.11" cy="16.71" r="0.36" fill="#000" fill-opacity="0.130"/><circle cx="46.00" cy="39.04" r="0.36" fill="#000" fill-opacity="0.130"/><circle cx="40.40" cy="20.21" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="43.07" cy="22.78" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="20.64" cy="19.98" r="1.03" fill="#000" fill-opacity="0.893"/><circle cx="16.74" cy="32.31" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="45.41" cy="37.28" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="44.66" cy="41.21" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="18.42" cy="28.33" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="21.25" cy="20.70" r="0.36" fill="#000" fill-opacity="0.131"/><circle cx="44.86" cy="38.30" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="33.32" cy="16.78" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="17.23" cy="30.32" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="30.66" cy="18.84" r="0.36" fill="#000" fill-opacity="0.133"/><circle cx="44.47" cy="36.08" r="0.36" fill="#000" fill-opacity="0.133"/><circle cx="35.09" cy="46.52" r="0.36" fill="#000" fill-opacity="0.132"/><circle cx="40.76" cy="42.86" r="0.36" fill="#000" fill-opacity="0.133"/><circle cx="19.81" cy="33.33" r="0.36" fill="#000" fill-opacity="0.134"/><circle cx="42.33" cy="36.34" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="21.48" cy="29.43" r="0.36" fill="#000" fill-opacity="0.136"/><circle cx="41.43" cy="40.35" r="0.36" fill="#000" fill-opacity="0.134"/><circle cx="41.53" cy="37.96" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="33.24" cy="21.28" r="0.36" fill="#000" fill-opacity="0.136"/><circle cx="42.64" cy="33.02" r="0.36" fill="#000" fill-opacity="0.136"/><circle cx="23.37" cy="23.20" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="20.24" cy="31.94" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="33.74" cy="20.13" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="35.12" cy="43.10" r="0.36" fill="#000" fill-opacity="0.135"/><circle cx="35.79" cy="23.99" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="40.55" cy="29.93" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="23.19" cy="34.31" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="38.44" cy="40.32" r="0.36" fill="#000" fill-opacity="0.136"/><circle cx="38.99" cy="35.30" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="38.25" cy="26.90" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="24.80" cy="30.60" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="37.98" cy="37.46" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="37.97" cy="39.29" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="25.70" cy="25.92" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="23.55" cy="33.57" r="0.36" fill="#000" fill-opacity="0.137"/><circle cx="26.79" cy="35.24" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="35.49" cy="34.17" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="34.27" cy="36.83" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="34.13" cy="23.77" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="28.30" cy="31.79" r="0.36" fill="#000" fill-opacity="0.140"/><circle cx="33.71" cy="36.73" r="1.10" fill="#000" fill-opacity="0.918"/><circle cx="35.06" cy="39.41" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="30.51" cy="36.09" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="31.33" cy="32.81" r="1.11" fill="#000" fill-opacity="0.920"/><circle cx="31.89" cy="33.00" r="0.36" fill="#000" fill-opacity="0.140"/><circle cx="35.96" cy="37.57" r="0.36" fill="#000" fill-opacity="0.138"/><circle cx="34.36" cy="38.05" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="27.06" cy="35.15" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="29.47" cy="36.16" r="1.10" fill="#000" fill-opacity="0.918"/><circle cx="28.19" cy="28.79" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="30.69" cy="36.66" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="34.96" cy="36.30" r="1.10" fill="#000" fill-opacity="0.918"/><circle cx="34.46" cy="27.62" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="34.93" cy="35.53" r="0.36" fill="#000" fill-opacity="0.139"/><circle cx="33.38" cy="34.68" r="0.36" fill="#000" fill-opacity="0.140"/><circle cx="30.77" cy="31.73" r="0.36" fill="#000" fill-opacity="0.140"/><circle cx="34.73" cy="31.57" r="0.36" fill="#000" fill-opacity="0.140"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/Contents.json b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/Contents.json
new file mode 100644
index 0000000000..869d360129
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "orb-working-inline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/orb-working-inline.svg b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/orb-working-inline.svg
new file mode 100644
index 0000000000..fd2af25be6
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Assets.xcassets/orb-working-inline.imageset/orb-working-inline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20"><circle cx="10.39" cy="10.08" r="0.43" fill="#000" fill-opacity="0.056"/><circle cx="8.49" cy="7.95" r="0.59" fill="#000" fill-opacity="0.706"/><circle cx="8.05" cy="11.59" r="0.43" fill="#000" fill-opacity="0.058"/><circle cx="6.66" cy="9.66" r="0.61" fill="#000" fill-opacity="0.711"/><circle cx="7.26" cy="6.61" r="0.43" fill="#000" fill-opacity="0.063"/><circle cx="13.36" cy="13.53" r="0.43" fill="#000" fill-opacity="0.065"/><circle cx="5.63" cy="7.80" r="0.43" fill="#000" fill-opacity="0.066"/><circle cx="11.22" cy="14.78" r="0.43" fill="#000" fill-opacity="0.066"/><circle cx="12.49" cy="8.36" r="0.43" fill="#000" fill-opacity="0.068"/><circle cx="5.19" cy="4.42" r="0.43" fill="#000" fill-opacity="0.083"/><circle cx="13.28" cy="10.82" r="0.43" fill="#000" fill-opacity="0.073"/><circle cx="10.76" cy="6.53" r="0.43" fill="#000" fill-opacity="0.075"/><circle cx="10.68" cy="6.48" r="0.74" fill="#000" fill-opacity="0.751"/><circle cx="4.87" cy="4.85" r="0.43" fill="#000" fill-opacity="0.086"/><circle cx="13.92" cy="16.14" r="0.43" fill="#000" fill-opacity="0.086"/><circle cx="15.05" cy="15.63" r="0.43" fill="#000" fill-opacity="0.087"/><circle cx="12.81" cy="12.96" r="0.43" fill="#000" fill-opacity="0.087"/><circle cx="8.73" cy="6.02" r="0.43" fill="#000" fill-opacity="0.091"/><circle cx="12.45" cy="13.41" r="0.89" fill="#000" fill-opacity="0.795"/><circle cx="11.27" cy="13.98" r="0.43" fill="#000" fill-opacity="0.105"/><circle cx="7.19" cy="7.04" r="0.43" fill="#000" fill-opacity="0.109"/><circle cx="15.05" cy="15.48" r="1.02" fill="#000" fill-opacity="0.832"/><circle cx="15.07" cy="15.81" r="1.02" fill="#000" fill-opacity="0.831"/><circle cx="4.95" cy="4.37" r="0.43" fill="#000" fill-opacity="0.109"/><circle cx="6.08" cy="3.86" r="0.43" fill="#000" fill-opacity="0.110"/><circle cx="15.13" cy="15.15" r="0.43" fill="#000" fill-opacity="0.110"/><circle cx="9.24" cy="13.47" r="0.43" fill="#000" fill-opacity="0.121"/><circle cx="6.72" cy="9.18" r="0.43" fill="#000" fill-opacity="0.123"/><circle cx="14.81" cy="15.58" r="0.43" fill="#000" fill-opacity="0.113"/><circle cx="6.87" cy="10.10" r="1.20" fill="#000" fill-opacity="0.884"/><circle cx="7.51" cy="11.64" r="0.43" fill="#000" fill-opacity="0.128"/><circle cx="8.29" cy="4.86" r="1.21" fill="#000" fill-opacity="0.887"/><circle cx="8.78" cy="5.22" r="0.43" fill="#000" fill-opacity="0.130"/><circle cx="14.37" cy="12.20" r="0.43" fill="#000" fill-opacity="0.130"/><circle cx="6.45" cy="6.24" r="1.23" fill="#000" fill-opacity="0.893"/><circle cx="6.64" cy="6.47" r="0.43" fill="#000" fill-opacity="0.131"/><circle cx="12.74" cy="13.39" r="0.43" fill="#000" fill-opacity="0.133"/><circle cx="11.95" cy="8.41" r="0.43" fill="#000" fill-opacity="0.138"/><circle cx="9.61" cy="9.92" r="0.43" fill="#000" fill-opacity="0.140"/></svg>
\ No newline at end of file
diff --git a/apps/ios/ZeronLiveActivity/Info.plist b/apps/ios/ZeronLiveActivity/Info.plist
new file mode 100644
index 0000000000..649c10d2e8
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/Info.plist
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.widgetkit-extension</string>
+	</dict>
+	<key>UIAppFonts</key>
+	<array>
+		<string>Geist-Medium.ttf</string>
+		<string>GeistMono-Medium.ttf</string>
+	</array>
+</dict>
+</plist>
diff --git a/apps/ios/ZeronLiveActivity/VoiceLiveActivity.swift b/apps/ios/ZeronLiveActivity/VoiceLiveActivity.swift
new file mode 100644
index 0000000000..a91a1f5e4f
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/VoiceLiveActivity.swift
@@ -0,0 +1,260 @@
+import ActivityKit
+import AppIntents
+import SwiftUI
+import UIKit
+import WidgetKit
+
+/// The orchestrator call outside the app. The Dynamic Island keeps the orb
+/// and the call clock beside the camera; expanded, and on the Lock Screen, it
+/// adds what Codex is doing, the host and the stage's mute and end controls.
+/// Tapping it returns to the full-screen stage.
+struct VoiceLiveActivity: Widget {
+    var body: some WidgetConfiguration {
+        ActivityConfiguration(for: VoiceActivityAttributes.self) { context in
+            LockScreenCall(host: context.attributes.host, state: context.state)
+                .activitySystemActionForegroundColor(.primary)
+                .widgetURL(Stage.url)
+        } dynamicIsland: { context in
+            let state = context.state
+            return DynamicIsland {
+                DynamicIslandExpandedRegion(.leading) {
+                    OrbGlyph(orb: state.orb, large: true)
+                        .frame(width: 46, height: 46)
+                        .padding(.leading, 6)
+                        .padding(.top, 2)
+                }
+                DynamicIslandExpandedRegion(.trailing) {
+                    CallClock(since: state.since)
+                        .font(Face.mono(15))
+                        .foregroundStyle(.secondary)
+                        .frame(maxHeight: .infinity, alignment: .center)
+                        .padding(.trailing, 6)
+                }
+                DynamicIslandExpandedRegion(.center) {
+                    VStack(alignment: .leading, spacing: 2) {
+                        Status(orb: state.orb, size: 16)
+                        Text("Codex on \(context.attributes.host)")
+                            .font(Face.sans(12))
+                            .foregroundStyle(.secondary)
+                            .lineLimit(1)
+                    }
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(.leading, 4)
+                }
+                DynamicIslandExpandedRegion(.bottom) {
+                    HStack(spacing: 10) {
+                        MuteControl(muted: state.muted, labeled: true)
+                        EndControl(labeled: true)
+                    }
+                    .padding(.top, 6)
+                    .padding(.horizontal, 4)
+                }
+            } compactLeading: {
+                OrbGlyph(orb: state.orb, large: false)
+                    .frame(width: 22, height: 22)
+                    .padding(.leading, 2)
+            } compactTrailing: {
+                if state.muted {
+                    Image(systemName: "mic.slash.fill")
+                        .font(.system(size: 13, weight: .semibold))
+                        .foregroundStyle(.secondary)
+                        .padding(.trailing, 2)
+                } else {
+                    CallClock(since: state.since)
+                        .font(Face.mono(14))
+                        .frame(width: 44, alignment: .trailing)
+                }
+            } minimal: {
+                OrbGlyph(orb: state.orb, large: false)
+                    .frame(width: 20, height: 20)
+            }
+            .keylineTint(state.orb == .awaiting ? Tone.warning : Tone.accent)
+            .widgetURL(Stage.url)
+        }
+    }
+}
+
+private enum Stage {
+    static let url = URL(string: "zeron://voice")
+}
+
+// MARK: Lock Screen
+
+private struct LockScreenCall: View {
+    let host: String
+    let state: VoiceActivityAttributes.ContentState
+
+    var body: some View {
+        HStack(spacing: 14) {
+            OrbGlyph(orb: state.orb, large: true)
+                .frame(width: 52, height: 52)
+            VStack(alignment: .leading, spacing: 3) {
+                Text("Codex · \(host)")
+                    .font(Face.mono(12))
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                Status(orb: state.orb, size: 17)
+                CallClock(since: state.since)
+                    .font(Face.mono(13))
+                    .foregroundStyle(.secondary)
+            }
+            Spacer(minLength: 8)
+            HStack(spacing: 10) {
+                MuteControl(muted: state.muted, labeled: false)
+                EndControl(labeled: false)
+            }
+        }
+        .padding(.horizontal, 18)
+        .padding(.vertical, 16)
+    }
+}
+
+// MARK: Pieces
+
+/// The desktop orb's drawing for this state, in the surrounding ink. Waiting
+/// on an answer it takes the stage's warning tone; muted it rests dimmer.
+private struct OrbGlyph: View {
+    let orb: VoiceActivityOrb
+    let large: Bool
+
+    var body: some View {
+        Image("orb-\(orb.rawValue)-\(large ? "avatar" : "inline")")
+            .resizable()
+            .renderingMode(.template)
+            .scaledToFit()
+            .foregroundStyle(orb == .awaiting ? AnyShapeStyle(Tone.warning) : AnyShapeStyle(.primary))
+            .opacity(orb == .muted ? 0.55 : 1)
+            .id(orb)
+            .transition(.opacity.combined(with: .scale(scale: 0.8)))
+            .accessibilityLabel(orb.status)
+    }
+}
+
+private struct Status: View {
+    let orb: VoiceActivityOrb
+    let size: CGFloat
+
+    var body: some View {
+        Text(orb.status)
+            .font(Face.sans(size))
+            .foregroundStyle(orb == .awaiting ? AnyShapeStyle(Tone.warning) : AnyShapeStyle(.primary))
+            .lineLimit(1)
+            .minimumScaleFactor(0.8)
+            .contentTransition(.opacity)
+    }
+}
+
+/// Elapsed call time, ticking on its own between updates.
+private struct CallClock: View {
+    let since: Date?
+
+    var body: some View {
+        if let since {
+            Text(timerInterval: since...Date.distantFuture, countsDown: false)
+                .monospacedDigit()
+                .multilineTextAlignment(.trailing)
+        } else {
+            Image(systemName: "ellipsis")
+                .font(.system(size: 13, weight: .semibold))
+        }
+    }
+}
+
+/// The stage's mute toggle: a quiet disc, filled with ink while muted.
+private struct MuteControl: View {
+    let muted: Bool
+    let labeled: Bool
+
+    var body: some View {
+        Button(intent: ToggleVoiceMuteIntent()) {
+            ControlFace(symbol: muted ? "mic.slash.fill" : "mic.fill", label: labeled ? (muted ? "Unmute" : "Mute") : nil)
+                // Plain colors: hierarchical styles turn vibrant on the Lock
+                // Screen material, and the muted disc would lose its ink.
+                .foregroundStyle(muted ? Color(uiColor: .systemBackground) : Color.primary)
+                .background(muted ? Color.primary : Color.primary.opacity(0.14), in: Capsule())
+        }
+        .buttonStyle(.plain)
+        .accessibilityLabel(muted ? "Unmute" : "Mute")
+    }
+}
+
+/// Hang up, in the stage's red.
+private struct EndControl: View {
+    let labeled: Bool
+
+    var body: some View {
+        Button(intent: EndVoiceCallIntent()) {
+            ControlFace(symbol: "phone.down.fill", label: labeled ? "End" : nil)
+                .foregroundStyle(.white)
+                .background(Color.red, in: Capsule())
+        }
+        .buttonStyle(.plain)
+        .accessibilityLabel("End call")
+    }
+}
+
+private struct ControlFace: View {
+    let symbol: String
+    let label: String?
+
+    var body: some View {
+        if let label {
+            Label(label, systemImage: symbol)
+                .font(Face.sans(14))
+                .labelStyle(.titleAndIcon)
+                .frame(maxWidth: .infinity)
+                .frame(height: 40)
+        } else {
+            Image(systemName: symbol)
+                .font(.system(size: 15, weight: .bold))
+                .frame(width: 44, height: 44)
+        }
+    }
+}
+
+// MARK: Style
+
+/// The app's faces (Geist), bundled with the extension.
+private enum Face {
+    static func sans(_ size: CGFloat) -> Font { .custom("Geist-Medium", size: size) }
+    static func mono(_ size: CGFloat) -> Font { .custom("GeistMono-Medium", size: size) }
+}
+
+/// Zeron Dark/Light accents (`Palette`), as the app paints them.
+private enum Tone {
+    static let accent = Color(UIColor { $0.userInterfaceStyle == .dark ? UIColor(hex: 0x8B7CF6) : UIColor(hex: 0x5B43E8) })
+    static let warning = Color(UIColor { $0.userInterfaceStyle == .dark ? UIColor(hex: 0xFACC15) : UIColor(hex: 0xA16207) })
+}
+
+private extension UIColor {
+    convenience init(hex: UInt32) {
+        self.init(
+            red: CGFloat(hex >> 16 & 0xFF) / 255,
+            green: CGFloat(hex >> 8 & 0xFF) / 255,
+            blue: CGFloat(hex & 0xFF) / 255,
+            alpha: 1
+        )
+    }
+}
+
+#if DEBUG
+#Preview("Island", as: .dynamicIsland(.expanded), using: VoiceActivityAttributes(host: "Fedora")) {
+    VoiceLiveActivity()
+} contentStates: {
+    VoiceActivityAttributes.ContentState(orb: .speaking, muted: false, since: .now.addingTimeInterval(-83))
+    VoiceActivityAttributes.ContentState(orb: .awaiting, muted: true, since: .now.addingTimeInterval(-421))
+}
+
+#Preview("Compact", as: .dynamicIsland(.compact), using: VoiceActivityAttributes(host: "Fedora")) {
+    VoiceLiveActivity()
+} contentStates: {
+    VoiceActivityAttributes.ContentState(orb: .listening, muted: false, since: .now.addingTimeInterval(-83))
+    VoiceActivityAttributes.ContentState(orb: .muted, muted: true, since: .now.addingTimeInterval(-83))
+}
+
+#Preview("Lock Screen", as: .content, using: VoiceActivityAttributes(host: "Fedora")) {
+    VoiceLiveActivity()
+} contentStates: {
+    VoiceActivityAttributes.ContentState(orb: .working, muted: false, since: .now.addingTimeInterval(-83))
+}
+#endif
diff --git a/apps/ios/ZeronLiveActivity/ZeronLiveActivityBundle.swift b/apps/ios/ZeronLiveActivity/ZeronLiveActivityBundle.swift
new file mode 100644
index 0000000000..f89776dfea
--- /dev/null
+++ b/apps/ios/ZeronLiveActivity/ZeronLiveActivityBundle.swift
@@ -0,0 +1,9 @@
+import SwiftUI
+import WidgetKit
+
+@main
+struct ZeronLiveActivityBundle: WidgetBundle {
+    var body: some Widget {
+        VoiceLiveActivity()
+    }
+}
diff --git a/apps/ios/ZeronShared/VoiceActivity.swift b/apps/ios/ZeronShared/VoiceActivity.swift
new file mode 100644
index 0000000000..65cce55506
--- /dev/null
+++ b/apps/ios/ZeronShared/VoiceActivity.swift
@@ -0,0 +1,69 @@
+import ActivityKit
+import AppIntents
+import Foundation
+
+/// The voice call as a Live Activity: the Dynamic Island and the Lock Screen
+/// keep showing the orchestrator call once Zeron leaves the screen. Shared by
+/// the app, which starts and updates it, and the widget extension, which
+/// draws it.
+struct VoiceActivityAttributes: ActivityAttributes {
+    struct ContentState: Codable, Hashable {
+        var orb: VoiceActivityOrb
+        var muted: Bool
+        /// When the call went live; nil while it connects.
+        var since: Date?
+    }
+
+    /// The execution host Codex runs on ("Fedora", "MacBook Pro").
+    var host: String
+}
+
+/// The orb's call states. Each has the desktop orb's own drawing (exported
+/// from `zeron-orb`) in the extension's asset catalog.
+enum VoiceActivityOrb: String, Codable, Hashable {
+    case connecting, listening, speaking, working, awaiting, muted
+
+    /// What the call is doing, in the stage's words.
+    var status: String {
+        switch self {
+        case .connecting: "Connecting…"
+        case .listening: "Listening"
+        case .speaking: "Speaking"
+        case .working: "Working on it…"
+        case .awaiting: "Codex needs your answer"
+        case .muted: "Muted"
+        }
+    }
+}
+
+/// Live Activity buttons run in the app's process, where the call lives. The
+/// widget extension compiles these too but never performs them.
+enum VoiceActivityAction {
+    case toggleMute, end
+
+    @MainActor static var handler: ((VoiceActivityAction) -> Void)?
+}
+
+struct ToggleVoiceMuteIntent: LiveActivityIntent {
+    static let title: LocalizedStringResource = "Mute or Unmute Voice"
+    static var isDiscoverable: Bool { false }
+
+    init() {}
+
+    func perform() async throws -> some IntentResult {
+        await MainActor.run { VoiceActivityAction.handler?(.toggleMute) }
+        return .result()
+    }
+}
+
+struct EndVoiceCallIntent: LiveActivityIntent {
+    static let title: LocalizedStringResource = "End Voice Call"
+    static var isDiscoverable: Bool { false }
+
+    init() {}
+
+    func perform() async throws -> some IntentResult {
+        await MainActor.run { VoiceActivityAction.handler?(.end) }
+        return .result()
+    }
+}
diff --git a/apps/ios/ZeronTests/RemoteVoiceLifecycleTests.swift b/apps/ios/ZeronTests/RemoteVoiceLifecycleTests.swift
new file mode 100644
index 0000000000..caafa98a5c
--- /dev/null
+++ b/apps/ios/ZeronTests/RemoteVoiceLifecycleTests.swift
@@ -0,0 +1,72 @@
+import XCTest
+@testable import Zeron
+
+final class RemoteVoiceLifecycleTests: XCTestCase {
+    func testCancelledContinuationIgnoresLateNativeSuccess() async {
+        let slot = VoiceContinuation<String>()
+        slot.finish(.failure(CancellationError()))
+        do {
+            let _: String = try await withCheckedThrowingContinuation { continuation in
+                slot.install(continuation)
+                slot.finish(.success("late offer"))
+            }
+            XCTFail("Cancelled negotiation must not produce an offer")
+        } catch { XCTAssertTrue(error is CancellationError) }
+    }
+
+    func testNativeCompletionResumesOnlyOnce() async throws {
+        let slot = VoiceContinuation<Int>()
+        let value = try await withCheckedThrowingContinuation { continuation in
+            slot.install(continuation)
+            slot.finish(.success(1))
+            slot.finish(.success(2))
+            slot.finish(.failure(CancellationError()))
+        }
+        XCTAssertEqual(value, 1)
+    }
+
+    @MainActor
+    func testClosedEndpointCannotReactivateOrProduceOffer() async {
+        let peer = CodexVoicePeer()
+        peer.close()
+        peer.close()
+        XCTAssertThrowsError(try peer.setMuted(false))
+        do { _ = try await peer.offer(); XCTFail("Closed peer cannot negotiate") } catch {}
+        do { try await peer.apply(answer: "late answer"); XCTFail("Closed peer cannot apply answer") } catch {}
+    }
+
+    @MainActor
+    func testOrbFramesMatchTheDesktopArtworkBox() {
+        for orb: VoiceOrb in [.idle, .connecting, .listening, .speaking, .working, .awaitingInput, .muted] {
+            let renderer = OrbRenderer(preset: .hero, orb: orb)
+            renderer.setAudioLevels(microphone: 0.4, speaker: 0.9)
+            let frame = renderer.nextFrame(animating: true, reducedMotion: false)
+            XCTAssertEqual(frame.size, 128)
+            XCTAssertFalse(frame.dots.isEmpty)
+            XCTAssertEqual(frame.dots.count % 5, 0)
+            XCTAssertEqual(frame.lines.count % 7, 0)
+            XCTAssertTrue((frame.dots + frame.lines).allSatisfy(\.isFinite))
+        }
+    }
+
+    func testCaptionShowsTheTailAndVeilsNewWords() {
+        let fader = CaptionFader(maxChars: 160)
+        XCTAssertEqual(fader.frame(item: "a", text: "  short  ", reducedMotion: true).text, "short")
+        let long = String(repeating: "a", count: 300) + " end"
+        let frame = fader.frame(item: "b", text: long, reducedMotion: false)
+        XCTAssertTrue(frame.text.hasPrefix("…"))
+        XCTAssertTrue(frame.text.hasSuffix(" end"))
+        XCTAssertLessThanOrEqual(frame.text.count, 161)
+        // A new turn: its words fade in while the previous caption fades out.
+        XCTAssertTrue(frame.animating)
+        XCTAssertEqual(frame.previous, "short")
+        XCTAssertEqual(frame.spans.first?.alpha, 0)
+    }
+
+    @MainActor
+    func testEveryEndReasonExplainsItself() {
+        for reason: VoiceEndReason in [.microphoneDenied, .audioUnavailable, .signInRequired, .usageUnavailable, .busy, .hostUnavailable, .hostIncompatible, .connectionLost] {
+            XCTAssertFalse(RemoteVoiceController.message(for: reason, host: "Fedora").isEmpty)
+        }
+    }
+}
diff --git a/apps/ios/ZeronUITests/VoiceFlowTests.swift b/apps/ios/ZeronUITests/VoiceFlowTests.swift
new file mode 100644
index 0000000000..aa7890b9fe
--- /dev/null
+++ b/apps/ios/ZeronUITests/VoiceFlowTests.swift
@@ -0,0 +1,72 @@
+import XCTest
+
+/// Voice controls around a scripted call (`-voice-preview`: no audio, host or relay).
+final class VoiceFlowTests: XCTestCase {
+    override func setUpWithError() throws {
+        continueAfterFailure = false
+        try XCTSkipUnless(UIDevice.current.userInterfaceIdiom == .phone, "iPhone tab shell")
+    }
+
+    private func launch(_ args: [String]) -> XCUIApplication {
+        let app = XCUIApplication()
+        app.launchArguments = ["-demo", "-fast", "-voice-preview"] + args
+        app.launch()
+        return app
+    }
+
+    /// Stage → transcript → back: the live strip in the bottom bar reopens the stage.
+    func testLiveStripReopensTheStageAfterTheTranscript() {
+        let app = launch(["-voice-stage"])
+        let stage = app.otherElements["voice-stage"]
+        XCTAssertTrue(stage.waitForExistence(timeout: 10))
+        app.buttons["voice-transcript"].tap()
+        XCTAssertTrue(app.scrollViews["transcript"].waitForExistence(timeout: 10))
+        XCTAssertFalse(stage.exists)
+        app.navigationBars.buttons.element(boundBy: 0).tap()
+        let strip = app.descendants(matching: .any)["voice-live"].firstMatch
+        XCTAssertTrue(strip.waitForExistence(timeout: 5))
+        strip.tap()
+        XCTAssertTrue(stage.waitForExistence(timeout: 5), "the live strip opens the call stage")
+    }
+
+    /// Minimizing the stage and tapping the strip brings it back.
+    func testLiveStripReopensAMinimizedStage() {
+        let app = launch(["-voice-stage"])
+        let stage = app.otherElements["voice-stage"]
+        XCTAssertTrue(stage.waitForExistence(timeout: 10))
+        app.buttons["voice-minimize"].tap()
+        let strip = app.descendants(matching: .any)["voice-live"].firstMatch
+        XCTAssertTrue(strip.waitForExistence(timeout: 5))
+        sleep(1)
+        strip.tap()
+        XCTAssertTrue(stage.waitForExistence(timeout: 5))
+    }
+
+    /// Settings → Voice lists hosts and call tips; the voice is a pop-up menu.
+    func testVoiceSettings() {
+        let app = XCUIApplication()
+        app.launchArguments = ["-demo", "-fast", "-remote-voice", "-route", "more"]
+        app.launch()
+        let row = app.cells["settings-voice"]
+        XCTAssertTrue(row.waitForExistence(timeout: 10))
+        row.tap()
+        let style = app.cells["voice-style"]
+        XCTAssertTrue(style.waitForExistence(timeout: 5))
+        snapshot(app, "voice-settings")
+        style.tap()
+        let maple = app.buttons["Maple"]
+        XCTAssertTrue(maple.waitForExistence(timeout: 5))
+        snapshot(app, "voice-settings-menu")
+        maple.tap()
+        XCTAssertTrue(style.staticTexts["Maple"].waitForExistence(timeout: 5), "the chosen voice shows in the row")
+        app.swipeUp()
+        snapshot(app, "voice-settings-scrolled")
+    }
+
+    private func snapshot(_ app: XCUIApplication, _ name: String) {
+        let shot = XCTAttachment(screenshot: app.screenshot())
+        shot.name = name
+        shot.lifetime = .keepAlways
+        add(shot)
+    }
+}
diff --git a/apps/zeron/build.rs b/apps/zeron/build.rs
index b9430530ef..7e389dcb48 100644
--- a/apps/zeron/build.rs
+++ b/apps/zeron/build.rs
@@ -1,4 +1,16 @@
 fn main() {
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos") {
+        let plist = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../dist/macos/Info-unbundled.plist");
+        println!("cargo:rerun-if-changed={}", plist.display());
+        // `cargo run` has no .app Info.plist. NSBundle also reads privacy
+        // declarations from this Mach-O section, so source builds can request
+        // microphone access without requiring a separate packaging step.
+        println!(
+            "cargo:rustc-link-arg-bin=zeron=-Wl,-sectcreate,__TEXT,__info_plist,{}",
+            plist.display()
+        );
+    }
     println!("cargo:rerun-if-changed=../../dist/windows/zeron.rc");
     println!("cargo:rerun-if-changed=../../dist/windows/zeron.ico");
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
diff --git a/crates/audio/Cargo.toml b/crates/audio/Cargo.toml
new file mode 100644
index 0000000000..97ffb49091
--- /dev/null
+++ b/crates/audio/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "zeron-audio"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[features]
+default = ["native"]
+native = ["dep:cpal"]
+aec = ["dep:webrtc-audio-processing"]
+
+[dependencies]
+zeron-proto.workspace = true
+base64 = "0.22"
+crossbeam-queue = "0.3"
+cpal = { version = "=0.18.2", optional = true }
+webrtc-audio-processing = { version = "~2.1.0", features = ["bundled"], optional = true }
+thiserror.workspace = true
diff --git a/crates/audio/src/aec.rs b/crates/audio/src/aec.rs
new file mode 100644
index 0000000000..b11c533e9e
--- /dev/null
+++ b/crates/audio/src/aec.rs
@@ -0,0 +1,89 @@
+//! WebRTC AEC3 at 48 kHz / 10 ms. Feed audio actually rendered by the
+//! hardware, including underrun silence; never use received network packets.
+use crate::AudioError;
+use webrtc_audio_processing::{
+    Config, Processor,
+    config::{EchoCanceller, HighPassFilter},
+};
+
+pub const DSP_SAMPLES: usize = 480;
+pub struct EchoProcessor {
+    processor: Processor,
+}
+impl EchoProcessor {
+    pub fn new() -> Result<Self, AudioError> {
+        let processor = Processor::new(48_000).map_err(|_| AudioError::Device)?;
+        processor.set_config(Config {
+            echo_canceller: Some(EchoCanceller::Full {
+                stream_delay_ms: None,
+            }),
+            high_pass_filter: Some(HighPassFilter::default()),
+            ..Config::default()
+        });
+        Ok(Self { processor })
+    }
+    pub fn render(&self, actually_played: &[f32; DSP_SAMPLES]) -> Result<(), AudioError> {
+        self.processor
+            .analyze_render_frame([actually_played.as_slice()])
+            .map_err(|_| AudioError::Frame)
+    }
+    pub fn capture(&self, microphone: &mut [f32; DSP_SAMPLES]) -> Result<(), AudioError> {
+        self.processor
+            .process_capture_frame([microphone.as_mut_slice()])
+            .map_err(|_| AudioError::Frame)
+    }
+    /// Device/session changes discard adaptive history as well as samples.
+    pub fn reset(&mut self) -> Result<(), AudioError> {
+        *self = Self::new()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn aec_reduces_delayed_synthetic_echo_without_erasing_double_talk() {
+        let processor=EchoProcessor::new().unwrap();
+        let mut delayed=std::collections::VecDeque::from([[0.0;DSP_SAMPLES];3]);
+        let mut random=1u32;
+        let mut before=0.0f64; let mut after=0.0f64;
+        let mut near_before=0.0f64; let mut near_after=0.0f64;
+        for index in 0..1000 {
+            let reference=std::array::from_fn(|_| {
+                random=random.wrapping_mul(1664525).wrapping_add(1013904223);
+                (random as f64/u32::MAX as f64*0.4-0.2) as f32
+            });
+            processor.render(&reference).unwrap();
+            let echo=delayed.pop_front().unwrap(); delayed.push_back(reference);
+            let mut microphone=std::array::from_fn(|sample| {
+                let human=if index>=800 { ((index*DSP_SAMPLES+sample) as f32*0.08).sin()*0.15 } else { 0.0 };
+                human+echo[sample]*0.55
+            });
+            let input_energy=microphone.iter().map(|s|(*s as f64).powi(2)).sum::<f64>();
+            processor.capture(&mut microphone).unwrap();
+            let output_energy=microphone.iter().map(|s|(*s as f64).powi(2)).sum::<f64>();
+            if (600..800).contains(&index) { before+=input_energy; after+=output_energy; }
+            if index>=900 { near_before+=input_energy; near_after+=output_energy; }
+        }
+        assert!(after<before*0.5,"echo energy ratio {}",after/before);
+        assert!(near_after>near_before*0.1,"double-talk energy ratio {}",near_after/near_before);
+    }
+
+    #[test]
+    fn reverse_and_capture_frames_are_finite_and_reset_cleanly() {
+        let mut processor = EchoProcessor::new().unwrap();
+        for frame in 0..400 {
+            let mut reference = [0.0; DSP_SAMPLES];
+            for (i, v) in reference.iter_mut().enumerate() {
+                *v = ((frame * DSP_SAMPLES + i) as f32 * 0.04).sin() * 0.2;
+            }
+            processor.render(&reference).unwrap();
+            let mut microphone = reference.map(|s| s * 0.6);
+            processor.capture(&mut microphone).unwrap();
+            assert!(microphone.iter().all(|s| s.is_finite()));
+        }
+        processor.reset().unwrap();
+        processor.capture(&mut [0.0; DSP_SAMPLES]).unwrap();
+    }
+}
diff --git a/crates/audio/src/dsp.rs b/crates/audio/src/dsp.rs
new file mode 100644
index 0000000000..2a454eeb15
--- /dev/null
+++ b/crates/audio/src/dsp.rs
@@ -0,0 +1,68 @@
+//! Stateful resampling and fixed framing outside real-time callbacks.
+/// Continuous linear resampler. One sample of lookahead, no chunk-edge reset.
+pub struct Resampler {
+    step: f64,
+    phase: f64,
+    previous: Option<f32>,
+}
+impl Resampler {
+    pub fn new(input: u32, output: u32) -> Option<Self> {
+        (input >= 8_000 && output >= 8_000 && input <= 192_000 && output <= 192_000).then_some(
+            Self {
+                step: input as f64 / output as f64,
+                phase: 0.0,
+                previous: None,
+            },
+        )
+    }
+    pub fn push(&mut self, sample: f32, output: &mut Vec<f32>) {
+        let sample = if sample.is_finite() {
+            sample.clamp(-1.0, 1.0)
+        } else {
+            0.0
+        };
+        if let Some(previous) = self.previous {
+            while self.phase < 1.0 {
+                output.push(previous + (sample - previous) * self.phase as f32);
+                self.phase += self.step;
+            }
+            self.phase -= 1.0;
+        }
+        self.previous = Some(sample);
+    }
+}
+pub fn level(samples: &[f32]) -> f32 {
+    if samples.is_empty() {
+        return 0.0;
+    }
+    (samples
+        .iter()
+        .map(|s| if s.is_finite() { s * s } else { 0.0 })
+        .sum::<f32>()
+        / samples.len() as f32)
+        .sqrt()
+        .clamp(0.0, 1.0)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn resampling_keeps_continuity_and_exact_duration_across_chunks() {
+        let input: Vec<f32> = (0..4801).map(|i| (i as f32 * 0.03).sin()).collect();
+        let mut a = Resampler::new(48_000, 24_000).unwrap();
+        let mut all = Vec::new();
+        for x in &input {
+            a.push(*x, &mut all);
+        }
+        let mut b = Resampler::new(48_000, 24_000).unwrap();
+        let mut chunks = Vec::new();
+        for chunk in input.chunks(37) {
+            for x in chunk {
+                b.push(*x, &mut chunks);
+            }
+        }
+        assert_eq!(all, chunks);
+        assert_eq!(all.len(), 2400);
+        assert!(all.iter().all(|s| s.is_finite()));
+    }
+}
diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs
new file mode 100644
index 0000000000..642e755ee6
--- /dev/null
+++ b/crates/audio/src/lib.rs
@@ -0,0 +1,79 @@
+//! Desktop-only bounded audio. PCM is ephemeral; no logs, files or network I/O.
+#[cfg(feature = "aec")]
+pub mod aec;
+pub mod dsp;
+#[cfg(feature = "native")]
+pub mod native;
+#[cfg(all(feature = "aec", feature = "native"))]
+pub mod worker;
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use zeron_proto::voice::*;
+
+#[derive(Debug, thiserror::Error)]
+pub enum AudioError {
+    #[error("audio device unavailable or unsupported")]
+    Device,
+    #[error("audio buffer overflow")]
+    Overflow,
+    #[error("invalid audio format or frame")]
+    Frame,
+}
+pub fn decode(frame: &VoiceFrame) -> Result<Vec<f32>, AudioError> {
+    if frame.data.len() > MAX_AUDIO_BYTES.div_ceil(3) * 4 {
+        return Err(AudioError::Frame);
+    }
+    let bytes = STANDARD
+        .decode(&frame.data)
+        .map_err(|_| AudioError::Frame)?;
+    if !frame.format.validate(bytes.len()) {
+        return Err(AudioError::Frame);
+    }
+    Ok(bytes
+        .chunks_exact(2)
+        .map(|b| i16::from_le_bytes([b[0], b[1]]) as f32 / 32768.0)
+        .collect())
+}
+pub fn encode(samples: &[f32], generation: u64, sequence: u64) -> Result<VoiceFrame, AudioError> {
+    if samples.is_empty() || samples.len() * 2 > MAX_AUDIO_BYTES {
+        return Err(AudioError::Frame);
+    }
+    let bytes: Vec<_> = samples
+        .iter()
+        .flat_map(|s| {
+            let value = if s.is_finite() {
+                (s.clamp(-1.0, 1.0) * 32767.0) as i16
+            } else {
+                0
+            };
+            value.to_le_bytes()
+        })
+        .collect();
+    Ok(VoiceFrame {
+        generation,
+        sequence,
+        format: VoiceFormat {
+            encoding: VoiceEncoding::Pcm16Le,
+            sample_rate: 24_000,
+            channels: 1,
+        },
+        data: STANDARD.encode(bytes),
+        item_id: None,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn codec_bounds_endian_and_nan() {
+        let f = encode(&[0.0, 0.5, -0.5, f32::NAN], 7, 8).unwrap();
+        let samples = decode(&f).unwrap();
+        assert!((samples[1] - 0.5).abs() < 0.0001);
+        assert!((samples[2] + 0.5).abs() < 0.0001);
+        assert_eq!(samples[3], 0.0);
+        let mut invalid = f.clone();
+        invalid.data = "A".into();
+        assert!(decode(&invalid).is_err());
+        assert!(encode(&vec![0.0; MAX_AUDIO_BYTES], 1, 1).is_err());
+    }
+}
diff --git a/crates/audio/src/native.rs b/crates/audio/src/native.rs
new file mode 100644
index 0000000000..30233a6414
--- /dev/null
+++ b/crates/audio/src/native.rs
@@ -0,0 +1,248 @@
+//! CPAL streams: callbacks touch only preallocated lock-free rings and atomics.
+use crate::{AudioError, dsp::Resampler};
+use cpal::{
+    FromSample, Sample, SampleFormat, SizedSample, Stream, StreamConfig,
+    traits::{DeviceTrait, HostTrait, StreamTrait},
+};
+use crossbeam_queue::ArrayQueue;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+
+const MAX_RING_SAMPLES: usize = 38_400;
+fn ring_samples(rate: u32) -> usize {
+    (rate as usize / 5).min(MAX_RING_SAMPLES)
+}
+#[derive(Clone, Copy)]
+struct OutputSample {
+    generation: u64,
+    value: f32,
+}
+/// Open returns paused streams. Caller starts after explicit user action and
+/// eligibility; merely constructing preferences must never open a microphone.
+pub struct AudioIo {
+    input: Stream,
+    output: Stream,
+    pub capture: Arc<ArrayQueue<f32>>,
+    pub reference: Arc<ArrayQueue<f32>>,
+    playout: Arc<ArrayQueue<OutputSample>>,
+    pub failed: Arc<AtomicBool>,
+    pub muted: Arc<AtomicBool>,
+    generation: Arc<AtomicU64>,
+    pub input_rate: u32,
+    pub output_rate: u32,
+    output_resampler: Resampler,
+    scratch: Vec<f32>,
+}
+impl AudioIo {
+    pub fn open(generation: u64) -> Result<Self, AudioError> {
+        let host = cpal::default_host();
+        let input_device = host.default_input_device().ok_or(AudioError::Device)?;
+        let output_device = host.default_output_device().ok_or(AudioError::Device)?;
+        let input_config = input_device
+            .default_input_config()
+            .map_err(|_| AudioError::Device)?;
+        let output_config = output_device
+            .default_output_config()
+            .map_err(|_| AudioError::Device)?;
+        let input_rate = input_config.sample_rate();
+        let output_rate = output_config.sample_rate();
+        let capture = Arc::new(ArrayQueue::new(ring_samples(input_rate)));
+        let reference = Arc::new(ArrayQueue::new(ring_samples(output_rate)));
+        let playout = Arc::new(ArrayQueue::new(ring_samples(output_rate)));
+        let failed = Arc::new(AtomicBool::new(false));
+        let muted = Arc::new(AtomicBool::new(false));
+        let generation = Arc::new(AtomicU64::new(generation));
+        let ic: StreamConfig = input_config.clone().into();
+        let oc: StreamConfig = output_config.clone().into();
+        if ic.channels == 0 || oc.channels == 0 || ic.channels > 8 || oc.channels > 8 {
+            return Err(AudioError::Device);
+        }
+        let output_resampler = Resampler::new(24_000, output_rate).ok_or(AudioError::Device)?;
+        if Resampler::new(input_rate, 48_000).is_none() {
+            return Err(AudioError::Device);
+        }
+        macro_rules! input {
+            ($t:ty) => {
+                input_stream::<$t>(
+                    &input_device,
+                    ic,
+                    capture.clone(),
+                    failed.clone(),
+                    muted.clone(),
+                )?
+            };
+        }
+        macro_rules! output {
+            ($t:ty) => {
+                output_stream::<$t>(
+                    &output_device,
+                    oc,
+                    playout.clone(),
+                    reference.clone(),
+                    failed.clone(),
+                    generation.clone(),
+                )?
+            };
+        }
+        let input = match input_config.sample_format() {
+            SampleFormat::F32 => input!(f32),
+            SampleFormat::F64 => input!(f64),
+            SampleFormat::I16 => input!(i16),
+            SampleFormat::U16 => input!(u16),
+            SampleFormat::I32 => input!(i32),
+            SampleFormat::U32 => input!(u32),
+            SampleFormat::I8 => input!(i8),
+            SampleFormat::U8 => input!(u8),
+            _ => return Err(AudioError::Device),
+        };
+        let output = match output_config.sample_format() {
+            SampleFormat::F32 => output!(f32),
+            SampleFormat::F64 => output!(f64),
+            SampleFormat::I16 => output!(i16),
+            SampleFormat::U16 => output!(u16),
+            SampleFormat::I32 => output!(i32),
+            SampleFormat::U32 => output!(u32),
+            SampleFormat::I8 => output!(i8),
+            SampleFormat::U8 => output!(u8),
+            _ => return Err(AudioError::Device),
+        };
+        Ok(Self {
+            input,
+            output,
+            capture,
+            reference,
+            playout,
+            failed,
+            muted,
+            generation,
+            input_rate,
+            output_rate,
+            output_resampler,
+            scratch: Vec::with_capacity(MAX_RING_SAMPLES),
+        })
+    }
+    pub fn start(&self) -> Result<(), AudioError> {
+        self.output.play().map_err(|_| AudioError::Device)?;
+        if self.input.play().is_err() {
+            let _ = self.output.pause();
+            return Err(AudioError::Device);
+        }
+        Ok(())
+    }
+    pub fn enqueue(&mut self, frame: &zeron_proto::voice::VoiceFrame) -> Result<(), AudioError> {
+        if frame.generation != self.generation.load(Ordering::Acquire) {
+            return Err(AudioError::Frame);
+        }
+        let samples = crate::decode(frame)?;
+        self.scratch.clear();
+        for sample in samples {
+            self.output_resampler.push(sample, &mut self.scratch);
+        }
+        if self.scratch.len() > self.playout.capacity() - self.playout.len() {
+            return Err(AudioError::Overflow);
+        }
+        for value in &self.scratch {
+            self.playout
+                .push(OutputSample {
+                    generation: frame.generation,
+                    value: *value,
+                })
+                .map_err(|_| AudioError::Overflow)?;
+        }
+        Ok(())
+    }
+    pub fn mute(&self, value: bool) {
+        self.muted.store(value, Ordering::Release);
+        while self.capture.pop().is_some() {}
+    }
+    pub fn flush(&mut self, next_generation: u64) {
+        self.generation.store(next_generation, Ordering::Release);
+        while self.playout.pop().is_some() {}
+        while self.reference.pop().is_some() {}
+        while self.capture.pop().is_some() {}
+        self.output_resampler = Resampler::new(24_000, self.output_rate).unwrap();
+    }
+}
+impl Drop for AudioIo {
+    fn drop(&mut self) {
+        self.muted.store(true, Ordering::Release);
+        let _ = self.input.pause();
+        let _ = self.output.pause();
+        self.generation.fetch_add(1, Ordering::AcqRel);
+        while self.playout.pop().is_some() {}
+    }
+}
+fn input_stream<T>(
+    device: &cpal::Device,
+    config: StreamConfig,
+    ring: Arc<ArrayQueue<f32>>,
+    failed: Arc<AtomicBool>,
+    muted: Arc<AtomicBool>,
+) -> Result<Stream, AudioError>
+where
+    T: SizedSample,
+    f32: FromSample<T>,
+{
+    let channels = config.channels as usize;
+    let errors = failed.clone();
+    device
+        .build_input_stream(
+            config,
+            move |samples: &[T], _| {
+                if muted.load(Ordering::Acquire) {
+                    return;
+                }
+                for frame in samples.chunks_exact(channels) {
+                    let mono =
+                        frame.iter().map(|s| f32::from_sample(*s)).sum::<f32>() / channels as f32;
+                    if ring.push(mono).is_err() {
+                        failed.store(true, Ordering::Release);
+                        break;
+                    }
+                }
+            },
+            move |_| {
+                errors.store(true, Ordering::Release);
+            },
+            Some(std::time::Duration::from_secs(2)),
+        )
+        .map_err(|_| AudioError::Device)
+}
+fn output_stream<T>(
+    device: &cpal::Device,
+    config: StreamConfig,
+    ring: Arc<ArrayQueue<OutputSample>>,
+    reference: Arc<ArrayQueue<f32>>,
+    failed: Arc<AtomicBool>,
+    generation: Arc<AtomicU64>,
+) -> Result<Stream, AudioError>
+where
+    T: SizedSample + FromSample<f32>,
+{
+    let channels = config.channels as usize;
+    let errors = failed.clone();
+    device
+        .build_output_stream(
+            config,
+            move |samples: &mut [T], _| {
+                for frame in samples.chunks_exact_mut(channels) {
+                    let value = ring
+                        .pop()
+                        .filter(|s| s.generation == generation.load(Ordering::Acquire))
+                        .map_or(0.0, |s| s.value);
+                    for sample in frame {
+                        *sample = T::from_sample(value);
+                    }
+                    // Exactly what was sent to the device, including underrun silence.
+                    if reference.push(value).is_err() {
+                        failed.store(true, Ordering::Release);
+                    }
+                }
+            },
+            move |_| {
+                errors.store(true, Ordering::Release);
+            },
+            Some(std::time::Duration::from_secs(2)),
+        )
+        .map_err(|_| AudioError::Device)
+}
diff --git a/crates/audio/src/worker.rs b/crates/audio/src/worker.rs
new file mode 100644
index 0000000000..7377373941
--- /dev/null
+++ b/crates/audio/src/worker.rs
@@ -0,0 +1,104 @@
+//! Poll on an audio worker, never GPUI or a hardware callback. Exact 10 ms
+//! DSP windows retain partial frames between polls; network frames are 20 ms.
+use crate::{
+    AudioError,
+    aec::{DSP_SAMPLES, EchoProcessor},
+    dsp::Resampler,
+    native::AudioIo,
+};
+use std::collections::VecDeque;
+use std::sync::atomic::Ordering;
+use zeron_proto::voice::VoiceFrame;
+
+pub struct AudioWorker {
+    pub io: AudioIo,
+    echo: EchoProcessor,
+    mic_resampler: Resampler,
+    reference_resampler: Resampler,
+    mic: VecDeque<f32>,
+    reference: VecDeque<f32>,
+    network: Vec<f32>,
+    scratch: Vec<f32>,
+    generation: u64,
+    sequence: u64,
+}
+impl AudioWorker {
+    pub fn open(generation: u64) -> Result<Self, AudioError> {
+        let io = AudioIo::open(generation)?;
+        Ok(Self {
+            echo: EchoProcessor::new()?,
+            mic_resampler: Resampler::new(io.input_rate, 48_000).ok_or(AudioError::Device)?,
+            reference_resampler: Resampler::new(io.output_rate, 48_000)
+                .ok_or(AudioError::Device)?,
+            io,
+            mic: VecDeque::with_capacity(9600),
+            reference: VecDeque::with_capacity(9600),
+            network: Vec::with_capacity(480),
+            scratch: Vec::with_capacity(8),
+            generation,
+            sequence: 0,
+        })
+    }
+    pub fn poll(&mut self) -> Result<Vec<VoiceFrame>, AudioError> {
+        if self.io.failed.load(Ordering::Acquire) {
+            return Err(AudioError::Device);
+        }
+        while let Some(sample) = self.io.reference.pop() {
+            self.scratch.clear();
+            self.reference_resampler.push(sample, &mut self.scratch);
+            self.reference.extend(self.scratch.iter().copied());
+            if self.reference.len() > 9600 {
+                return Err(AudioError::Overflow);
+            }
+        }
+        while self.reference.len() >= DSP_SAMPLES {
+            let frame = std::array::from_fn(|_| self.reference.pop_front().unwrap());
+            self.echo.render(&frame)?;
+        }
+        if self.io.muted.load(Ordering::Acquire) {
+            while self.io.capture.pop().is_some() {}
+            self.mic.clear();
+            self.network.clear();
+            self.mic_resampler = Resampler::new(self.io.input_rate, 48_000).unwrap();
+            return Ok(Vec::new());
+        }
+        while let Some(sample) = self.io.capture.pop() {
+            self.scratch.clear();
+            self.mic_resampler.push(sample, &mut self.scratch);
+            self.mic.extend(self.scratch.iter().copied());
+            if self.mic.len() > 9600 {
+                return Err(AudioError::Overflow);
+            }
+        }
+        let mut frames = Vec::with_capacity(10);
+        while self.mic.len() >= DSP_SAMPLES {
+            let mut frame = std::array::from_fn(|_| self.mic.pop_front().unwrap());
+            self.echo.capture(&mut frame)?;
+            // Exact 48 -> 24 kHz decimation with a pair average after AEC.
+            self.network
+                .extend(frame.chunks_exact(2).map(|s| (s[0] + s[1]) * 0.5));
+            if self.network.len() == 480 {
+                self.sequence += 1;
+                frames.push(crate::encode(
+                    &self.network,
+                    self.generation,
+                    self.sequence,
+                )?);
+                self.network.clear();
+            }
+        }
+        Ok(frames)
+    }
+    pub fn invalidate_playout(&mut self, next_generation: u64) -> Result<(), AudioError> {
+        self.io.flush(next_generation);
+        self.echo.reset()?;
+        self.generation = next_generation;
+        self.sequence = 0;
+        self.mic.clear();
+        self.reference.clear();
+        self.network.clear();
+        self.mic_resampler = Resampler::new(self.io.input_rate, 48_000).unwrap();
+        self.reference_resampler = Resampler::new(self.io.output_rate, 48_000).unwrap();
+        Ok(())
+    }
+}
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index 34c213e71d..2187afa34a 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -12,6 +12,7 @@ publish.workspace = true
 # frontend (iOS, Android, tests, CLIs).
 
 [dependencies]
+zeron-voice-session.workspace = true
 zeron-proto.workspace = true
 zeron-doc.workspace = true
 zeron-sync.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index d43669c15a..0d075c8afa 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -556,6 +556,21 @@ impl std::fmt::Debug for Client {
 }
 
 impl Client {
+    /// Dedicated ephemeral call handle; never uses durable commands or RPC retries.
+    pub async fn voice_transport(
+        &self,
+        device_id: &str,
+    ) -> Result<Arc<zeron_voice_session::RpcTransport>> {
+        let live = self.inner.live().ok_or_else(|| {
+            ClientError::Unsupported("remote voice requires a connected account".into())
+        })?;
+        live.relay.voice_transport(device_id).await
+    }
+    /// Sign-out/shutdown closes every call created by this client.
+    pub fn voice_cancellation(&self) -> CancellationToken {
+        self.inner.cancel.child_token()
+    }
+
     /// Build and start. Never blocks on the network: live mode hydrates from
     /// `data_dir` and connects in the background; Demo seeds its dataset.
     pub fn new(
diff --git a/crates/client/src/live/relay.rs b/crates/client/src/live/relay.rs
index f1ae1c46fc..0e03e13bda 100644
--- a/crates/client/src/live/relay.rs
+++ b/crates/client/src/live/relay.rs
@@ -65,6 +65,21 @@ pub(crate) struct WatchKey {
 }
 
 impl Relay {
+    pub(crate) async fn voice_transport(
+        &self,
+        device_id: &str,
+    ) -> Result<Arc<zeron_voice_session::RpcTransport>> {
+        let client = self
+            .links
+            .client(device_id)
+            .await
+            .map_err(|e| map_rpc(device_id, methods::VOICE_CAPABILITIES_V2, e))?;
+        Ok(Arc::new(zeron_voice_session::RpcTransport {
+            client,
+            host: device_id.into(),
+        }))
+    }
+
     pub(crate) fn new(inner: &Arc<ClientInner>, edge: &str, bearer: Bearer) -> Self {
         let weak = Arc::downgrade(inner);
         let started = now_ms();
diff --git a/crates/client/src/workspace/view.rs b/crates/client/src/workspace/view.rs
index 078ad4042b..9838658a76 100644
--- a/crates/client/src/workspace/view.rs
+++ b/crates/client/src/workspace/view.rs
@@ -567,7 +567,7 @@ pub(crate) fn derive(
     let mut active: Vec<&Chat> = state
         .chats
         .iter()
-        .filter(|c| !c.archived && c.parent_chat_id.is_none())
+        .filter(|c| !c.archived && c.is_top_level())
         .filter(|c| {
             c.space_id
                 .as_deref()
@@ -674,7 +674,7 @@ pub(crate) fn derive(
     let mut archived_chats: Vec<&Chat> = state
         .chats
         .iter()
-        .filter(|c| c.archived && c.parent_chat_id.is_none())
+        .filter(|c| c.archived && c.is_top_level())
         .collect();
     sort_recency(&mut archived_chats);
     let archived: Vec<Arc<SessionRow>> = archived_chats.iter().map(|c| row(c)).collect();
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 8c52c58501..f03251e5a2 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -16,6 +16,7 @@ pub mod rebuild;
 pub mod registry;
 pub mod schema;
 pub mod transcript_delta;
+pub mod voice;
 pub mod workspace;
 
 pub use commands::*;
diff --git a/crates/doc/src/voice.rs b/crates/doc/src/voice.rs
new file mode 100644
index 0000000000..c9d9363e75
--- /dev/null
+++ b/crates/doc/src/voice.rs
@@ -0,0 +1,112 @@
+//! Canonical final text reducer. Call from the engine's serialized document
+//! owner; this never submits a command and never accepts PCM or partial text.
+use crate::{DocError, MessagePart, MessageRole, MessageStatus, SessionDoc, SessionMessageEntry};
+use zeron_proto::voice::{MAX_TRANSCRIPT_BYTES, VoiceRole, VoiceTranscript};
+
+pub fn commit_voice_transcript(
+    doc: &SessionDoc,
+    final_text: &VoiceTranscript,
+    device: &str,
+    created_at: i64,
+) -> Result<Option<String>, DocError> {
+    if final_text.text.len() > MAX_TRANSCRIPT_BYTES
+        || final_text.session_id.is_empty()
+        || final_text.item_id.is_empty()
+        || final_text.session_id.len() > 256
+        || final_text.item_id.len() > 256
+    {
+        return Err(DocError::Schema(
+            "invalid canonical voice transcript".into(),
+        ));
+    }
+    if final_text.text.trim().is_empty() {
+        return Ok(None);
+    }
+    // Length-prefixing prevents collisions if a provider id contains ':';
+    // identity is unrelated to text, so two identical phrases stay two items.
+    let id = format!(
+        "voice:{}:{}:{}",
+        final_text.session_id.len(),
+        final_text.session_id,
+        final_text.item_id
+    );
+    let entries = doc.read_entries()?;
+    if entries.iter().any(|entry| entry.id == id) {
+        return Ok(None);
+    }
+    if let Some(promoted) = &final_text.promoted_message_id {
+        // Promotion must point to an existing native record. Never silently
+        // create a duplicate when it arrives out of order; retry after routing.
+        return if entries.iter().any(|entry| &entry.id == promoted) {
+            Ok(None)
+        } else {
+            Err(DocError::Schema(
+                "voice promotion precedes native message".into(),
+            ))
+        };
+    }
+    doc.push_message(&SessionMessageEntry {
+        id: id.clone(),
+        role: match final_text.role {
+            VoiceRole::User => MessageRole::User,
+            VoiceRole::Assistant => MessageRole::Assistant,
+        },
+        parts: vec![MessagePart::Text {
+            id: "t0".into(),
+            text: final_text.text.clone(),
+        }],
+        created_at,
+        device_id: device.into(),
+        status: Some(MessageStatus::Complete),
+        continuation_of: None,
+        duration_ms: None,
+    })?;
+    Ok(Some(id))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use loro::ToJson;
+    #[test]
+    fn final_identity_survives_replay_and_snapshot_without_commands_or_audio() {
+        let doc = SessionDoc::init("chat").unwrap();
+        let mut text = VoiceTranscript {
+            session_id: "session".into(),
+            item_id: "one".into(),
+            role: VoiceRole::User,
+            text: "create a chat".into(),
+            promoted_message_id: None,
+        };
+        assert!(
+            commit_voice_transcript(&doc, &text, "device", 1)
+                .unwrap()
+                .is_some()
+        );
+        assert!(
+            commit_voice_transcript(&doc, &text, "device", 2)
+                .unwrap()
+                .is_none()
+        );
+        text.item_id = "two".into();
+        assert!(
+            commit_voice_transcript(&doc, &text, "device", 3)
+                .unwrap()
+                .is_some()
+        );
+        let snapshot = doc.doc().export(loro::ExportMode::Snapshot).unwrap();
+        let restored = loro::LoroDoc::new();
+        restored.import(&snapshot).unwrap();
+        let restored = SessionDoc::from_doc(restored);
+        assert_eq!(restored.read_entries().unwrap().len(), 2);
+        assert!(
+            commit_voice_transcript(&restored, &text, "device", 4)
+                .unwrap()
+                .is_none()
+        );
+        let json = restored.doc().get_deep_value().to_json_value().to_string();
+        assert!(!json.contains("leaseToken"));
+        assert!(!json.contains("sampleRate"));
+        assert!(!json.contains("Submit"));
+    }
+}
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index 1a685d2554..d74bd6d0c0 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -43,6 +43,7 @@ tempfile.workspace = true
 windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_Pipes", "Win32_System_Threading"] }
 
 [dev-dependencies]
+tokio = { workspace = true, features = ["test-util"] }
 zeron-mcp.workspace = true
 zeron-harness = { workspace = true, features = ["installer-fixture"] }
 zip.workspace = true
diff --git a/crates/engine/src/diff_sync.rs b/crates/engine/src/diff_sync.rs
index e9cb782daf..8f2796d9b8 100644
--- a/crates/engine/src/diff_sync.rs
+++ b/crates/engine/src/diff_sync.rs
@@ -850,7 +850,9 @@ async fn capture_git(cwd: &Path, args: &[&str], max_bytes: usize) -> Result<Capt
         .take()
         .ok_or_else(|| EngineError::Other("git stdout unavailable".into()))?;
     let mut out: Vec<u8> = Vec::new();
-    let mut buf = [0u8; 64 * 1024];
+    // Keep the read buffer out of nested async state: inline storage grows
+    // every caller's future and can overflow a standard RPC worker's stack.
+    let mut buf = vec![0u8; 64 * 1024];
     let mut truncated = false;
     loop {
         let n = stdout
diff --git a/crates/engine/src/doc_host.rs b/crates/engine/src/doc_host.rs
index bffa3545f0..fcf4c7377b 100644
--- a/crates/engine/src/doc_host.rs
+++ b/crates/engine/src/doc_host.rs
@@ -409,9 +409,7 @@ impl ChatConnectionSnapshot {
             sync_requested,
             stats: client.as_ref().map(|client| client.stats()),
             delivery_live: sync_started
-                && client
-                    .as_ref()
-                    .is_some_and(|client| client.delivery_live()),
+                && client.as_ref().is_some_and(|client| client.delivery_live()),
         }
     }
 
@@ -664,6 +662,20 @@ impl ChatDocHandle {
         &self.chat_id
     }
 
+    pub(crate) fn commit_voice(
+        &self,
+        transcript: &zeron_proto::voice::VoiceTranscript,
+    ) -> Result<Option<String>, EngineError> {
+        let _owner = lock(&self.transcript_import);
+        zeron_doc::voice::commit_voice_transcript(
+            &self.doc,
+            transcript,
+            &self.device_id,
+            chrono::Utc::now().timestamp_millis(),
+        )
+        .map_err(EngineError::from)
+    }
+
     pub fn doc(&self) -> &SessionDoc {
         &self.doc
     }
@@ -5526,11 +5538,6 @@ impl DocHost {
             .await
     }
 
-    /// Create (or reuse) the isolated worktree a Run's [`zeron_proto::WorktreeSpec`]
-    /// asks for, returning the resolved cwd plus the fresh worktree when one was
-    /// actually created. Reuse guard: a chat whose row already points inside a
-    /// linked worktree of the same repo keeps it — a duplicate Run (client retry
-    /// after a lost ack, ledger reset) must not mint a second checkout.
     async fn materialize_worktree(
         &self,
         chat_id: &str,
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 2f4c74b653..23da6a3804 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -40,6 +40,7 @@ pub mod terminals;
 pub mod titles;
 mod transcript_history;
 pub mod uploads;
+pub mod voice;
 pub mod workspace_files;
 pub mod workspace_host;
 
diff --git a/crates/engine/src/rpc.rs b/crates/engine/src/rpc.rs
index be5d0666fe..4ddbcbc6c5 100644
--- a/crates/engine/src/rpc.rs
+++ b/crates/engine/src/rpc.rs
@@ -50,6 +50,8 @@
 //! handlers stay transport-agnostic. This includes the workspace file surface,
 //! whose checkout always lives on the routed target device.
 
+mod voice_chat;
+mod voice_remote;
 use async_trait::async_trait;
 use base64::Engine as _;
 use futures::StreamExt;
@@ -607,7 +609,9 @@ enum MutateParams {
     },
 }
 
+#[derive(Clone)]
 pub struct EngineRpc {
+    voice: crate::voice::VoiceManager,
     sessions: SessionsEngine,
     doc_host: DocHost,
     workspace: WorkspaceHost,
@@ -653,6 +657,7 @@ impl EngineRpc {
             capabilities: zeron_proto::capabilities::current(),
         };
         Self {
+            voice: sessions.voice_manager(),
             sessions,
             doc_host,
             workspace,
@@ -1028,7 +1033,8 @@ impl EngineRpc {
             // only unary calls below get the reply deadline.
             if matches!(
                 method,
-                methods::WATCH_CHECKOUT_CHANGE_REQUEST
+                methods::OWN_VOICE_V2
+                    | methods::WATCH_CHECKOUT_CHANGE_REQUEST
                     | methods::WATCH_WORKSPACE_GIT_STATUS
                     | methods::WATCH_HARNESS_UPDATES
             ) {
@@ -1088,6 +1094,42 @@ impl EngineRpc {
         }
     }
 
+    async fn prepare_voice_bridge(
+        &self,
+        chat: &str,
+    ) -> Result<
+        (
+            zeron_harness::codex::realtime::RealtimeHandle,
+            tokio::sync::broadcast::Receiver<zeron_proto::voice::VoiceEvent>,
+            std::sync::Arc<crate::sessions::VoiceActivity>,
+        ),
+        zeron_proto::voice::VoiceRejection,
+    > {
+        use zeron_proto::voice::VoiceRejection;
+        // Without Codex here a retry can never connect: ask for an install.
+        if !self
+            .registry
+            .resolve(HarnessId::Codex)
+            .is_ok_and(|codex| codex.installed())
+        {
+            return Err(VoiceRejection::NativeRuntimeUnavailable);
+        }
+        let mut request = self
+            .doc_host
+            .request_from_chat_row(chat, "")
+            .ok_or(VoiceRejection::Unsupported)?;
+        if request.cwd.is_empty() {
+            request.cwd = "~".into();
+        }
+        self.sessions
+            .start_idle(chat, request)
+            .await
+            .map_err(|_| VoiceRejection::Unsupported)?;
+        self.sessions
+            .take_voice_bridge(chat)
+            .ok_or(VoiceRejection::Unsupported)
+    }
+
     fn mutate(&self, params: MutateParams) -> Result<(), RpcError> {
         let failed = |e: crate::EngineError| RpcError::Failed(e.to_string());
         match params {
@@ -1100,6 +1142,10 @@ impl EngineRpc {
                 cwd,
                 parent_chat_id,
             } => {
+                // A voice orchestrator is hidden, so the chats it creates are
+                // the user's top-level sessions rather than its side chats.
+                let parent_chat_id = parent_chat_id
+                    .filter(|parent| !zeron_proto::voice::is_orchestrator_chat(parent));
                 self.workspace
                     .create_chat_with_parent(
                         &chat_id,
@@ -1160,11 +1206,13 @@ impl EngineRpc {
                 .set_chat_branch(&chat_id, &branch)
                 .map_err(failed)
                 .map(drop),
-            MutateParams::SetChatCwd { chat_id, cwd } => self
-                .workspace
-                .set_chat_cwd(&chat_id, &cwd)
-                .map_err(failed)
-                .map(drop),
+            MutateParams::SetChatCwd { chat_id, cwd } => {
+                self.voice.retire_chat(&chat_id);
+                self.workspace
+                    .set_chat_cwd(&chat_id, &cwd)
+                    .map_err(failed)
+                    .map(drop)
+            }
             MutateParams::SetChatActivity {
                 chat_id,
                 last_message_at,
@@ -1174,11 +1222,13 @@ impl EngineRpc {
                 .set_chat_activity(&chat_id, last_message_at, created_at)
                 .map_err(failed)
                 .map(drop),
-            MutateParams::SetChatHost { chat_id, device_id } => self
-                .workspace
-                .set_chat_host(&chat_id, &device_id)
-                .map_err(failed)
-                .map(drop),
+            MutateParams::SetChatHost { chat_id, device_id } => {
+                self.voice.retire_chat(&chat_id);
+                self.workspace
+                    .set_chat_host(&chat_id, &device_id)
+                    .map_err(failed)
+                    .map(drop)
+            }
             MutateParams::SetChatArchived { chat_id, archived } => self
                 .workspace
                 .set_chat_archived(&chat_id, archived)
@@ -1187,12 +1237,15 @@ impl EngineRpc {
             MutateParams::ChangeSidebarPin { change } => {
                 self.workspace.change_sidebar_pin(&change).map_err(failed)
             }
-            MutateParams::SetChatConfig { chat_id, config } => self
-                .workspace
-                .set_chat_config(&chat_id, &config)
-                .map_err(failed)
-                .map(drop),
+            MutateParams::SetChatConfig { chat_id, config } => {
+                self.voice.retire_chat(&chat_id);
+                self.workspace
+                    .set_chat_config(&chat_id, &config)
+                    .map_err(failed)
+                    .map(drop)
+            }
             MutateParams::DeleteChat { chat_id } => {
+                self.voice.retire_chat(&chat_id);
                 self.workspace.delete_chat(&chat_id).map_err(failed)?;
                 self.doc_host.purge_chat(&chat_id);
                 Ok(())
@@ -1307,6 +1360,12 @@ where
 }
 
 fn forward_deadline(method: &str) -> std::time::Duration {
+    if method == methods::PREPARE_VOICE_V2 {
+        return Duration::from_secs(65);
+    }
+    if method == methods::NEGOTIATE_VOICE_V2 {
+        return Duration::from_secs(95);
+    }
     use std::time::Duration;
     match method {
         methods::CLONE_REPO | methods::FETCH_ALL | methods::APPLY_UPDATE => {
@@ -1334,6 +1393,9 @@ const LOGIN_TUNNEL_TTL: Duration = Duration::from_secs(15 * 60);
 /// list (plus [`is_stream_method`] for streams) to make more of the surface
 /// device-addressable — the handlers themselves need no changes.
 fn forwardable(method: &str) -> bool {
+    if voice_remote::handles(method) {
+        return true;
+    }
     matches!(
         method,
         methods::FORK_SIDE_CHAT
@@ -1432,6 +1494,9 @@ fn forwardable(method: &str) -> bool {
 
 /// Forwardable methods whose reply is a stream (proxied item-by-item).
 fn is_stream_method(method: &str) -> bool {
+    if method == methods::OWN_VOICE_V2 {
+        return true;
+    }
     matches!(
         method,
         methods::WATCH_DOC_MESSAGES
@@ -1702,6 +1767,19 @@ impl RpcService for EngineRpc {
             }
             return self.forward(&target, method, params).await;
         }
+        if matches!(
+            method,
+            methods::SIGN_OUT
+                | methods::SELECT_ORG
+                | methods::COMPLETE_AGENT_LOGIN
+                | methods::ACTIVATE_AGENT_ACCOUNT
+                | methods::FORGET_AGENT_ACCOUNT
+        ) {
+            self.voice.retire();
+        }
+        if voice_remote::handles(method) {
+            return self.voice_remote(method, params).await;
+        }
         if AuthRpc::handles(method) {
             return AuthRpc::new(self.auth()?.clone())
                 .handle(method, params)
@@ -1883,7 +1961,11 @@ impl RpcService for EngineRpc {
                         "Fork must be created on the source device".into(),
                     ));
                 }
-                if let Some(existing) = self.workspace.chat(&p.chat_id).map_err(failed)? {
+                if let Some(existing) = self
+                    .workspace
+                    .chat(&p.chat_id)
+                    .map_err(|e| RpcError::Failed(e.to_string()))?
+                {
                     if existing.parent_chat_id.as_deref() == Some(parent_chat_id.as_str()) {
                         return RpcReply::value(&existing);
                     }
@@ -3293,6 +3375,7 @@ impl RpcService for EngineRpc {
                 RpcReply::value(&snapshot)
             }
             methods::ACTIVATE_AGENT_ACCOUNT => {
+                self.voice.retire();
                 let p: AgentAccountParams = parse_params(params)?;
                 let snapshot = self
                     .agent_accounts
@@ -3302,6 +3385,7 @@ impl RpcService for EngineRpc {
                 RpcReply::value(&snapshot)
             }
             methods::FORGET_AGENT_ACCOUNT => {
+                self.voice.retire();
                 let p: AgentAccountParams = parse_params(params)?;
                 let snapshot = self
                     .agent_accounts
@@ -3403,6 +3487,99 @@ impl RpcService for EngineRpc {
 mod tests {
     use super::*;
 
+    #[tokio::test]
+    async fn voice_owner_is_shared_across_services_and_shutdown_retires_it() {
+        let temp = tempfile::tempdir().unwrap();
+        let core = crate::EngineCore::assemble_with_profile(
+            crate::EngineProfile::local(temp.path()).unwrap(),
+            std::sync::Arc::new(HarnessRegistry::new()),
+            HarnessId::Codex,
+            None,
+        )
+        .unwrap();
+        let first = core.rpc_service();
+        let second = core.rpc_service();
+        let lease = first.voice.reserve("chat").unwrap();
+        assert!(second.voice.owns_chat("chat"));
+        assert_eq!(
+            second.voice.reserve("other").unwrap_err(),
+            zeron_proto::voice::VoiceRejection::Busy
+        );
+        let owner = second.voice.own(lease).unwrap();
+        core.sessions.shutdown().await;
+        assert!(!first.voice.owns_chat("chat"));
+        drop(owner);
+    }
+
+    #[tokio::test]
+    async fn chats_created_by_a_voice_orchestrator_are_top_level() {
+        let temp = tempfile::tempdir().unwrap();
+        let core = crate::EngineCore::assemble_with_profile(
+            crate::EngineProfile::local(temp.path()).unwrap(),
+            std::sync::Arc::new(HarnessRegistry::new()),
+            HarnessId::Codex,
+            None,
+        )
+        .unwrap();
+        let rpc = core.rpc_service();
+        let orchestrator = format!("{}1", zeron_proto::voice::ORCHESTRATOR_CHAT_PREFIX);
+        for (chat, parent, expected) in [
+            ("worker", orchestrator.as_str(), None),
+            ("side", "ordinary", Some("ordinary")),
+        ] {
+            rpc.handle(
+                methods::MUTATE,
+                serde_json::json!({"op":"createChat", "chatId":chat,
+                    "parentChatId":parent, "deviceId":core.device_id,
+                    "config":{"harness":"codex","sandbox":"workspace-write"}}),
+            )
+            .await
+            .unwrap();
+            let row = core.workspace.chat(chat).unwrap().unwrap();
+            assert_eq!(row.parent_chat_id.as_deref(), expected);
+        }
+        core.sessions.shutdown().await;
+    }
+
+    #[tokio::test]
+    async fn voice_origin_uses_normal_remote_routing() {
+        let temp = tempfile::tempdir().unwrap();
+        let core = crate::EngineCore::assemble_with_profile(
+            crate::EngineProfile::local(temp.path()).unwrap(),
+            std::sync::Arc::new(HarnessRegistry::new()),
+            HarnessId::Codex,
+            None,
+        )
+        .unwrap();
+        let rpc = core.rpc_service();
+        let lease = rpc.voice.reserve("voice-origin").unwrap();
+        let owner = rpc.voice.own(lease).unwrap();
+        for method in [methods::QUEUE_COMMAND, methods::QUEUE_MESSAGE] {
+            let error = match rpc.handle(method, serde_json::json!({"originChatId":"voice-origin","targetDeviceId":"remote","chatId":"other"})).await {
+                Err(error) => error,
+                Ok(_) => panic!("offline remote routing unexpectedly succeeded"),
+            };
+            assert!(
+                matches!(error, RpcError::Failed(ref message) if message == "cannot reach device remote: remote routing unavailable (offline)")
+            );
+        }
+        // Voice origin follows the same forwarding boundary as ordinary MCP
+        // calls; this fixture has no relay configured.
+        rpc.handle(
+            methods::MUTATE,
+            serde_json::json!({"op":"createChat", "chatId":"remote-grok",
+                "originChatId":"voice-origin", "deviceId":"remote",
+                "config":{"harness":"grok","sandbox":"workspace-write"}}),
+        )
+        .await
+        .unwrap();
+        let chat = core.workspace.chat("remote-grok").unwrap().unwrap();
+        assert_eq!(chat.device_id, "remote");
+        assert_eq!(chat.config.unwrap().harness, HarnessId::Grok);
+        drop(owner);
+        core.sessions.shutdown().await;
+    }
+
     // Each subprocess has private HOME/PATH/overrides, avoiding process-global test races.
     #[cfg(unix)]
     async fn installer_rpc_fixture(mode: &str) {
diff --git a/crates/engine/src/rpc/voice_chat.rs b/crates/engine/src/rpc/voice_chat.rs
new file mode 100644
index 0000000000..401253711c
--- /dev/null
+++ b/crates/engine/src/rpc/voice_chat.rs
@@ -0,0 +1,211 @@
+//! Each host keeps one voice orchestrator chat: every call on this device
+//! resumes it, so the orchestrator remembers earlier calls. Hosts never share
+//! it — another computer has its own. Once the synced transcript passes
+//! [`ROTATE_AFTER`] entries, the next call moves to a fresh chat that inherits
+//! the Codex thread: memory continues, the transcript starts small again. The
+//! old segment is removed only once its successor holds a message.
+use super::*;
+use zeron_proto::voice::{ORCHESTRATOR_CHAT_PREFIX, ORCHESTRATOR_CHAT_TITLE, VoiceRejection};
+use zeron_proto::{Chat, SessionStatus};
+
+/// Transcript entries after which the next call starts a new segment.
+pub(super) const ROTATE_AFTER: usize = 1000;
+
+/// This device's current orchestrator chat: its newest one, if any.
+fn current<'a>(chats: &'a [Chat], device: &str) -> Option<&'a Chat> {
+    chats
+        .iter()
+        .filter(|c| {
+            zeron_proto::voice::is_orchestrator_chat(&c.id) && c.device_id == device && !c.archived
+        })
+        .max_by_key(|c| c.created_at)
+}
+
+impl EngineRpc {
+    /// The chat a call on this device runs in: reused, rotated or created.
+    /// Callers hold the voice preparation lock and have checked that no call
+    /// is live, so nothing is rotated from under one.
+    pub(super) async fn voice_chat(&self, config: ChatConfig) -> Result<String, VoiceRejection> {
+        let device = self.engine_info.device_id.clone();
+        let chats = self
+            .workspace
+            .read_chats()
+            .map_err(|_| VoiceRejection::Protocol)?;
+        let chat = current(&chats, &device).cloned();
+        let Some(chat) = chat else {
+            return self.new_voice_chat(config, None);
+        };
+        // A question left over from an ended call would block this one.
+        if self
+            .sessions
+            .session_status(&chat.id)
+            .is_some_and(|s| s.status == SessionStatus::AwaitingInput)
+        {
+            let _ = self.sessions.interrupt(&chat.id).await;
+        }
+        // Delegated work still running keeps its chat and configuration.
+        if self.sessions.turn_in_flight(&chat.id) {
+            return Ok(chat.id);
+        }
+        let entries = self
+            .doc_host
+            .open(&chat.id)
+            .map_err(|_| VoiceRejection::Protocol)?
+            .doc()
+            .read_entries()
+            .map_err(|_| VoiceRejection::Protocol)?
+            .len();
+        if entries > 0 {
+            self.prune_superseded(&chats, &chat).await;
+        }
+        if entries < ROTATE_AFTER {
+            if chat.config.as_ref() != Some(&config) {
+                // A warm process cannot take another configuration.
+                let _ = self.sessions.interrupt(&chat.id).await;
+                self.workspace
+                    .set_chat_config(&chat.id, &config)
+                    .map_err(|_| VoiceRejection::Protocol)?;
+            }
+            return Ok(chat.id);
+        }
+        // The old segment's warm process holds the Codex thread; stop it before
+        // the next segment resumes the same thread.
+        let _ = self.sessions.interrupt(&chat.id).await;
+        let thread = self
+            .workspace
+            .chat_harness_session(&chat.id)
+            .filter(|(id, _)| !id.is_empty());
+        // The old segment stays until the new one holds a message: a failed
+        // start may remove the empty successor, and then the next call
+        // rotates again from here instead of losing the thread.
+        self.new_voice_chat(config, thread)
+    }
+
+    /// Removes this device's earlier segments of `current`'s Codex thread.
+    /// Orchestrators from other threads (calls before segments) are kept.
+    async fn prune_superseded(&self, chats: &[Chat], current: &Chat) {
+        let Some(thread) = current
+            .harness_session_id
+            .as_deref()
+            .filter(|t| !t.is_empty())
+        else {
+            return;
+        };
+        for old in chats.iter().filter(|c| {
+            c.id != current.id
+                && c.device_id == current.device_id
+                && zeron_proto::voice::is_orchestrator_chat(&c.id)
+                && c.harness_session_id.as_deref() == Some(thread)
+        }) {
+            if self.sessions.turn_in_flight(&old.id) {
+                continue;
+            }
+            let _ = self.sessions.interrupt(&old.id).await;
+            let _ = self.workspace.delete_chat(&old.id);
+            self.doc_host.purge_chat(&old.id);
+        }
+    }
+
+    fn new_voice_chat(
+        &self,
+        config: ChatConfig,
+        thread: Option<(String, Option<String>)>,
+    ) -> Result<String, VoiceRejection> {
+        let chat = format!("{ORCHESTRATOR_CHAT_PREFIX}{}", uuid::Uuid::new_v4());
+        // No space: a projectless chat whose cwd is the host's `~`.
+        self.workspace
+            .create_chat(
+                &chat,
+                None,
+                Some(&self.engine_info.device_id),
+                Some(config),
+                None,
+            )
+            .map_err(|_| VoiceRejection::Protocol)?;
+        // Same title on every host: the transcript is reachable from every
+        // client's voice controls, never an untitled "New session".
+        self.workspace
+            .rename_chat(&chat, ORCHESTRATOR_CHAT_TITLE)
+            .map_err(|_| VoiceRejection::Protocol)?;
+        if let Some((id, cwd)) = thread {
+            self.workspace
+                .set_chat_harness_session(&chat, &id, cwd.as_deref().unwrap_or(""));
+        }
+        Ok(chat)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn config(model: &str) -> ChatConfig {
+        serde_json::from_value(serde_json::json!({
+            "harness": "codex", "model": model, "sandbox": "workspace-write"
+        }))
+        .unwrap()
+    }
+
+    #[tokio::test]
+    async fn calls_reuse_the_hosts_chat_and_rotate_a_long_transcript_keeping_the_thread() {
+        let temp = tempfile::tempdir().unwrap();
+        let core = crate::EngineCore::assemble_with_profile(
+            crate::EngineProfile::local(temp.path()).unwrap(),
+            std::sync::Arc::new(HarnessRegistry::new()),
+            HarnessId::Codex,
+            None,
+        )
+        .unwrap();
+        let rpc = core.rpc_service();
+        // Another host's orchestrator is never this device's.
+        let foreign = format!("{ORCHESTRATOR_CHAT_PREFIX}foreign");
+        core.workspace
+            .create_chat(&foreign, None, Some("other-device"), None, None)
+            .unwrap();
+
+        let first = rpc.voice_chat(config("a")).await.unwrap();
+        assert_ne!(first, foreign);
+        let row = core.workspace.chat(&first).unwrap().unwrap();
+        assert_eq!(row.title.as_deref(), Some(ORCHESTRATOR_CHAT_TITLE));
+        assert_eq!(row.device_id, core.device_id);
+
+        // The next call resumes it, taking the configuration it asks for.
+        assert_eq!(rpc.voice_chat(config("b")).await.unwrap(), first);
+        let row = core.workspace.chat(&first).unwrap().unwrap();
+        assert_eq!(row.config, Some(config("b")));
+
+        core.workspace
+            .set_chat_harness_session(&first, "codex-thread", "/home/me");
+        let doc = core.doc_host.open(&first).unwrap();
+        for i in 0..ROTATE_AFTER {
+            doc.write_user_message(&format!("m{i}"), "hi", i as i64)
+                .unwrap();
+        }
+        let inherited = Some(("codex-thread".into(), Some("/home/me".into())));
+        let next = rpc.voice_chat(config("b")).await.unwrap();
+        assert_ne!(next, first);
+        assert_eq!(core.workspace.chat_harness_session(&next), inherited);
+
+        // A failed start removes its empty successor; the old segment is
+        // still there, so the next call rotates again on the same thread.
+        core.workspace.delete_chat(&next).unwrap();
+        core.doc_host.purge_chat(&next);
+        let retry = rpc.voice_chat(config("b")).await.unwrap();
+        assert!(retry != first && retry != next);
+        assert_eq!(core.workspace.chat_harness_session(&retry), inherited);
+
+        // An empty successor keeps its predecessor; one with a message
+        // supersedes it. Other orchestrators and threads are never touched.
+        assert_eq!(rpc.voice_chat(config("b")).await.unwrap(), retry);
+        assert!(core.workspace.chat(&first).unwrap().is_some());
+        core.doc_host
+            .open(&retry)
+            .unwrap()
+            .write_user_message("hello", "hi", 0)
+            .unwrap();
+        assert_eq!(rpc.voice_chat(config("b")).await.unwrap(), retry);
+        assert!(core.workspace.chat(&first).unwrap().is_none());
+        assert!(core.workspace.chat(&foreign).unwrap().is_some());
+        core.sessions.shutdown().await;
+    }
+}
diff --git a/crates/engine/src/rpc/voice_remote.rs b/crates/engine/src/rpc/voice_remote.rs
new file mode 100644
index 0000000000..3e50da890c
--- /dev/null
+++ b/crates/engine/src/rpc/voice_remote.rs
@@ -0,0 +1,189 @@
+use super::*;
+use zeron_proto::voice::{VoiceRejection, remote as wire};
+
+pub(super) fn handles(method: &str) -> bool {
+    matches!(
+        method,
+        methods::VOICE_CAPABILITIES_V2
+            | methods::PREPARE_VOICE_V2
+            | methods::OWN_VOICE_V2
+            | methods::NEGOTIATE_VOICE_V2
+            | methods::CONFIRM_VOICE_MEDIA_V2
+            | methods::REPORT_VOICE_MEDIA_V2
+            | methods::STOP_VOICE_V2
+            | methods::CANCEL_VOICE_ATTEMPT_V2
+    )
+}
+fn failure(reason: VoiceRejection) -> RpcError {
+    RpcError::Failed(format!("voice unavailable: {reason:?}"))
+}
+
+impl EngineRpc {
+    pub(super) async fn voice_remote(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<RpcReply, RpcError> {
+        let envelope: wire::Envelope<serde_json::Value> = parse_params(params)?;
+        if envelope.target_device_id != self.engine_info.device_id {
+            return Err(failure(VoiceRejection::RemoteHost));
+        }
+        let p = envelope.payload;
+        match method {
+            methods::VOICE_CAPABILITIES_V2 => RpcReply::value(&wire::Capabilities {
+                protocol: wire::CAPABILITY.into(),
+                client_webrtc: true,
+                voices: vec![],
+            }),
+            methods::PREPARE_VOICE_V2 => {
+                let request: wire::Prepare = parse_params(p)?;
+                if request.config.harness != HarnessId::Codex {
+                    return Err(failure(VoiceRejection::WrongHarness));
+                }
+                if request.voice.as_ref().is_some_and(|v| v.len() > 128) {
+                    return Err(failure(VoiceRejection::Protocol));
+                }
+                let (mut rx, start) = self.voice.begin_attempt(&request).map_err(failure)?;
+                if let Some(cancel) = start {
+                    let engine = self.clone();
+                    tokio::spawn(async move {
+                        let key = request.attempt_key.clone();
+                        let mut chat = None;
+                        let result = tokio::select! {biased;
+                            _=cancel.cancelled()=>Err(VoiceRejection::InvalidLease),
+                            r=tokio::time::timeout(Duration::from_secs(60),engine.prepare_remote_voice(request,&mut chat,cancel.clone()))=>r.unwrap_or(Err(VoiceRejection::Protocol)),
+                        };
+                        if let Some(chat) = chat.filter(|chat| {
+                            result.is_err() && engine.workspace.chat(chat).ok().flatten().is_some()
+                        }) {
+                            engine.voice.retire_chat(&chat);
+                            // The chat outlives calls: delegated work it still
+                            // runs survives this failed start.
+                            if !engine.sessions.turn_in_flight(&chat) {
+                                let _ = engine.sessions.interrupt(&chat).await;
+                            }
+                            // Preserve any actual activity; remove only this empty preparation.
+                            if engine
+                                .doc_host
+                                .open(&chat)
+                                .ok()
+                                .is_some_and(|d| d.watch_messages().borrow().entries.is_empty())
+                            {
+                                let _ = engine.workspace.delete_chat(&chat);
+                            }
+                        }
+                        engine.voice.complete_attempt(&key, result);
+                    });
+                }
+                loop {
+                    if let Some(result) = rx.borrow().clone() {
+                        let prepared = result.map_err(failure)?;
+                        self.voice
+                            .validate_remote(&prepared.lease)
+                            .map_err(failure)?;
+                        return RpcReply::value(&prepared);
+                    }
+                    rx.changed()
+                        .await
+                        .map_err(|_| failure(VoiceRejection::Protocol))?;
+                }
+            }
+            methods::OWN_VOICE_V2 => {
+                let lease: wire::Lease = parse_params(p)?;
+                let owner = self.voice.own_remote(lease).map_err(failure)?;
+                Ok(RpcReply::Stream(
+                    futures::stream::unfold(owner, |mut owner| async move {
+                        owner
+                            .next()
+                            .await
+                            .map(|e| (serde_json::to_value(e).unwrap(), owner))
+                    })
+                    .boxed(),
+                ))
+            }
+            methods::NEGOTIATE_VOICE_V2 => RpcReply::value(
+                &self
+                    .voice
+                    .negotiate_remote(parse_params(p)?)
+                    .await
+                    .map_err(failure)?,
+            ),
+            methods::CONFIRM_VOICE_MEDIA_V2 => RpcReply::value(
+                &self
+                    .voice
+                    .confirm_remote(&parse_params(p)?)
+                    .map_err(failure)?,
+            ),
+            methods::REPORT_VOICE_MEDIA_V2 => RpcReply::value(
+                &self
+                    .voice
+                    .report_remote(&parse_params(p)?)
+                    .map_err(failure)?,
+            ),
+            methods::STOP_VOICE_V2 => {
+                self.voice.stop_remote(&parse_params(p)?).map_err(failure)?;
+                RpcReply::value(&serde_json::json!({"ok":true}))
+            }
+            methods::CANCEL_VOICE_ATTEMPT_V2 => {
+                let p: wire::Cancel = parse_params(p)?;
+                self.voice.cancel_attempt(&p.attempt_key).map_err(failure)?;
+                RpcReply::value(&serde_json::json!({"ok":true}))
+            }
+            _ => Err(RpcError::UnknownMethod(method.into())),
+        }
+    }
+    async fn prepare_remote_voice(
+        &self,
+        p: wire::Prepare,
+        resolved: &mut Option<String>,
+        cancel: tokio_util::sync::CancellationToken,
+    ) -> Result<wire::Prepared, VoiceRejection> {
+        let _preparation = self.voice.preparation().await;
+        let epoch = self.voice.identity_epoch();
+        if self.voice.busy() {
+            return Err(VoiceRejection::Busy);
+        }
+        if cancel.is_cancelled() {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        let chat = self.voice_chat(p.config).await?;
+        *resolved = Some(chat.clone());
+        let (bridge, events, active) = self.prepare_voice_bridge(&chat).await?;
+        let eligibility = bridge.probe_external().await?;
+        if p.voice
+            .as_ref()
+            .is_some_and(|v| !eligibility.voices.contains(v))
+        {
+            return Err(VoiceRejection::Unsupported);
+        }
+        if cancel.is_cancelled() {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        let expected = self
+            .workspace
+            .chat(&chat)
+            .map_err(|_| VoiceRejection::Protocol)?
+            .ok_or(VoiceRejection::InvalidLease)?;
+        let doc = self
+            .doc_host
+            .open(&chat)
+            .map_err(|_| VoiceRejection::Protocol)?;
+        self.voice
+            .connect_remote(
+                self.engine_info.device_id.clone(),
+                chat,
+                p.voice,
+                eligibility.voices,
+                bridge,
+                events,
+                active,
+                doc,
+                self.sessions.clone(),
+                self.workspace.clone(),
+                expected,
+                epoch,
+                cancel,
+            )
+            .await
+    }
+}
diff --git a/crates/engine/src/sessions.rs b/crates/engine/src/sessions.rs
index 9504e005b3..253e13f804 100644
--- a/crates/engine/src/sessions.rs
+++ b/crates/engine/src/sessions.rs
@@ -104,7 +104,37 @@ impl RuntimeConfig {
     }
 }
 
+/// A run's live voice calls. They hold its idle reaper off, and each hang-up
+/// wakes the reaper to restart its window from there.
+#[derive(Default)]
+pub(crate) struct VoiceActivity {
+    calls: std::sync::atomic::AtomicUsize,
+    ended: tokio::sync::Notify,
+}
+impl VoiceActivity {
+    pub(crate) fn live(&self) -> bool {
+        self.calls.load(std::sync::atomic::Ordering::Acquire) > 0
+    }
+    /// A live call until the returned guard drops.
+    pub(crate) fn call(self: &Arc<Self>) -> VoiceCall {
+        self.calls.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
+        VoiceCall(self.clone())
+    }
+}
+pub(crate) struct VoiceCall(Arc<VoiceActivity>);
+impl Drop for VoiceCall {
+    fn drop(&mut self) {
+        self.0
+            .calls
+            .fetch_sub(1, std::sync::atomic::Ordering::AcqRel);
+        // A stored permit: the reaper hears it even while busy elsewhere.
+        self.0.ended.notify_one();
+    }
+}
+
 struct RunHandle {
+    voice: Option<zeron_harness::codex::realtime::RealtimeHandle>,
+    voice_active: Arc<VoiceActivity>,
     run_id: String,
     steerable: bool,
     runtime_config: RuntimeConfig,
@@ -140,6 +170,7 @@ struct RoutedSteer {
 }
 
 struct Inner {
+    voice: crate::voice::VoiceManager,
     device_id: String,
     /// Loopback IPC port this engine serves, once known (0 = not serving):
     /// what the injected `zeron mcp` server dials back into.
@@ -194,6 +225,7 @@ impl SessionsEngine {
         let (sessions_tx, _) = watch::channel(Vec::new());
         Self {
             inner: Arc::new(Inner {
+                voice: crate::voice::VoiceManager::default(),
                 device_id,
                 ipc_port: std::sync::atomic::AtomicU16::new(0),
                 journal,
@@ -212,6 +244,10 @@ impl SessionsEngine {
         }
     }
 
+    pub(crate) fn voice_manager(&self) -> crate::voice::VoiceManager {
+        self.inner.voice.clone()
+    }
+
     /// Record the loopback IPC port this engine serves. Runs started after
     /// this carry Zeron's MCP server (see [`Inner::zeron_mcp`]); until then —
     /// or with 0 — agents get no Zeron tools rather than a dead server.
@@ -308,6 +344,9 @@ impl SessionsEngine {
     /// "don't restart from under a session" gate.
     pub fn any_active(&self) -> bool {
         lock(&self.inner.statuses).values().any(is_active)
+            || lock(&self.inner.runs)
+                .values()
+                .any(|r| r.voice_active.live())
     }
 
     /// A text prompt for `chat_id` would land in the mailbox of a live
@@ -378,6 +417,62 @@ impl SessionsEngine {
         Ok((replay, rx))
     }
 
+    /// Local experimental bootstrap. No Submit, empty user entry or title request.
+    pub async fn start_idle(
+        &self,
+        chat_id: &str,
+        request: RunRequest,
+    ) -> Result<String, EngineError> {
+        // A fresh explicit request may renew an identity-invalidated idle
+        // process. Never interrupt a native delegated turn to recover voice.
+        let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(8);
+        loop {
+            let stale = lock(&self.inner.runs).get(chat_id).map(|run| {
+                (
+                    run.voice.as_ref().is_some_and(|v| v.invalidated()),
+                    run.voice_active.live(),
+                )
+            });
+            match stale {
+                Some((true, false)) => {
+                    if self.turn_in_flight(chat_id) {
+                        return Err(EngineError::Other(
+                            "identity changed during delegated work".into(),
+                        ));
+                    }
+                    self.interrupt(chat_id).await?;
+                    break;
+                }
+                Some((true, _)) => {
+                    if tokio::time::Instant::now() >= deadline {
+                        return Err(EngineError::Other("voice cleanup in progress".into()));
+                    }
+                    tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+                }
+                _ => break,
+            }
+        }
+        self.dispatch_inner(chat_id, HarnessId::Codex, request, None, false, true)
+            .await
+    }
+
+    pub(crate) fn take_voice_bridge(
+        &self,
+        chat_id: &str,
+    ) -> Option<(
+        zeron_harness::codex::realtime::RealtimeHandle,
+        tokio::sync::broadcast::Receiver<zeron_proto::voice::VoiceEvent>,
+        Arc<VoiceActivity>,
+    )> {
+        let mut runs = lock(&self.inner.runs);
+        let run = runs.get_mut(chat_id)?;
+        Some((
+            run.voice.clone()?,
+            run.voice.as_ref()?.events.subscribe(),
+            run.voice_active.clone(),
+        ))
+    }
+
     /// Start (or route) a run for `chat_id`.
     ///
     /// - The user message entry is written to the doc immediately (id = `message_id`).
@@ -408,7 +503,14 @@ impl SessionsEngine {
         message_id: Option<String>,
         startup_retry: bool,
     ) -> futures::future::BoxFuture<'a, Result<String, EngineError>> {
-        Box::pin(self.dispatch_inner(chat_id, harness_id, request, message_id, startup_retry))
+        Box::pin(self.dispatch_inner(
+            chat_id,
+            harness_id,
+            request,
+            message_id,
+            startup_retry,
+            false,
+        ))
     }
 
     async fn dispatch_inner(
@@ -418,6 +520,7 @@ impl SessionsEngine {
         mut request: RunRequest,
         mut message_id: Option<String>,
         startup_retry: bool,
+        idle: bool,
     ) -> Result<String, EngineError> {
         // Project-less chats store cwd `~` (the creating device can't know the
         // host's home); expand it here, on the host, where the run spawns.
@@ -438,6 +541,13 @@ impl SessionsEngine {
             )
         });
         if let Some((run_id, steerable, same_runtime, steer_tx, ledger, history_sent)) = routed {
+            if idle {
+                return if same_runtime && harness_id == HarnessId::Codex {
+                    Ok(run_id)
+                } else {
+                    Err(EngineError::Other("incompatible live runtime".into()))
+                };
+            }
             let user_id = message_id.clone().unwrap_or_else(new_id);
             let mut bootstrap = None;
             let accepted = if steerable && same_runtime {
@@ -528,7 +638,9 @@ impl SessionsEngine {
         let harness = self.inner.registry.resolve(harness_id)?;
         let handle = self.doc_handle(chat_id)?;
         let user_id = message_id.unwrap_or_else(new_id);
-        handle.write_user_message(&user_id, &request.prompt, now_ms())?;
+        if !idle {
+            handle.write_user_message(&user_id, &request.prompt, now_ms())?;
+        }
 
         // Engine-owned resume (zeron sessions.ts:736 — every dispatch read the
         // chat's stored harness session): callers always send `resume: None`;
@@ -581,7 +693,10 @@ impl SessionsEngine {
         };
         let interrupt_token = CancellationToken::new();
         let fork_history_sent = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let (voice_handle, realtime, _voice_events) = zeron_harness::codex::realtime::channel();
+        let voice_active = Arc::new(VoiceActivity::default());
         let controls = RunControls {
+            realtime: (harness_id == HarnessId::Codex).then_some(realtime),
             execution_lease: None,
             request_input,
             steering: steer_rx,
@@ -591,6 +706,8 @@ impl SessionsEngine {
         lock(&self.inner.runs).insert(
             chat_id.to_string(),
             RunHandle {
+                voice: (harness_id == HarnessId::Codex).then_some(voice_handle),
+                voice_active: voice_active.clone(),
                 run_id: run_id.clone(),
                 steerable: harness.supports_steering(),
                 runtime_config: RuntimeConfig::from_request(harness_id, &request),
@@ -603,17 +720,27 @@ impl SessionsEngine {
                 fork_history_sent: fork_history_sent.clone(),
             },
         );
-        self.set_status(chat_id, SessionStatus::Working, true);
+        self.set_status(
+            chat_id,
+            if idle {
+                SessionStatus::Idle
+            } else {
+                SessionStatus::Working
+            },
+            true,
+        );
         // AFTER Working (same causal-order guarantee as the steer path): the
         // lastMessageAt bump must never be observable ahead of the live run.
-        self.inner.note_message(chat_id, &request.prompt);
+        if !idle {
+            self.inner.note_message(chat_id, &request.prompt);
+        }
 
         // Name the chat NOW, off the first prompt — not after the first
         // exchange completes ("called New session for a long time for no
         // reason"; the titler only needs the prompt and skips titled chats;
         // the Done-time call below stays as the retry for a failed
         // generation).
-        if let Some(titles) = self.inner.titles.get() {
+        if !idle && let Some(titles) = self.inner.titles.get() {
             titles.maybe_generate(chat_id, harness_id, &request.prompt, &request.cwd);
         }
 
@@ -628,6 +755,8 @@ impl SessionsEngine {
             engine_rx,
             cancel_rx,
             RunResumeState {
+                idle,
+                voice_active,
                 user_message_id: user_id,
                 resume_injected,
                 startup_retry,
@@ -962,6 +1091,7 @@ impl SessionsEngine {
 
     /// Graceful shutdown: interrupt every live run so streaming entries settle.
     pub async fn shutdown(&self) {
+        self.inner.voice.retire();
         let chats: Vec<String> = lock(&self.inner.runs).keys().cloned().collect();
         for chat_id in chats {
             if let Err(err) = self.interrupt(&chat_id).await {
@@ -1714,6 +1844,8 @@ fn finish_segment<'a>(
 /// engine-injected resumes retry — a caller-specified resume fails loudly),
 /// and whether this run already IS the retry (one attempt only).
 struct RunResumeState {
+    idle: bool,
+    voice_active: Arc<VoiceActivity>,
     user_message_id: String,
     resume_injected: bool,
     startup_retry: bool,
@@ -1822,14 +1954,16 @@ async fn drive_run(
         None => ProviderSession::Fresh,
         resumed => ProviderSession::Continued(resumed),
     };
-    if let Some(prompt) = inner.fork_history_prompt(
-        &chat_id,
-        &doc,
-        harness_id,
-        &request.prompt,
-        Some(&resume_state.user_message_id),
-        provider,
-    ) {
+    if !resume_state.idle
+        && let Some(prompt) = inner.fork_history_prompt(
+            &chat_id,
+            &doc,
+            harness_id,
+            &request.prompt,
+            Some(&resume_state.user_message_id),
+            provider,
+        )
+    {
         request.prompt = prompt;
         carried_history = true;
         resume_state
@@ -1873,7 +2007,11 @@ async fn drive_run(
                     wire_request.prompt =
                         zeron_proto::invocation::harness_prompt(&wire_request.prompt, harness_id);
                 }
-                harness.run(wire_request, controls).await
+                if resume_state.idle {
+                    harness.start_idle(wire_request, controls).await
+                } else {
+                    harness.run(wire_request, controls).await
+                }
             } else {
                 Ok(futures::stream::once(async {
                     Ok(AgentEvent::Done {
@@ -1980,13 +2118,21 @@ async fn drive_run(
     // its steering mailbox stay warm, and the next user message (dispatch
     // routes into a live run) starts the next turn with zero respawn/resume
     // latency. `Some(when)` = idle since then; the 30-min reaper below ends
-    // a session nobody comes back to (zeron SESSION_IDLE_MS).
-    // `ZERON_SESSION_IDLE_MS` overrides the window (tests).
+    // a session nobody comes back to (zeron SESSION_IDLE_MS). A voice
+    // orchestrator holds Codex and its MCP servers (~200 MB) for calls only,
+    // so it goes after 5 minutes. A call holds the reaper off, and the window
+    // restarts at hang-up. `ZERON_SESSION_IDLE_MS` overrides both (tests).
     let session_idle = std::env::var("ZERON_SESSION_IDLE_MS")
         .ok()
         .and_then(|v| v.parse::<u64>().ok())
         .map(std::time::Duration::from_millis)
-        .unwrap_or(std::time::Duration::from_secs(30 * 60));
+        .unwrap_or(std::time::Duration::from_secs(
+            if zeron_proto::voice::is_orchestrator_chat(&chat_id) {
+                5 * 60
+            } else {
+                30 * 60
+            },
+        ));
     // A live subagent stretches the window, but never unbounded: every
     // driver's subagent terminal is a best-effort vendor signal (claude's
     // untagged task_notification, grok's subagent_finished, codex thread
@@ -1995,7 +2141,8 @@ async fn drive_run(
     // silent this long (4h by default) is presumed lost; the reap stamps its
     // chip failed.
     let subagent_silence = session_idle * 8;
-    let mut idle_since: Option<tokio::time::Instant> = None;
+    let mut idle_since: Option<tokio::time::Instant> =
+        resume_state.idle.then(tokio::time::Instant::now);
     let steerable = harness.supports_steering();
     // TURN-QUIESCE WATCHDOG (2026-08-12 stuck-Working incident): a harness
     // that loses a turn's Done — the adapter never settles `session/prompt`
@@ -2091,12 +2238,19 @@ async fn drive_run(
                     inner.touch_session(&chat_id);
                     continue;
                 }
+                // A hang-up restarts the idle window, however long the call.
+                _ = resume_state.voice_active.ended.notified() => {
+                    if idle_since.is_some() {
+                        idle_since = Some(tokio::time::Instant::now());
+                    }
+                    continue;
+                }
                 // An accepted update must not wait behind a warm between-turn
                 // child for the full idle-reaper window. The completed turn is
                 // already durable, so retire the parked process cleanly and let
                 // the queued exclusive lease proceed.
                 _ = tokio::time::sleep_until(tokio::time::Instant::now()),
-                    if idle_since.is_some() && inner.registry.update_pending(harness_id) =>
+                    if idle_since.is_some() && !resume_state.voice_active.live() && inner.registry.update_pending(harness_id) =>
                 {
                     if let Some(token) = lock(&inner.runs)
                         .get(&chat_id)
@@ -2108,7 +2262,7 @@ async fn drive_run(
                     break SessionStatus::Idle;
                 }
                 // Idle reaper (zeron SESSION_IDLE_MS): a parked persistent session
-                // nobody returned to in 30 minutes releases its child. The turn
+                // nobody returned to within its window releases its child. The turn
                 // was finalized at Done, so this end is clean — no aborted stamp.
                 // A live background subagent is somebody still using the child:
                 // the window counts from its last activity, and stretches to
@@ -2120,7 +2274,11 @@ async fn drive_run(
                                 + if subagents.is_empty() { session_idle } else { subagent_silence }
                         })
                         .unwrap_or_else(tokio::time::Instant::now)
-                ), if idle_since.is_some() => {
+                ), if idle_since.is_some() && !resume_state.voice_active.live() => {
+                    // A call that began after this wait was armed holds it off.
+                    if resume_state.voice_active.live() {
+                        continue;
+                    }
                     tracing::info!(
                         chat = %chat_id,
                         live_subagents = subagents.len(),
@@ -2522,6 +2680,8 @@ async fn drive_run(
                 inner.set_status(&chat_id, SessionStatus::Working, true);
             } else {
                 match &event {
+                    AgentEvent::SessionStarted { .. }
+                        if resume_state.idle && !saw_session_started => {}
                     AgentEvent::Steered { .. } => {
                         idle_since = None;
                         inner.set_status(&chat_id, SessionStatus::Working, true);
@@ -2603,6 +2763,7 @@ async fn drive_run(
         // helper that is down hard fails the retry too and surfaces its
         // crash text (the harness now appends exit status + stderr).
         if resume_state.resume_injected
+            && !resume_state.idle
             && !resume_state.startup_retry
             && !saw_session_started
             && folded.is_empty()
@@ -3099,6 +3260,164 @@ mod tests {
         }
     }
 
+    struct IdleStartupFixture {
+        idle_calls: Arc<std::sync::atomic::AtomicUsize>,
+        inference_calls: Arc<std::sync::atomic::AtomicUsize>,
+        fail: bool,
+    }
+    #[async_trait::async_trait]
+    impl zeron_harness::Harness for IdleStartupFixture {
+        fn id(&self) -> HarnessId {
+            HarnessId::Codex
+        }
+        fn display_name(&self) -> &str {
+            "Offline idle fixture"
+        }
+        fn supports_steering(&self) -> bool {
+            false
+        }
+        fn steering_mode(&self) -> zeron_proto::SteeringMode {
+            zeron_proto::SteeringMode::TurnBoundary
+        }
+        fn reasoning_levels(&self) -> &[zeron_proto::ReasoningLevel] {
+            &[]
+        }
+        async fn models(&self) -> Result<Vec<zeron_proto::Model>, zeron_harness::HarnessError> {
+            Ok(vec![])
+        }
+        async fn start_idle(
+            &self,
+            request: RunRequest,
+            _controls: zeron_harness::RunControls,
+        ) -> Result<
+            futures::stream::BoxStream<'static, Result<AgentEvent, zeron_harness::HarnessError>>,
+            zeron_harness::HarnessError,
+        > {
+            use futures::StreamExt;
+            self.idle_calls
+                .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+            assert!(request.prompt.is_empty());
+            assert_eq!(request.resume.as_deref(), Some("old-native-thread"));
+            let event = if self.fail {
+                AgentEvent::Done {
+                    status: zeron_proto::DoneStatus::Errored,
+                    result: None,
+                    error: Some("offline startup failed".into()),
+                    session_id: None,
+                }
+            } else {
+                AgentEvent::SessionStarted {
+                    harness: HarnessId::Codex,
+                    model: "fixture".into(),
+                    tools: vec![],
+                    cwd: request.cwd,
+                    session_id: "new-native-thread".into(),
+                    assistant_message_id: "fixture-empty".into(),
+                }
+            };
+            Ok(futures::stream::iter([Ok(event)])
+                .chain(futures::stream::pending())
+                .boxed())
+        }
+        async fn run(
+            &self,
+            _request: RunRequest,
+            _controls: zeron_harness::RunControls,
+        ) -> Result<
+            futures::stream::BoxStream<'static, Result<AgentEvent, zeron_harness::HarnessError>>,
+            zeron_harness::HarnessError,
+        > {
+            self.inference_calls
+                .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+            Err(zeron_harness::HarnessError::Protocol(
+                "fixture forbids inference".into(),
+            ))
+        }
+    }
+
+    async fn idle_startup_case(fail: bool) {
+        use super::*;
+        let temp = tempfile::tempdir().unwrap();
+        let idle_calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let inference_calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let registry = crate::HarnessRegistry::new();
+        registry.register(Arc::new(IdleStartupFixture {
+            idle_calls: idle_calls.clone(),
+            inference_calls: inference_calls.clone(),
+            fail,
+        }));
+        let core = crate::EngineCore::assemble_with_profile(
+            crate::EngineProfile::local(temp.path()).unwrap(),
+            Arc::new(registry),
+            HarnessId::Codex,
+            None,
+        )
+        .unwrap();
+        core.workspace
+            .create_chat("idle", None, Some(&core.device_id), None, None)
+            .unwrap();
+        let mut request = request();
+        request.prompt.clear();
+        core.sessions
+            .inner
+            .remember_harness_session("idle", "old-native-thread", &request.cwd);
+        core.sessions.start_idle("idle", request).await.unwrap();
+        tokio::time::timeout(std::time::Duration::from_secs(5), async {
+            loop {
+                let completed = if fail {
+                    core.sessions
+                        .session_status("idle")
+                        .is_some_and(|s| s.status == SessionStatus::Errored)
+                } else {
+                    core.sessions.inner.resume_for("idle", "/tmp").as_deref()
+                        == Some("new-native-thread")
+                };
+                if completed {
+                    break;
+                }
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(idle_calls.load(std::sync::atomic::Ordering::SeqCst), 1);
+        assert_eq!(inference_calls.load(std::sync::atomic::Ordering::SeqCst), 0);
+        let entries = core
+            .doc_host
+            .open("idle")
+            .unwrap()
+            .doc()
+            .read_entries()
+            .unwrap();
+        assert!(
+            !entries
+                .iter()
+                .any(|entry| entry.role == zeron_doc::MessageRole::User)
+        );
+        if !fail {
+            assert!(entries.is_empty());
+            assert_eq!(
+                core.sessions.session_status("idle").unwrap().status,
+                SessionStatus::Idle
+            );
+            assert_eq!(
+                core.workspace.chat_harness_session("idle").unwrap().0,
+                "new-native-thread"
+            );
+            let events = core.sessions.inner.journal.replay("idle", 0).unwrap();
+            assert!(events.iter().any(|(_, event)| matches!(event, AgentEvent::SessionStarted { session_id, .. } if session_id == "new-native-thread")));
+        }
+        core.sessions.shutdown().await;
+    }
+    #[tokio::test]
+    async fn voice_idle_startup_failure_never_retries_as_inference() {
+        idle_startup_case(true).await;
+    }
+    #[tokio::test]
+    async fn voice_idle_startup_remembers_thread_without_creating_messages() {
+        idle_startup_case(false).await;
+    }
+
     #[test]
     fn live_routing_requires_the_same_runtime_configuration() {
         let initial = request();
diff --git a/crates/engine/src/titles.rs b/crates/engine/src/titles.rs
index 037d1c9dbc..963c97f3be 100644
--- a/crates/engine/src/titles.rs
+++ b/crates/engine/src/titles.rs
@@ -277,6 +277,7 @@ async fn collect_text(
     let interrupt = CancellationToken::new();
     let _cancel_on_drop = interrupt.clone().drop_guard();
     let controls = RunControls {
+        realtime: None,
         execution_lease,
         request_input: Box::new(|_questions: Vec<UserInputQuestion>| {
             let (tx, rx) = tokio::sync::oneshot::channel::<Vec<UserInputAnswer>>();
diff --git a/crates/engine/src/voice.rs b/crates/engine/src/voice.rs
new file mode 100644
index 0000000000..319a6c6b9e
--- /dev/null
+++ b/crates/engine/src/voice.rs
@@ -0,0 +1,310 @@
+//! Exclusive, local, ephemeral voice ownership. Native media remains in Codex's helper.
+pub(crate) mod remote;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+use tokio::sync::mpsc;
+use tokio::time::Instant;
+use tokio_util::sync::CancellationToken;
+use zeron_harness::codex::realtime::{RealtimeHandle, VoiceCommand};
+use zeron_proto::{SessionStatus, voice::*};
+
+#[derive(Clone, Default)]
+pub struct VoiceManager {
+    inner: Arc<Inner>,
+}
+#[derive(Default)]
+struct Inner {
+    slot: Mutex<Option<Slot>>,
+    attempts:
+        Mutex<std::collections::HashMap<zeron_proto::voice::remote::AttemptKey, remote::Attempt>>,
+    generation: AtomicU64,
+    identity_epoch: AtomicU64,
+    // A successor waits until the old native stop completes, even after its owner is dropped.
+    preparation: tokio::sync::Mutex<()>,
+    native_lifecycle: Arc<tokio::sync::Mutex<()>>,
+}
+struct Slot {
+    lease: VoiceLease,
+    snapshot: VoiceSnapshot,
+    attach_deadline: Instant,
+    owner_attached: bool,
+    events: Option<mpsc::Receiver<VoiceEvent>>,
+    sender: mpsc::Sender<VoiceEvent>,
+    cancel: CancellationToken,
+    provider: Option<RealtimeHandle>,
+    remote: Option<remote::RemoteSlot>,
+}
+pub struct VoiceOwner {
+    manager: VoiceManager,
+    lease: VoiceLease,
+    events: mpsc::Receiver<VoiceEvent>,
+}
+impl VoiceOwner {
+    pub async fn next(&mut self) -> Option<VoiceEvent> {
+        self.events.recv().await
+    }
+}
+impl Drop for VoiceOwner {
+    fn drop(&mut self) {
+        let _ = self.manager.stop(&self.lease);
+    }
+}
+
+impl VoiceManager {
+    pub(crate) async fn preparation(&self) -> tokio::sync::MutexGuard<'_, ()> {
+        self.inner.preparation.lock().await
+    }
+    pub(crate) fn identity_epoch(&self) -> u64 {
+        self.inner.identity_epoch.load(Ordering::Acquire)
+    }
+    #[cfg(test)]
+    pub(crate) fn reserve(&self, chat: &str) -> Result<VoiceLease, VoiceRejection> {
+        self.reserve_with_deadline(chat, self.identity_epoch(), 5)
+    }
+    fn reserve_with_deadline(
+        &self,
+        chat: &str,
+        epoch: u64,
+        seconds: u64,
+    ) -> Result<VoiceLease, VoiceRejection> {
+        let mut state = self.inner.slot.lock().unwrap();
+        if self.identity_epoch() != epoch {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        if state.is_some() {
+            return Err(VoiceRejection::Busy);
+        }
+        let generation = self.inner.generation.fetch_add(1, Ordering::AcqRel) + 1;
+        let lease = VoiceLease {
+            session_id: uuid::Uuid::new_v4().to_string(),
+            generation,
+            token: uuid::Uuid::new_v4().to_string(),
+        };
+        let snapshot = VoiceSnapshot {
+            session_id: lease.session_id.clone(),
+            chat_id: chat.into(),
+            generation,
+            phase: VoicePhase::Starting,
+            muted: false,
+            playing: false,
+            work: VoiceWork::Idle,
+            reason: None,
+            voice: None,
+            voices: Vec::new(),
+        };
+        let (sender, events) = mpsc::channel(32);
+        let _ = sender.try_send(VoiceEvent::Snapshot {
+            snapshot: snapshot.clone(),
+        });
+        *state = Some(Slot {
+            lease: lease.clone(),
+            snapshot,
+            attach_deadline: Instant::now() + Duration::from_secs(seconds),
+            owner_attached: false,
+            events: Some(events),
+            sender,
+            cancel: CancellationToken::new(),
+            provider: None,
+            remote: None,
+        });
+        drop(state);
+        let manager = self.clone();
+        let pending = lease.clone();
+        tokio::spawn(async move {
+            tokio::time::sleep(Duration::from_secs(seconds)).await;
+            manager.expire_unattached(&pending);
+        });
+        Ok(lease)
+    }
+    fn expire_unattached(&self, lease: &VoiceLease) {
+        let expired = self.inner.slot.lock().unwrap().as_ref().is_some_and(|s| {
+            Self::matches(s, lease) && !s.owner_attached && Instant::now() >= s.attach_deadline
+        });
+        if expired {
+            let _ = self.stop(lease);
+        }
+    }
+    fn matches(s: &Slot, l: &VoiceLease) -> bool {
+        s.lease.session_id == l.session_id
+            && s.lease.generation == l.generation
+            && s.lease.token == l.token
+    }
+    pub fn own(&self, lease: VoiceLease) -> Result<VoiceOwner, VoiceRejection> {
+        let mut state = self.inner.slot.lock().unwrap();
+        let slot = state
+            .as_mut()
+            .filter(|s| Self::matches(s, &lease))
+            .ok_or(VoiceRejection::InvalidLease)?;
+        if slot.owner_attached || Instant::now() >= slot.attach_deadline {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        let events = slot.events.take().ok_or(VoiceRejection::InvalidLease)?;
+        slot.owner_attached = true;
+        if let Some(remote) = &mut slot.remote {
+            remote.last_report = Instant::now();
+        }
+        Ok(VoiceOwner {
+            manager: self.clone(),
+            lease,
+            events,
+        })
+    }
+    fn publish(&self, lease: &VoiceLease, event: VoiceEvent) -> Result<(), VoiceRejection> {
+        let result = {
+            let state = self.inner.slot.lock().unwrap();
+            let slot = state
+                .as_ref()
+                .filter(|s| Self::matches(s, lease))
+                .ok_or(VoiceRejection::InvalidLease)?;
+            slot.sender
+                .try_send(event)
+                .map_err(|_| VoiceRejection::Overflow)
+        };
+        if result.is_err() {
+            let _ = self.stop(lease);
+        }
+        result
+    }
+    fn update(
+        &self,
+        lease: &VoiceLease,
+        f: impl FnOnce(&mut VoiceSnapshot),
+    ) -> Result<(), VoiceRejection> {
+        let snapshot = {
+            let mut state = self.inner.slot.lock().unwrap();
+            let slot = state
+                .as_mut()
+                .filter(|s| Self::matches(s, lease))
+                .ok_or(VoiceRejection::InvalidLease)?;
+            f(&mut slot.snapshot);
+            slot.snapshot.clone()
+        };
+        self.publish(lease, VoiceEvent::Snapshot { snapshot })
+    }
+    pub fn stop(&self, lease: &VoiceLease) -> Result<(), VoiceRejection> {
+        self.finish(lease, None)
+    }
+    fn finish(
+        &self,
+        lease: &VoiceLease,
+        reason: Option<VoiceRejection>,
+    ) -> Result<(), VoiceRejection> {
+        let mut state = self.inner.slot.lock().unwrap();
+        let Some(s) = state.as_ref() else {
+            return Ok(());
+        };
+        if !Self::matches(s, lease) {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        let s = state.take().unwrap();
+        drop(state);
+        Self::close_slot(s, reason);
+        Ok(())
+    }
+    fn close_slot(s: Slot, reason: Option<VoiceRejection>) {
+        s.cancel.cancel();
+        if let Some(provider) = s.provider.as_ref() {
+            provider.abort_voice(s.lease.generation);
+        }
+        let _ = s.sender.try_send(VoiceEvent::Closed {
+            generation: s.lease.generation,
+            reason,
+        });
+    }
+    #[cfg(test)]
+    pub(crate) fn owns_chat(&self, chat: &str) -> bool {
+        self.inner
+            .slot
+            .lock()
+            .unwrap()
+            .as_ref()
+            .is_some_and(|s| s.snapshot.chat_id == chat)
+    }
+    pub fn retire(&self) {
+        let mut state = self.inner.slot.lock().unwrap();
+        // The same lock covers reservation and identity changes: a pending probe
+        // may never create a lease after account/profile retirement.
+        self.inner.identity_epoch.fetch_add(1, Ordering::AcqRel);
+        for attempt in self.inner.attempts.lock().unwrap().values() {
+            attempt.cancel.cancel();
+        }
+        self.inner.generation.fetch_add(1, Ordering::AcqRel);
+        let old = state.take();
+        drop(state);
+        if let Some(slot) = old {
+            Self::close_slot(slot, None);
+        }
+    }
+    pub(crate) fn retire_chat(&self, chat: &str) {
+        let mut state = self.inner.slot.lock().unwrap();
+        self.inner.identity_epoch.fetch_add(1, Ordering::AcqRel);
+        let old = if state.as_ref().is_some_and(|s| s.snapshot.chat_id == chat) {
+            state.take()
+        } else {
+            None
+        };
+        drop(state);
+        if let Some(slot) = old {
+            Self::close_slot(slot, None);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn exclusive_owner_drop_and_stale_guards() {
+        let manager = VoiceManager::default();
+        let lease = manager.reserve("chat").unwrap();
+        assert_eq!(manager.reserve("chat").unwrap_err(), VoiceRejection::Busy);
+        let mut bad = lease.clone();
+        bad.token = "bad".into();
+        assert!(manager.own(bad).is_err());
+        let owner = manager.own(lease.clone()).unwrap();
+        assert!(manager.own(lease.clone()).is_err());
+        drop(owner);
+        let next = manager.reserve("chat").unwrap();
+        assert_eq!(manager.stop(&lease), Err(VoiceRejection::InvalidLease));
+        assert!(manager.own(next).is_ok());
+    }
+    #[tokio::test(start_paused = true)]
+    async fn unattached_owner_watchdog_releases_reservation() {
+        let manager = VoiceManager::default();
+        let old = manager.reserve("chat").unwrap();
+        tokio::task::yield_now().await;
+        tokio::time::advance(Duration::from_secs(6)).await;
+        tokio::task::yield_now().await;
+        assert!(manager.own(old.clone()).is_err());
+        let next = manager.reserve("next").unwrap();
+        assert!(next.generation > old.generation);
+        let owner = manager.own(next).unwrap();
+        tokio::time::advance(Duration::from_secs(6)).await;
+        tokio::task::yield_now().await;
+        assert!(manager.owns_chat("next"));
+        drop(owner);
+        assert!(!manager.owns_chat("next"));
+    }
+
+    #[tokio::test]
+    async fn retirement_rejects_a_start_prepared_under_the_old_identity() {
+        let manager = VoiceManager::default();
+        let epoch = manager.identity_epoch();
+        manager.retire();
+        assert_eq!(
+            manager.reserve_with_deadline("chat", epoch, 5).unwrap_err(),
+            VoiceRejection::InvalidLease
+        );
+        assert!(manager.reserve("chat").is_ok());
+    }
+
+    #[tokio::test]
+    async fn account_retirement_invalidates_lease() {
+        let manager = VoiceManager::default();
+        let lease = manager.reserve("chat").unwrap();
+        manager.retire();
+        assert!(manager.own(lease).is_err());
+    }
+}
diff --git a/crates/engine/src/voice/remote.rs b/crates/engine/src/voice/remote.rs
new file mode 100644
index 0000000000..d69802ae15
--- /dev/null
+++ b/crates/engine/src/voice/remote.rs
@@ -0,0 +1,495 @@
+//! Client-owned media: host state contains signaling and canonical text only.
+use super::*;
+use tokio::sync::watch;
+use zeron_proto::voice::remote as wire;
+
+type PreparedResult = Option<Result<wire::Prepared, VoiceRejection>>;
+pub(crate) struct Attempt {
+    request: Option<wire::Prepare>,
+    created: Instant,
+    pub cancel: CancellationToken,
+    result: watch::Sender<PreparedResult>,
+}
+struct Negotiation {
+    id: wire::AttemptKey,
+    offer: wire::Sdp,
+    result: watch::Sender<Option<Result<wire::Negotiated, VoiceRejection>>>,
+}
+pub(super) struct RemoteSlot {
+    host: String,
+    last_sequence: u64,
+    pub last_report: Instant,
+    confirm_deadline: Option<Instant>,
+    negotiation: Option<Negotiation>,
+    confirmed: bool,
+    attempted: Arc<std::sync::atomic::AtomicBool>,
+}
+
+impl VoiceManager {
+    /// Registers before spawning preparation, so cancel-before-prepare is terminal.
+    pub(crate) fn begin_attempt(
+        &self,
+        request: &wire::Prepare,
+    ) -> Result<(watch::Receiver<PreparedResult>, Option<CancellationToken>), VoiceRejection> {
+        let mut attempts = self.inner.attempts.lock().unwrap();
+        attempts.retain(|_, a| {
+            a.created.elapsed() < Duration::from_secs(wire::ATTEMPT_TTL_SECS)
+                || (!a.cancel.is_cancelled()
+                    && a.result.borrow().as_ref().is_none_or(Result::is_ok))
+        });
+        if let Some(a) = attempts.get(&request.attempt_key) {
+            if a.cancel.is_cancelled() {
+                return Err(VoiceRejection::InvalidLease);
+            }
+            if a.request
+                .as_ref()
+                .is_none_or(|p| p.config != request.config || p.voice != request.voice)
+            {
+                return Err(VoiceRejection::Protocol);
+            }
+            return Ok((a.result.subscribe(), None));
+        }
+        if attempts.len() >= wire::MAX_ATTEMPTS {
+            return Err(VoiceRejection::Overflow);
+        }
+        let (result, rx) = watch::channel(None);
+        let cancel = CancellationToken::new();
+        attempts.insert(
+            request.attempt_key.clone(),
+            Attempt {
+                request: Some(request.clone()),
+                created: Instant::now(),
+                cancel: cancel.clone(),
+                result,
+            },
+        );
+        Ok((rx, Some(cancel)))
+    }
+    pub(crate) fn complete_attempt(
+        &self,
+        key: &wire::AttemptKey,
+        result: Result<wire::Prepared, VoiceRejection>,
+    ) {
+        let mut attempts = self.inner.attempts.lock().unwrap();
+        if let Some(a) = attempts.get_mut(key) {
+            let result = if a.cancel.is_cancelled() {
+                Err(VoiceRejection::InvalidLease)
+            } else {
+                result
+            };
+            a.result.send_replace(Some(result));
+        }
+    }
+    pub(crate) fn cancel_attempt(&self, key: &wire::AttemptKey) -> Result<(), VoiceRejection> {
+        let lease = {
+            let mut attempts = self.inner.attempts.lock().unwrap();
+            if let Some(a) = attempts.get_mut(key) {
+                a.cancel.cancel();
+                let lease = a
+                    .result
+                    .borrow()
+                    .as_ref()
+                    .and_then(|r| r.as_ref().ok())
+                    .map(|p| p.lease.voice.clone());
+                a.result
+                    .send_replace(Some(Err(VoiceRejection::InvalidLease)));
+                lease
+            } else {
+                attempts.retain(|_, a| {
+                    a.created.elapsed() < Duration::from_secs(wire::ATTEMPT_TTL_SECS)
+                        || (!a.cancel.is_cancelled()
+                            && a.result.borrow().as_ref().is_none_or(Result::is_ok))
+                });
+                if attempts.len() >= wire::MAX_ATTEMPTS {
+                    return Err(VoiceRejection::Overflow);
+                }
+                let (result, _) = watch::channel(Some(Err(VoiceRejection::InvalidLease)));
+                let cancel = CancellationToken::new();
+                cancel.cancel();
+                attempts.insert(
+                    key.clone(),
+                    Attempt {
+                        request: None,
+                        created: Instant::now(),
+                        cancel,
+                        result,
+                    },
+                );
+                None
+            }
+        };
+        if let Some(lease) = lease {
+            let _ = self.stop(&lease);
+        }
+        Ok(())
+    }
+    pub(crate) fn busy(&self) -> bool {
+        self.inner.slot.lock().unwrap().is_some()
+    }
+    fn remote_matches(s: &Slot, lease: &wire::Lease) -> bool {
+        Self::matches(s, &lease.voice)
+            && s.remote
+                .as_ref()
+                .is_some_and(|r| r.host == lease.host_device_id)
+    }
+    pub(crate) fn validate_remote(&self, lease: &wire::Lease) -> Result<(), VoiceRejection> {
+        self.inner
+            .slot
+            .lock()
+            .unwrap()
+            .as_ref()
+            .filter(|s| Self::remote_matches(s, lease))
+            .map(|_| ())
+            .ok_or(VoiceRejection::InvalidLease)
+    }
+    pub(crate) fn own_remote(&self, lease: wire::Lease) -> Result<VoiceOwner, VoiceRejection> {
+        self.validate_remote(&lease)?;
+        self.own(lease.voice)
+    }
+    pub(crate) fn stop_remote(&self, lease: &wire::Lease) -> Result<(), VoiceRejection> {
+        // An old authenticated lease is harmless once retired; never stop a successor.
+        if self.validate_remote(lease).is_ok() {
+            self.stop(&lease.voice)?;
+        }
+        Ok(())
+    }
+    pub(crate) fn report_remote(&self, p: &wire::Report) -> Result<wire::Ack, VoiceRejection> {
+        let mut state = self.inner.slot.lock().unwrap();
+        let s = state
+            .as_mut()
+            .filter(|s| Self::remote_matches(s, &p.lease) && s.owner_attached)
+            .ok_or(VoiceRejection::InvalidLease)?;
+        let r = s.remote.as_mut().unwrap();
+        if p.sequence <= r.last_sequence {
+            return Ok(wire::Ack {
+                sequence: r.last_sequence,
+            });
+        }
+        r.last_sequence = p.sequence;
+        r.last_report = Instant::now();
+        s.snapshot.muted = p.muted;
+        let ack = wire::Ack {
+            sequence: p.sequence,
+        };
+        drop(state);
+        if p.state != wire::MediaState::Ready {
+            self.stop(&p.lease.voice)?;
+        }
+        Ok(ack)
+    }
+    pub(crate) fn confirm_remote(
+        &self,
+        p: &wire::Confirm,
+    ) -> Result<VoiceSnapshot, VoiceRejection> {
+        let snapshot = {
+            let mut state = self.inner.slot.lock().unwrap();
+            let s = state
+                .as_mut()
+                .filter(|s| Self::remote_matches(s, &p.lease) && s.owner_attached)
+                .ok_or(VoiceRejection::InvalidLease)?;
+            let r = s.remote.as_mut().unwrap();
+            let n = r
+                .negotiation
+                .as_ref()
+                .filter(|n| n.id == p.negotiation_id)
+                .ok_or(VoiceRejection::Protocol)?;
+            if !matches!(&*n.result.borrow(), Some(Ok(_))) {
+                return Err(VoiceRejection::Protocol);
+            }
+            if r.confirm_deadline.is_some_and(|d| Instant::now() >= d) {
+                return Err(VoiceRejection::InvalidLease);
+            }
+            if !r.confirmed {
+                s.snapshot.muted = p.muted;
+            }
+            r.confirmed = true;
+            r.confirm_deadline = None;
+            s.snapshot.phase = VoicePhase::Active;
+            s.snapshot.clone()
+        };
+        self.publish(
+            &p.lease.voice,
+            VoiceEvent::Snapshot {
+                snapshot: snapshot.clone(),
+            },
+        )?;
+        Ok(snapshot)
+    }
+    pub(crate) async fn negotiate_remote(
+        &self,
+        p: wire::Negotiate,
+    ) -> Result<wire::Negotiated, VoiceRejection> {
+        let mut rx = {
+            let mut state = self.inner.slot.lock().unwrap();
+            let s = state
+                .as_mut()
+                .filter(|s| Self::remote_matches(s, &p.lease) && s.owner_attached)
+                .ok_or(VoiceRejection::InvalidLease)?;
+            let r = s.remote.as_mut().unwrap();
+            if let Some(n) = &r.negotiation {
+                if n.id != p.negotiation_id || n.offer != p.offer {
+                    return Err(VoiceRejection::Protocol);
+                }
+                n.result.subscribe()
+            } else {
+                let (result, rx) = watch::channel(None);
+                r.negotiation = Some(Negotiation {
+                    id: p.negotiation_id.clone(),
+                    offer: p.offer.clone(),
+                    result: result.clone(),
+                });
+                r.attempted.store(true, Ordering::Release);
+                let bridge = s.provider.clone().ok_or(VoiceRejection::Protocol)?;
+                let voice = s.snapshot.voice.clone();
+                let cancel = s.cancel.clone();
+                let manager = self.clone();
+                let p = p.clone();
+                tokio::spawn(async move {
+                    let operation = async {
+                        let (reply, answer) = tokio::sync::oneshot::channel();
+                        bridge
+                            .commands
+                            .send(VoiceCommand::External {
+                                voice,
+                                session_id: p.lease.voice.session_id.clone(),
+                                generation: p.lease.voice.generation,
+                                offer: p.offer,
+                                reply,
+                            })
+                            .await
+                            .map_err(|_| VoiceRejection::Protocol)?;
+                        let answer = answer.await.map_err(|_| VoiceRejection::Protocol)??;
+                        manager.validate_remote(&p.lease)?;
+                        {
+                            let mut state = manager.inner.slot.lock().unwrap();
+                            if let Some(r) = state
+                                .as_mut()
+                                .filter(|s| Self::remote_matches(s, &p.lease))
+                                .and_then(|s| s.remote.as_mut())
+                            {
+                                r.confirm_deadline = Some(Instant::now() + Duration::from_secs(30));
+                            }
+                        }
+                        Ok(wire::Negotiated {
+                            negotiation_id: p.negotiation_id,
+                            answer,
+                        })
+                    };
+                    let outcome = tokio::select! {biased;
+                        _=cancel.cancelled()=>Err(VoiceRejection::InvalidLease),
+                        r=tokio::time::timeout(Duration::from_secs(90),operation)=>r.unwrap_or(Err(VoiceRejection::Protocol)),
+                    };
+                    if outcome.is_err() {
+                        let _ = manager.finish(&p.lease.voice, outcome.as_ref().err().copied());
+                    }
+                    result.send_replace(Some(outcome));
+                });
+                rx
+            }
+        };
+        loop {
+            if let Some(result) = rx.borrow().clone() {
+                return result;
+            }
+            rx.changed().await.map_err(|_| VoiceRejection::Protocol)?;
+        }
+    }
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) async fn connect_remote(
+        &self,
+        host: String,
+        chat: String,
+        voice: Option<String>,
+        voices: Vec<String>,
+        bridge: RealtimeHandle,
+        mut events: tokio::sync::broadcast::Receiver<VoiceEvent>,
+        active: Arc<crate::sessions::VoiceActivity>,
+        doc: Arc<crate::doc_host::ChatDocHandle>,
+        sessions: crate::sessions::SessionsEngine,
+        workspace: crate::workspace_host::WorkspaceHost,
+        expected: zeron_proto::Chat,
+        epoch: u64,
+        attempt: CancellationToken,
+    ) -> Result<wire::Prepared, VoiceRejection> {
+        let lifecycle = self.inner.native_lifecycle.clone().lock_owned().await;
+        if attempt.is_cancelled() {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        let lease = self.reserve_with_deadline(&chat, epoch, 15)?;
+        let attempted = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let cancel = {
+            let mut state = self.inner.slot.lock().unwrap();
+            let s = state
+                .as_mut()
+                .filter(|s| Self::matches(s, &lease))
+                .ok_or(VoiceRejection::InvalidLease)?;
+            s.remote = Some(RemoteSlot {
+                host: host.clone(),
+                last_sequence: 0,
+                last_report: Instant::now(),
+                confirm_deadline: None,
+                negotiation: None,
+                confirmed: false,
+                attempted: attempted.clone(),
+            });
+            s.provider = Some(bridge.clone());
+            s.snapshot.voice = voice;
+            s.snapshot.voices = voices.clone();
+            s.cancel.clone()
+        };
+        let prepared = wire::Prepared {
+            lease: wire::Lease {
+                host_device_id: host,
+                voice: lease.clone(),
+            },
+            chat_id: chat.clone(),
+            voices,
+            heartbeat_seconds: wire::HEARTBEAT_SECS,
+            lease_seconds: wire::LEASE_SECS,
+        };
+        let manager = self.clone();
+        let call = active.call();
+        tokio::spawn(async move {
+            let _call = call;
+            let _lifecycle = lifecycle;
+            let mut ticker = tokio::time::interval(Duration::from_millis(250));
+            let mut statuses = sessions.watch_sessions();
+            let result=async {loop {tokio::select!{biased;
+                _=cancel.cancelled()=>return Ok(()),
+                _=attempt.cancelled()=>return Err(VoiceRejection::InvalidLease),
+                _=ticker.tick()=>{
+                    if bridge.invalidated(){return Err(VoiceRejection::InvalidLease);}
+                    if workspace.chat(&chat).ok().flatten().is_none_or(|c|c.device_id!=expected.device_id || c.config!=expected.config || c.cwd!=expected.cwd){return Err(VoiceRejection::InvalidLease);}
+                    let state=manager.inner.slot.lock().unwrap();
+                    let s=state.as_ref().filter(|s|Self::matches(s,&lease)).ok_or(VoiceRejection::InvalidLease)?;
+                    let r=s.remote.as_ref().unwrap();
+                    if (s.owner_attached && r.last_report.elapsed()>=Duration::from_secs(wire::LEASE_SECS)) || r.confirm_deadline.is_some_and(|d|Instant::now()>=d){return Err(VoiceRejection::InvalidLease);}
+                },
+                changed=statuses.changed()=>{
+                    changed.map_err(|_|VoiceRejection::Protocol)?;
+                    let work=match sessions.session_status(&chat).map(|s|s.status){Some(SessionStatus::Working)=>VoiceWork::Working,Some(SessionStatus::AwaitingInput)=>VoiceWork::AwaitingInput,_=>VoiceWork::Idle};
+                    manager.update(&lease,|s|s.work=work)?;
+                },
+                event=events.recv()=>{
+                    let event=event.map_err(|_|VoiceRejection::Overflow)?;
+                    match &event {
+                        VoiceEvent::Final{transcript}=>{
+                            if transcript.session_id!=lease.session_id{continue;}
+                            if doc.commit_voice(transcript).map_err(|_|VoiceRejection::Protocol)?.is_some(){workspace.note_message(&chat,&transcript.text);}
+                        },
+                        VoiceEvent::Partial{generation,..} | VoiceEvent::InvalidatePlayout{generation,..} if *generation!=lease.generation=>continue,
+                        VoiceEvent::Closed{generation,reason}=>{if *generation!=lease.generation{continue;}return reason.map_or(Ok(()),Err);},
+                        VoiceEvent::Audio{..} | VoiceEvent::Levels{..}=>return Err(VoiceRejection::Protocol),
+                        _=>{},
+                    }
+                    manager.publish(&lease,event)?;
+                }
+            }}}.await;
+            bridge.abort_voice(lease.generation);
+            let _ = bridge.stop().await;
+            let _ = manager.finish(&lease, result.err());
+            // A terminal attempt cannot replay a successful but dead lease.
+            attempt.cancel();
+            let empty = doc.watch_messages().borrow().entries.is_empty();
+            if !attempted.load(Ordering::Acquire) && empty {
+                let _ = sessions.interrupt(&chat).await;
+                let _ = workspace.delete_chat(&chat);
+            }
+        });
+        Ok(prepared)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn request() -> wire::Prepare {
+        wire::Prepare {
+            attempt_key: wire::AttemptKey::new(),
+            config: serde_json::from_value(
+                serde_json::json!({"harness":"codex","sandbox":"danger-full-access"}),
+            )
+            .unwrap(),
+            voice: None,
+        }
+    }
+    #[tokio::test]
+    async fn cancel_before_prepare_and_duplicate_payloads_are_terminal() {
+        let m = VoiceManager::default();
+        let p = request();
+        m.cancel_attempt(&p.attempt_key).unwrap();
+        assert!(matches!(
+            m.begin_attempt(&p),
+            Err(VoiceRejection::InvalidLease)
+        ));
+        let mut p = request();
+        let (_, first) = m.begin_attempt(&p).unwrap();
+        assert!(first.is_some());
+        let (_, duplicate) = m.begin_attempt(&p).unwrap();
+        assert!(duplicate.is_none());
+        p.voice = Some("different".into());
+        assert!(matches!(m.begin_attempt(&p), Err(VoiceRejection::Protocol)));
+    }
+    #[tokio::test]
+    async fn bounded_attempt_registry_never_evicts_live_preparations() {
+        let m = VoiceManager::default();
+        for _ in 0..wire::MAX_ATTEMPTS {
+            m.begin_attempt(&request()).unwrap();
+        }
+        assert!(matches!(
+            m.begin_attempt(&request()),
+            Err(VoiceRejection::Overflow)
+        ));
+    }
+    #[tokio::test]
+    async fn reports_require_owner_and_sequence_and_old_stop_is_harmless() {
+        let m = VoiceManager::default();
+        let lease = m.reserve("chat").unwrap();
+        {
+            let mut state = m.inner.slot.lock().unwrap();
+            state.as_mut().unwrap().remote = Some(RemoteSlot {
+                host: "host".into(),
+                last_sequence: 0,
+                last_report: Instant::now(),
+                confirm_deadline: None,
+                negotiation: None,
+                confirmed: false,
+                attempted: Arc::default(),
+            });
+        }
+        let lease = wire::Lease {
+            host_device_id: "host".into(),
+            voice: lease,
+        };
+        let mut p = wire::Report {
+            lease: lease.clone(),
+            sequence: 2,
+            muted: true,
+            state: wire::MediaState::Ready,
+        };
+        assert_eq!(
+            m.report_remote(&p).unwrap_err(),
+            VoiceRejection::InvalidLease
+        );
+        let owner = m.own_remote(lease.clone()).unwrap();
+        assert_eq!(m.report_remote(&p).unwrap().sequence, 2);
+        p.sequence = 1;
+        p.muted = false;
+        assert_eq!(m.report_remote(&p).unwrap().sequence, 2);
+        assert!(
+            m.inner
+                .slot
+                .lock()
+                .unwrap()
+                .as_ref()
+                .unwrap()
+                .snapshot
+                .muted
+        );
+        drop(owner);
+        let successor = m.reserve("next").unwrap();
+        m.stop_remote(&lease).unwrap();
+        assert!(m.owns_chat("next"));
+        m.stop(&successor).unwrap();
+    }
+}
diff --git a/crates/engine/tests/support/voice_relay.rs b/crates/engine/tests/support/voice_relay.rs
new file mode 100644
index 0000000000..8a031d4c4f
--- /dev/null
+++ b/crates/engine/tests/support/voice_relay.rs
@@ -0,0 +1,96 @@
+//! Route-only test relay; no cloud service or credentials.
+#![allow(clippy::result_large_err)]
+use futures::{SinkExt, StreamExt};
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use tokio::net::TcpListener;
+use tokio::sync::mpsc;
+use tokio_tungstenite::tungstenite::Message as WsMessage;
+use tokio_tungstenite::tungstenite::handshake::server::{
+    Request as WsRequest, Response as WsResponse,
+};
+use zeron_rpc::{DeviceFrameHeader, decode_device_frame, encode_device_frame};
+
+#[derive(Default)]
+struct RelayState {
+    host: Option<mpsc::UnboundedSender<Vec<u8>>>,
+    clients: HashMap<String, mpsc::UnboundedSender<Vec<u8>>>,
+}
+
+pub async fn fake_device_room() -> (String, tokio::task::JoinHandle<()>) {
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay");
+    let url = format!(
+        "http://127.0.0.1:{}",
+        listener.local_addr().expect("addr").port()
+    );
+    let state = Arc::new(Mutex::new(RelayState::default()));
+    let task = tokio::spawn(async move {
+        loop {
+            let Ok((stream, _)) = listener.accept().await else {
+                break;
+            };
+            let state = state.clone();
+            tokio::spawn(async move {
+                let mut uri = String::new();
+                let Ok(ws) = tokio_tungstenite::accept_hdr_async(
+                    stream,
+                    |req: &WsRequest, res: WsResponse| {
+                        uri = req.uri().to_string();
+                        Ok(res)
+                    },
+                )
+                .await
+                else {
+                    return;
+                };
+                let query = uri.split_once('?').map(|(_, q)| q).unwrap_or("");
+                let is_host = query.contains("role=host");
+                let conn_id = query
+                    .split('&')
+                    .find_map(|kv| kv.strip_prefix("connId="))
+                    .unwrap_or("anon")
+                    .to_string();
+                let (mut sink, mut ws_stream) = ws.split();
+                let (tx, mut rx) = mpsc::unbounded_channel::<Vec<u8>>();
+                {
+                    let mut st = state.lock().expect("lock");
+                    if is_host {
+                        st.host = Some(tx);
+                    } else {
+                        st.clients.insert(conn_id.clone(), tx);
+                    }
+                }
+                let writer = tokio::spawn(async move {
+                    while let Some(bytes) = rx.recv().await {
+                        if sink.send(WsMessage::Binary(bytes)).await.is_err() {
+                            break;
+                        }
+                    }
+                });
+                while let Some(Ok(message)) = ws_stream.next().await {
+                    let WsMessage::Binary(bytes) = message else {
+                        continue;
+                    };
+                    let Ok((header, payload)) = decode_device_frame(&bytes) else {
+                        break;
+                    };
+                    let st = state.lock().expect("lock");
+                    if is_host {
+                        let Some(to) = header.to else { continue };
+                        if let Some(client) = st.clients.get(&to) {
+                            let stripped = DeviceFrameHeader::new(header.s, header.k);
+                            let _ = client
+                                .send(encode_device_frame(&stripped, &payload).expect("encode"));
+                        }
+                    } else if let Some(host) = &st.host {
+                        let mut routed = DeviceFrameHeader::new(header.s, header.k);
+                        routed.from = Some(conn_id.clone());
+                        let _ = host.send(encode_device_frame(&routed, &payload).expect("encode"));
+                    }
+                }
+                writer.abort();
+            });
+        }
+    });
+    (url, task)
+}
diff --git a/crates/engine/tests/voice_runtime.rs b/crates/engine/tests/voice_runtime.rs
new file mode 100644
index 0000000000..fd755dd7a4
--- /dev/null
+++ b/crates/engine/tests/voice_runtime.rs
@@ -0,0 +1,492 @@
+//! Offline tests for the remote voice protocol against a fake native Codex package.
+use serde_json::json;
+use zeron_engine::{EngineCore, EngineProfile, HarnessRegistry};
+use zeron_proto::HarnessId;
+use zeron_rpc::methods;
+
+#[cfg(unix)]
+fn native_package(root: &std::path::Path) -> std::path::PathBuf {
+    use std::os::unix::fs::PermissionsExt;
+    let fixture =
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../harness/tests/fixtures");
+    let binary = root.join("bin/codex");
+    let helper = root.join("codex-resources/voice/bin/codex-voice-host");
+    std::fs::create_dir_all(binary.parent().unwrap()).unwrap();
+    std::fs::create_dir_all(helper.parent().unwrap()).unwrap();
+    std::fs::write(
+        root.join("codex-package.json"),
+        r#"{"layoutVersion":1,"version":"0.159.0"}"#,
+    )
+    .unwrap();
+    for (source, target) in [
+        ("fake-codex-voice-native.py", &binary),
+        ("fake-codex-voice-host.py", &helper),
+    ] {
+        std::fs::copy(fixture.join(source), target).unwrap();
+        std::fs::set_permissions(target, std::fs::Permissions::from_mode(0o755)).unwrap();
+    }
+    binary
+}
+#[cfg(unix)]
+async fn native_core(temp: &tempfile::TempDir) -> EngineCore {
+    let package = temp.path().join("codex-package");
+    let binary = native_package(&package);
+    let registry = std::sync::Arc::new(HarnessRegistry::new());
+    registry.register(std::sync::Arc::new(
+        zeron_harness::CodexHarness::new().with_executable(binary),
+    ));
+    let core = EngineCore::assemble_with_profile(
+        EngineProfile::local(&temp.path().join("data")).unwrap(),
+        registry,
+        HarnessId::Codex,
+        None,
+    )
+    .unwrap();
+    let config =
+        serde_json::from_value(json!({"harness":"codex","sandbox":"danger-full-access"})).unwrap();
+    core.workspace
+        .create_chat(
+            "native-voice",
+            None,
+            Some(&core.device_id),
+            Some(config),
+            Some(package.display().to_string()),
+        )
+        .unwrap();
+    core
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn remote_failed_prepare_after_rotation_preserves_thread_for_retry() {
+    use zeron_proto::voice::{ORCHESTRATOR_CHAT_PREFIX, remote as wire};
+    let temp = tempfile::tempdir().unwrap();
+    let core = native_core(&temp).await;
+    let client = zeron_rpc::memory_client(core.rpc_service());
+    let config =
+        serde_json::from_value(json!({"harness":"codex","sandbox":"danger-full-access"})).unwrap();
+    let mut request = wire::Prepare {
+        attempt_key: wire::AttemptKey::new(),
+        config,
+        voice: Some("invalid-voice".into()),
+    };
+    let envelope = |p: serde_json::Value| json!({"targetDeviceId":core.device_id,"payload":p});
+
+    // Seed a previous call at the rotation threshold with its native thread.
+    let previous = format!("{ORCHESTRATOR_CHAT_PREFIX}previous");
+    core.workspace
+        .create_chat(
+            &previous,
+            None,
+            Some(&core.device_id),
+            Some(request.config.clone()),
+            None,
+        )
+        .unwrap();
+    core.workspace
+        .set_chat_harness_session(&previous, "remembered-thread", "");
+    // The engine's `ROTATE_AFTER`.
+    const ROTATE_AFTER: usize = 1000;
+    let doc = core.doc_host.open(&previous).unwrap();
+    for i in 0..ROTATE_AFTER {
+        doc.write_user_message(&format!("m{i}"), "remember me", i as i64)
+            .unwrap();
+    }
+
+    // An unsupported voice fails after rotation and exercises the real
+    // preparation cleanup, rather than manually deleting the successor.
+    let failure = client
+        .call(methods::PREPARE_VOICE_V2, envelope(json!(request)))
+        .await
+        .unwrap_err();
+    assert!(
+        matches!(failure, zeron_rpc::RpcError::Failed(ref message)
+            if message == "voice unavailable: Unsupported"),
+        "unexpected preparation failure: {failure:?}"
+    );
+    let remaining: Vec<_> = core
+        .workspace
+        .read_chats()
+        .unwrap()
+        .into_iter()
+        .filter(|c| zeron_proto::voice::is_orchestrator_chat(&c.id))
+        .collect();
+    assert_eq!(
+        remaining.len(),
+        1,
+        "cleanup must remove the empty successor"
+    );
+    assert_eq!(
+        remaining[0].id, previous,
+        "cleanup must keep the predecessor"
+    );
+    assert_eq!(
+        core.workspace.chat_harness_session(&previous).unwrap().0,
+        "remembered-thread"
+    );
+    assert_eq!(doc.doc().read_entries().unwrap().len(), ROTATE_AFTER);
+
+    // A fresh attempt rotates again and resumes the original Codex thread.
+    request.attempt_key = wire::AttemptKey::new();
+    request.voice = None;
+    let prepared: wire::Prepared = client
+        .call_as(methods::PREPARE_VOICE_V2, envelope(json!(request)))
+        .await
+        .unwrap();
+    assert_ne!(prepared.chat_id, previous);
+    assert_eq!(
+        core.sessions
+            .last_request(&prepared.chat_id)
+            .unwrap()
+            .resume
+            .as_deref(),
+        Some("remembered-thread")
+    );
+    assert!(core.workspace.chat(&previous).unwrap().is_some());
+    client
+        .call(methods::STOP_VOICE_V2, envelope(json!(prepared.lease)))
+        .await
+        .unwrap();
+    core.sessions.shutdown().await;
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn remote_voice_full_control_flow_and_idempotent_prepare_without_host_audio() {
+    use zeron_proto::voice::{VoiceEvent, remote as wire};
+    let temp = tempfile::tempdir().unwrap();
+    let core = native_core(&temp).await;
+    std::fs::remove_file(
+        temp.path()
+            .join("codex-package/codex-resources/voice/bin/codex-voice-host"),
+    )
+    .unwrap();
+    let client = zeron_rpc::memory_client(core.rpc_service());
+    let request = wire::Prepare {
+        attempt_key: wire::AttemptKey::new(),
+        config: serde_json::from_value(json!({"harness":"codex","sandbox":"danger-full-access"}))
+            .unwrap(),
+        voice: None,
+    };
+    let envelope = |p: serde_json::Value| json!({"targetDeviceId":core.device_id,"payload":p});
+    let info: zeron_proto::EngineInfo = client
+        .call_as(methods::ENGINE_INFO, json!({}))
+        .await
+        .unwrap();
+    assert!(info.supports(wire::CAPABILITY));
+    let capabilities: wire::Capabilities = client
+        .call_as(methods::VOICE_CAPABILITIES_V2, envelope(json!({})))
+        .await
+        .unwrap();
+    assert_eq!(capabilities.protocol, wire::CAPABILITY);
+    assert!(capabilities.client_webrtc);
+    let call = envelope(serde_json::to_value(&request).unwrap());
+    let prepared: wire::Prepared = client
+        .call_as(methods::PREPARE_VOICE_V2, call.clone())
+        .await
+        .unwrap();
+    let again: wire::Prepared = client
+        .call_as(methods::PREPARE_VOICE_V2, call)
+        .await
+        .unwrap();
+    assert_eq!(again.chat_id, prepared.chat_id);
+    assert_eq!(
+        again.lease.voice.session_id,
+        prepared.lease.voice.session_id
+    );
+    assert!(prepared.chat_id.starts_with("voice-orchestrator-"));
+    assert_eq!(
+        core.workspace
+            .chat(&prepared.chat_id)
+            .unwrap()
+            .unwrap()
+            .title
+            .as_deref(),
+        Some(zeron_proto::voice::ORCHESTRATOR_CHAT_TITLE)
+    );
+    let mut owner = client
+        .subscribe_checked(
+            methods::OWN_VOICE_V2,
+            envelope(serde_json::to_value(&prepared.lease).unwrap()),
+        )
+        .await
+        .unwrap();
+    assert!(
+        client
+            .subscribe_checked(
+                methods::OWN_VOICE_V2,
+                envelope(serde_json::to_value(&prepared.lease).unwrap())
+            )
+            .await
+            .is_err()
+    );
+    let id = wire::AttemptKey::new();
+    let negotiation = wire::Negotiate {
+        lease: prepared.lease.clone(),
+        negotiation_id: id.clone(),
+        offer: wire::Sdp::new("fixture-offer".into()).unwrap(),
+    };
+    let reply: wire::Negotiated = client
+        .call_as(
+            methods::NEGOTIATE_VOICE_V2,
+            envelope(serde_json::to_value(&negotiation).unwrap()),
+        )
+        .await
+        .unwrap();
+    assert_eq!(reply.answer.expose(), "fixture-answer");
+    let repeat: wire::Negotiated = client
+        .call_as(
+            methods::NEGOTIATE_VOICE_V2,
+            envelope(serde_json::to_value(&negotiation).unwrap()),
+        )
+        .await
+        .unwrap();
+    assert_eq!(repeat.answer, reply.answer);
+    client
+        .call(
+            methods::CONFIRM_VOICE_MEDIA_V2,
+            envelope(
+                serde_json::to_value(wire::Confirm {
+                    lease: prepared.lease.clone(),
+                    negotiation_id: id,
+                    muted: false,
+                })
+                .unwrap(),
+            ),
+        )
+        .await
+        .unwrap();
+    tokio::time::timeout(std::time::Duration::from_secs(3), async {
+        loop {
+            if matches!(
+                serde_json::from_value::<VoiceEvent>(owner.recv().await.unwrap()).unwrap(),
+                VoiceEvent::Final { .. }
+            ) {
+                break;
+            }
+        }
+    })
+    .await
+    .unwrap();
+    drop(owner);
+    tokio::time::sleep(std::time::Duration::from_millis(400)).await;
+    assert!(
+        client
+            .call(
+                methods::PREPARE_VOICE_V2,
+                envelope(serde_json::to_value(request).unwrap())
+            )
+            .await
+            .is_err()
+    );
+    assert!(!temp.path().join("codex-package/helper-wire.jsonl").exists());
+    core.sessions.shutdown().await;
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn remote_cancel_before_prepare_and_owner_drop_preserve_other_calls() {
+    use zeron_proto::voice::remote as wire;
+    let temp = tempfile::tempdir().unwrap();
+    let core = native_core(&temp).await;
+    let client = zeron_rpc::memory_client(core.rpc_service());
+    let wrap = |p: serde_json::Value| json!({"targetDeviceId":core.device_id,"payload":p});
+    let config =
+        serde_json::from_value(json!({"harness":"codex","sandbox":"danger-full-access"})).unwrap();
+    let mut request = wire::Prepare {
+        attempt_key: wire::AttemptKey::new(),
+        config,
+        voice: None,
+    };
+    client
+        .call(
+            methods::CANCEL_VOICE_ATTEMPT_V2,
+            wrap(json!({"attemptKey":request.attempt_key})),
+        )
+        .await
+        .unwrap();
+    assert!(
+        client
+            .call(methods::PREPARE_VOICE_V2, wrap(json!(request)))
+            .await
+            .is_err()
+    );
+    assert!(!temp.path().join("codex-package/voice-wire.jsonl").exists());
+    request.attempt_key = wire::AttemptKey::new();
+    let prepared: wire::Prepared = client
+        .call_as(methods::PREPARE_VOICE_V2, wrap(json!(request)))
+        .await
+        .unwrap();
+    let owner = client
+        .subscribe_checked(methods::OWN_VOICE_V2, wrap(json!(prepared.lease)))
+        .await
+        .unwrap();
+    drop(owner);
+    tokio::time::timeout(std::time::Duration::from_secs(3), async {
+        while core.workspace.chat(&prepared.chat_id).unwrap().is_some() {
+            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+        }
+    })
+    .await
+    .unwrap();
+    let _: zeron_proto::EngineInfo = client
+        .call_as(methods::ENGINE_INFO, json!({}))
+        .await
+        .unwrap();
+    // The dropped voice stream did not close the connection or another generation.
+    request.attempt_key = wire::AttemptKey::new();
+    let next: wire::Prepared = client
+        .call_as(methods::PREPARE_VOICE_V2, wrap(json!(request)))
+        .await
+        .unwrap();
+    client
+        .call(methods::STOP_VOICE_V2, wrap(json!(prepared.lease)))
+        .await
+        .unwrap();
+    let next_owner = client
+        .subscribe_checked(methods::OWN_VOICE_V2, wrap(json!(next.lease)))
+        .await
+        .unwrap();
+    drop(next_owner);
+    core.sessions.shutdown().await;
+}
+
+#[cfg(unix)]
+#[path = "support/voice_relay.rs"]
+mod voice_relay;
+
+#[cfg(unix)]
+#[tokio::test]
+async fn remote_voice_crosses_two_engines_and_owner_drop_releases_host() {
+    use std::{sync::Arc, time::Duration};
+    use zeron_proto::voice::{VoiceEvent, remote as wire};
+    use zeron_rpc::{HostRelay, HostRelayConfig, LinkCache, LinkCacheConfig, StaticToken};
+    let temp = tempfile::tempdir().unwrap();
+    let host = native_core(&temp).await;
+    std::fs::remove_file(
+        temp.path()
+            .join("codex-package/codex-resources/voice/bin/codex-voice-host"),
+    )
+    .unwrap();
+    let (url, room) = voice_relay::fake_device_room().await;
+    let relay = HostRelay::spawn(
+        HostRelayConfig::new(
+            &url,
+            host.device_id.clone(),
+            Arc::new(StaticToken("test".into())),
+        ),
+        host.rpc_service(),
+        Arc::new(|_| true),
+    );
+    let viewer_dir = tempfile::tempdir().unwrap();
+    let viewer = EngineCore::assemble_with_profile(
+        EngineProfile::local(viewer_dir.path()).unwrap(),
+        Arc::new(HarnessRegistry::new()),
+        HarnessId::Codex,
+        None,
+    )
+    .unwrap();
+    let mut links = LinkCacheConfig::new(url, Arc::new(StaticToken("test".into())));
+    links.probe_timeout = Duration::from_secs(3);
+    viewer.set_links(LinkCache::new(links));
+    let client = zeron_rpc::memory_client(viewer.rpc_service());
+    let wrap = |p: serde_json::Value| json!({"targetDeviceId":host.device_id,"payload":p});
+    tokio::time::timeout(Duration::from_secs(12), async {
+        loop {
+            if client
+                .call(methods::VOICE_CAPABILITIES_V2, wrap(json!({})))
+                .await
+                .is_ok()
+            {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
+    })
+    .await
+    .unwrap();
+    let request = wire::Prepare {
+        attempt_key: wire::AttemptKey::new(),
+        config: serde_json::from_value(json!({"harness":"codex","sandbox":"danger-full-access"}))
+            .unwrap(),
+        voice: None,
+    };
+    let prepared: wire::Prepared = client
+        .call_as(methods::PREPARE_VOICE_V2, wrap(json!(request)))
+        .await
+        .unwrap();
+    assert!(viewer.workspace.chat(&prepared.chat_id).unwrap().is_none());
+    let mut owner = client
+        .subscribe_checked(methods::OWN_VOICE_V2, wrap(json!(prepared.lease)))
+        .await
+        .unwrap();
+    let id = wire::AttemptKey::new();
+    let _: wire::Negotiated = client
+        .call_as(
+            methods::NEGOTIATE_VOICE_V2,
+            wrap(json!(wire::Negotiate {
+                lease: prepared.lease.clone(),
+                negotiation_id: id.clone(),
+                offer: wire::Sdp::new("fixture-offer".into()).unwrap()
+            })),
+        )
+        .await
+        .unwrap();
+    client
+        .call(
+            methods::CONFIRM_VOICE_MEDIA_V2,
+            wrap(json!(wire::Confirm {
+                lease: prepared.lease.clone(),
+                negotiation_id: id,
+                muted: false
+            })),
+        )
+        .await
+        .unwrap();
+    tokio::time::timeout(Duration::from_secs(3), async {
+        while !matches!(
+            serde_json::from_value::<VoiceEvent>(owner.recv().await.unwrap()).unwrap(),
+            VoiceEvent::Final { .. }
+        ) {}
+    })
+    .await
+    .unwrap();
+    drop(owner);
+    tokio::time::timeout(Duration::from_secs(4), async {
+        loop {
+            let report = wire::Report {
+                lease: prepared.lease.clone(),
+                sequence: 1,
+                muted: true,
+                state: wire::MediaState::Ready,
+            };
+            if client
+                .call(methods::REPORT_VOICE_MEDIA_V2, wrap(json!(report)))
+                .await
+                .is_err()
+            {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(20)).await;
+        }
+    })
+    .await
+    .unwrap();
+    let info: zeron_proto::EngineInfo = client
+        .call_as(
+            methods::ENGINE_INFO,
+            json!({"targetDeviceId":host.device_id}),
+        )
+        .await
+        .unwrap();
+    assert_eq!(info.device_id, viewer.device_id); // EngineInfo is deliberately local.
+    client
+        .call(methods::VOICE_CAPABILITIES_V2, wrap(json!({})))
+        .await
+        .unwrap();
+    assert!(!temp.path().join("codex-package/helper-wire.jsonl").exists());
+    drop(relay);
+    room.abort();
+    host.sessions.shutdown().await;
+    viewer.sessions.shutdown().await;
+}
diff --git a/crates/harness/Cargo.toml b/crates/harness/Cargo.toml
index d9eeb0d29b..5adfa50dc7 100644
--- a/crates/harness/Cargo.toml
+++ b/crates/harness/Cargo.toml
@@ -22,11 +22,12 @@ path = "tests/fixtures/pi_rpc.rs"
 required-features = ["native-fixture"]
 
 [dependencies]
+zeron-voice-media.workspace = true
 zeron-proto.workspace = true
 base64 = "0.22"
 reqwest.workspace = true
 tokio.workspace = true
-tokio-util = { workspace = true, features = ["io-util"] }
+tokio-util = { workspace = true, features = ["io-util", "codec"] }
 uuid.workspace = true
 futures.workspace = true
 async-trait.workspace = true
diff --git a/crates/harness/examples/cursor_stability_probe.rs b/crates/harness/examples/cursor_stability_probe.rs
index 3b95847947..8770e5dad5 100644
--- a/crates/harness/examples/cursor_stability_probe.rs
+++ b/crates/harness/examples/cursor_stability_probe.rs
@@ -20,6 +20,7 @@ async fn turn(
     let (tx, steering) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: token.clone(),
@@ -139,6 +140,7 @@ async fn parked(harness: &CursorHarness, count: usize) {
     let nonce = format!("PARKED-STABILITY-{}", uuid::Uuid::new_v4());
     let (tx, steering) = mpsc::channel(8);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: CancellationToken::new(),
@@ -250,6 +252,7 @@ async fn burst(harness: &CursorHarness, count: usize, cancel: bool) {
     let (tx, steering) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: token.clone(),
@@ -387,6 +390,7 @@ async fn history(harness: &CursorHarness, count: usize) {
         .collect();
     let (tx, steering) = mpsc::channel(8);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: CancellationToken::new(),
diff --git a/crates/harness/examples/cursor_steering_probe.rs b/crates/harness/examples/cursor_steering_probe.rs
index 2d0f0b52ca..cc047ee5d0 100644
--- a/crates/harness/examples/cursor_steering_probe.rs
+++ b/crates/harness/examples/cursor_steering_probe.rs
@@ -26,6 +26,7 @@ async fn main() -> anyhow::Result<()> {
         .run(
             request,
             RunControls {
+                realtime: None,
                 execution_lease: None,
                 steering,
                 interrupt: interrupt.clone(),
diff --git a/crates/harness/examples/devin_models_probe.rs b/crates/harness/examples/devin_models_probe.rs
index 44140c527c..a6b6b6af37 100644
--- a/crates/harness/examples/devin_models_probe.rs
+++ b/crates/harness/examples/devin_models_probe.rs
@@ -27,6 +27,7 @@ async fn main() -> anyhow::Result<()> {
     };
     let (_steering, steering) = tokio::sync::mpsc::channel(8);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(|_| {
             let (tx, rx) = tokio::sync::oneshot::channel();
diff --git a/crates/harness/examples/grok_subagent_probe.rs b/crates/harness/examples/grok_subagent_probe.rs
index bc85f3e35b..9c5b498562 100644
--- a/crates/harness/examples/grok_subagent_probe.rs
+++ b/crates/harness/examples/grok_subagent_probe.rs
@@ -17,6 +17,7 @@ async fn main() {
     std::fs::create_dir_all(&cwd).unwrap();
     let (_steer_tx, steering) = mpsc::channel(8);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/examples/opencode_subagent_probe.rs b/crates/harness/examples/opencode_subagent_probe.rs
index 5057661a7d..5b1b5f55d6 100644
--- a/crates/harness/examples/opencode_subagent_probe.rs
+++ b/crates/harness/examples/opencode_subagent_probe.rs
@@ -25,6 +25,7 @@ async fn main() {
     std::fs::create_dir_all(&cwd).unwrap();
     let (_steer_tx, steering) = mpsc::channel(8);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/examples/opencode_turn_probe.rs b/crates/harness/examples/opencode_turn_probe.rs
index d4e8e9be1b..be55a72266 100644
--- a/crates/harness/examples/opencode_turn_probe.rs
+++ b/crates/harness/examples/opencode_turn_probe.rs
@@ -63,6 +63,7 @@ async fn main() {
         .run(
             request,
             RunControls {
+                realtime: None,
                 execution_lease: None,
                 request_input: Box::new(move |questions| {
                     assert!(
diff --git a/crates/harness/examples/steering_probe.rs b/crates/harness/examples/steering_probe.rs
index 5bbd4d0e25..19c8bd1b15 100644
--- a/crates/harness/examples/steering_probe.rs
+++ b/crates/harness/examples/steering_probe.rs
@@ -56,6 +56,7 @@ async fn main() -> anyhow::Result<()> {
         resume: None,
     };
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: interrupt.clone(),
diff --git a/crates/harness/src/acp/mod.rs b/crates/harness/src/acp/mod.rs
index c5d14f02f6..20b3ab00f8 100644
--- a/crates/harness/src/acp/mod.rs
+++ b/crates/harness/src/acp/mod.rs
@@ -3505,6 +3505,7 @@ async fn run_session(session: Session) {
         sign_in_prompted,
     } = session;
     let RunControls {
+        realtime: _,
         execution_lease: _execution_lease,
         request_input,
         mut steering,
diff --git a/crates/harness/src/claude/mod.rs b/crates/harness/src/claude/mod.rs
index a5be1d7245..ed03dc5bb2 100644
--- a/crates/harness/src/claude/mod.rs
+++ b/crates/harness/src/claude/mod.rs
@@ -755,6 +755,7 @@ async fn run_session(session: Session) {
         stderr_tail,
     } = session;
     let RunControls {
+        realtime: _,
         execution_lease: _execution_lease,
         request_input,
         mut steering,
diff --git a/crates/harness/src/codex/mod.rs b/crates/harness/src/codex/mod.rs
index ea212c46d9..e9d1744d13 100644
--- a/crates/harness/src/codex/mod.rs
+++ b/crates/harness/src/codex/mod.rs
@@ -38,6 +38,7 @@
 
 pub(crate) mod catalog;
 mod normalize;
+pub mod realtime;
 mod subagents;
 
 use std::collections::{HashMap, HashSet, VecDeque};
@@ -86,6 +87,21 @@ pub fn resolve_codex_executable() -> Option<PathBuf> {
     crate::executable::find_on_paths("codex", extra)
 }
 
+/// `canonicalize` yields `\\?\`-prefixed verbatim paths on Windows, which
+/// cmd.exe cannot launch batch shims through; keep the plain drive/UNC form.
+fn plain_executable(path: PathBuf) -> PathBuf {
+    #[cfg(windows)]
+    {
+        if let Some(rest) = path.to_str().and_then(|p| p.strip_prefix(r"\\?\")) {
+            return match rest.strip_prefix(r"UNC\") {
+                Some(share) => PathBuf::from(format!(r"\\{share}")),
+                None => PathBuf::from(rest),
+            };
+        }
+    }
+    path
+}
+
 /// Dotted `thread/start` config overrides that add an injected MCP server
 /// to the user's `mcp_servers` table.
 fn codex_mcp_overrides(mcp: &zeron_proto::McpServer) -> Vec<(String, Value)> {
@@ -652,7 +668,15 @@ impl Harness for CodexHarness {
         request: RunRequest,
         controls: RunControls,
     ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
-        self.run_with_mode(request, controls, false).await
+        self.run_with_mode(request, controls, false, false).await
+    }
+
+    async fn start_idle(
+        &self,
+        request: RunRequest,
+        controls: RunControls,
+    ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
+        self.run_with_mode(request, controls, false, true).await
     }
 
     async fn run_title(
@@ -666,7 +690,7 @@ impl Harness for CodexHarness {
         request.mcp = None;
         request.model_options.clear();
         request.auto_approve = false;
-        self.run_with_mode(request, controls, true).await
+        self.run_with_mode(request, controls, true, false).await
     }
 }
 
@@ -676,6 +700,7 @@ impl CodexHarness {
         mut request: RunRequest,
         controls: RunControls,
         title_only: bool,
+        idle: bool,
     ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
         let native = command_request(&request.prompt, "")?;
         if native
@@ -692,7 +717,13 @@ impl CodexHarness {
                 "Codex commands cannot include attachments; send them in a separate prompt".into(),
             ));
         }
-        let exe = self.resolve_executable()?;
+        // Pin the physical release for this process and its voice helper: an
+        // installer may move the current symlink while this runtime stays warm.
+        let exe = plain_executable(
+            self.resolve_executable()?
+                .canonicalize()
+                .map_err(HarnessError::Io)?,
+        );
         // Yolo mode: danger-full-access + approvalPolicy "never" (set below) —
         // codex's --dangerously-bypass-approvals-and-sandbox equivalent.
         // Parity with the Claude adapter, which auto-approves every
@@ -747,6 +778,8 @@ impl CodexHarness {
         let (event_tx, event_rx) = mpsc::channel::<Result<AgentEvent, HarnessError>>(256);
         tokio::spawn(run_session(Session {
             title_only,
+            idle,
+            executable: exe,
             child,
             client,
             incoming,
@@ -770,7 +803,9 @@ impl CodexHarness {
 // ---------------------------------------------------------------------------
 
 struct Session {
+    executable: PathBuf,
     title_only: bool,
+    idle: bool,
     child: Child,
     client: RpcClient,
     incoming: mpsc::Receiver<Incoming>,
@@ -946,7 +981,9 @@ async fn start_turn(client: &RpcClient, params: Value) -> Result<String, Harness
 /// steering mailbox, the interrupt token, and consumer liveness.
 async fn run_session(session: Session) {
     let Session {
+        executable,
         title_only,
+        idle,
         mut child,
         client,
         mut incoming,
@@ -958,6 +995,7 @@ async fn run_session(session: Session) {
         stderr_tail,
     } = session;
     let RunControls {
+        realtime,
         execution_lease: _execution_lease,
         request_input,
         mut steering,
@@ -1052,6 +1090,16 @@ async fn run_session(session: Session) {
             .await?;
         client.notify("initialized", None);
 
+        if realtime.is_some() {
+            // Codex's first account/read announces the initial auth snapshot
+            // via account/updated. Load it before attaching the voice router,
+            // which must keep aborting media on subsequent identity updates.
+            // A failed warmup must not block text; voice probes still verify auth.
+            let _ = client
+                .request("account/read", json!({"refreshToken": false}))
+                .await;
+        }
+
         let mut start_params = start_params.clone();
         if title_only {
             // Disable each configured MCP server explicitly: an empty table
@@ -1096,9 +1144,13 @@ async fn run_session(session: Session) {
         let thread_id = thread["thread"]["id"].as_str().unwrap_or("").to_owned();
         let mut children = subagents::Subagents::new(thread_id.clone());
         children.restore(&thread["thread"]);
-        Ok::<_, HarnessError>((thread_id, children))
+        let voice_context = realtime::ThreadContext {
+            cwd: thread["cwd"].as_str().unwrap_or(&request.cwd).to_owned(),
+            model_provider: thread["modelProvider"].as_str().map(str::to_owned),
+        };
+        Ok::<_, HarnessError>((thread_id, children, voice_context))
     };
-    let (thread_id, mut children) = tokio::select! {
+    let (thread_id, mut children, voice_context) = tokio::select! {
         res = setup => match res {
             Ok(thread_id) => thread_id,
             Err(e) => {
@@ -1173,19 +1225,30 @@ async fn run_session(session: Session) {
     }
 
     let mut router = TurnRouter::default();
-    match start_turn(&client, turn_params(&request.prompt)).await {
-        Ok(id) => router.adopt_started(id),
-        Err(e) => {
-            let _ = event_tx
-                .send(Ok(AgentEvent::Done {
-                    status: DoneStatus::Errored,
-                    result: None,
-                    error: Some(e.to_string()),
-                    session_id: Some(thread_id.clone()),
-                }))
-                .await;
-            shutdown_child(&mut child, kill_grace).await;
-            return;
+    let _voice_bridge = realtime.map(|controls| {
+        realtime::attach(
+            client.clone(),
+            thread_id.clone(),
+            executable,
+            voice_context,
+            controls,
+        )
+    });
+    if !idle {
+        match start_turn(&client, turn_params(&request.prompt)).await {
+            Ok(id) => router.adopt_started(id),
+            Err(e) => {
+                let _ = event_tx
+                    .send(Ok(AgentEvent::Done {
+                        status: DoneStatus::Errored,
+                        result: None,
+                        error: Some(e.to_string()),
+                        session_id: Some(thread_id.clone()),
+                    }))
+                    .await;
+                shutdown_child(&mut child, kill_grace).await;
+                return;
+            }
         }
     }
 
@@ -1203,7 +1266,7 @@ async fn run_session(session: Session) {
     let mut interrupted = false;
     let mut interrupt_sent = false;
     // A Done has been emitted for the turn currently/last in flight.
-    let mut done_current = false;
+    let mut done_current = idle;
     let mut current_native = command_request(&request.prompt, &thread_id)
         .ok()
         .flatten()
@@ -1240,7 +1303,17 @@ async fn run_session(session: Session) {
                     }
                 }
                 match method.as_str() {
-                    "turn/started" => router.note_started(turn_id(&params)),
+                    "turn/started" => {
+                        let id=turn_id(&params);
+                        // Native voice handoffs start a turn without going through turn/start.
+                        // Publish the boundary before its text/tool deltas reach the parked engine.
+                        if done_current && !id.is_empty() && !router.is_completed(&id) {
+                            done_current=false;
+                            let (prev,next)=rotate(&mut assistant_message_id);
+                            if !send(&event_tx,AgentEvent::Steered{assistant_message_id:Some(prev),next_assistant_message_id:Some(next)}).await {break 'main;}
+                        }
+                        router.note_started(id);
+                    },
 
                     "item/agentMessage/delta" => {
                         streamed_text.insert(item_id(&params));
diff --git a/crates/harness/src/codex/realtime.rs b/crates/harness/src/codex/realtime.rs
new file mode 100644
index 0000000000..fa499db85e
--- /dev/null
+++ b/crates/harness/src/codex/realtime.rs
@@ -0,0 +1,632 @@
+//! Ephemeral native subscription voice in the same app-server process as text/MCP.
+//! WebSocket appendAudio is deliberately unavailable: in Codex 0.159 it needs an API key.
+#[path = "realtime_host.rs"]
+mod host;
+use crate::jsonrpc::{Incoming, RpcClient};
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use serde_json::{Value, json};
+use std::sync::{Arc, Mutex};
+use std::{path::PathBuf, sync::atomic::Ordering, time::Duration};
+use tokio::sync::{broadcast, mpsc, oneshot};
+use tokio_util::sync::CancellationToken;
+type AudioAbort = Arc<Mutex<Option<(u64, CancellationToken)>>>;
+use zeron_proto::voice::*;
+
+/// Every Zeron voice session is a projectless orchestrator. Given to both the
+/// realtime voice model and the backing Codex model that runs its delegations.
+pub const ORCHESTRATOR_INSTRUCTIONS: &str = "This is a Zeron voice session and you are the user's orchestrator. Use the Zeron MCP tools to do the work: list and read chats, create new chats with the right agent and project, send them messages, check on their progress, and report back. Delegate coding and file changes to those chats instead of doing them yourself in this session. Keep spoken replies short and conversational.";
+
+#[derive(Clone)]
+pub(super) struct ThreadContext {
+    pub cwd: String,
+    pub model_provider: Option<String>,
+}
+
+pub enum VoiceCommand {
+    Probe {
+        external: bool,
+        reply: oneshot::Sender<Result<VoiceEligibility, VoiceRejection>>,
+    },
+    Start {
+        voice: Option<String>,
+        session_id: String,
+        generation: u64,
+        reply: oneshot::Sender<Result<(), VoiceRejection>>,
+    },
+    External {
+        voice: Option<String>,
+        session_id: String,
+        generation: u64,
+        offer: remote::Sdp,
+        reply: oneshot::Sender<Result<remote::Sdp, VoiceRejection>>,
+    },
+    Mute {
+        muted: bool,
+        reply: oneshot::Sender<Result<(), VoiceRejection>>,
+    },
+    Append {
+        frame: VoiceFrame,
+        reply: oneshot::Sender<Result<(), VoiceRejection>>,
+    },
+    Stop {
+        reply: oneshot::Sender<Result<(), VoiceRejection>>,
+    },
+}
+pub struct RealtimeControls {
+    audio_abort: AudioAbort,
+    invalidated: Arc<std::sync::atomic::AtomicBool>,
+    pub commands: mpsc::Receiver<VoiceCommand>,
+    pub events: broadcast::Sender<VoiceEvent>,
+}
+#[derive(Clone)]
+pub struct RealtimeHandle {
+    audio_abort: AudioAbort,
+    invalidated: Arc<std::sync::atomic::AtomicBool>,
+    pub commands: mpsc::Sender<VoiceCommand>,
+    pub events: broadcast::Sender<VoiceEvent>,
+}
+impl RealtimeHandle {
+    pub fn invalidated(&self) -> bool {
+        self.invalidated.load(Ordering::Acquire)
+    }
+    /// Immediately closes native capture even if the control actor is waiting on I/O.
+    pub fn abort_voice(&self, generation: u64) {
+        if let Some((current, cancel)) = self.audio_abort.lock().unwrap().as_ref() {
+            if *current == generation {
+                cancel.cancel();
+            }
+        }
+    }
+
+    pub async fn probe(&self) -> Result<VoiceEligibility, VoiceRejection> {
+        self.probe_mode(false).await
+    }
+    pub async fn probe_external(&self) -> Result<VoiceEligibility, VoiceRejection> {
+        self.probe_mode(true).await
+    }
+    async fn probe_mode(&self, external: bool) -> Result<VoiceEligibility, VoiceRejection> {
+        let (reply, rx) = oneshot::channel();
+        tokio::time::timeout(Duration::from_secs(15), async {
+            self.commands
+                .send(VoiceCommand::Probe { external, reply })
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            rx.await.map_err(|_| VoiceRejection::Protocol)?
+        })
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+    }
+
+    pub async fn stop(&self) -> Result<(), VoiceRejection> {
+        let (reply, rx) = oneshot::channel();
+        tokio::time::timeout(Duration::from_secs(8), async {
+            self.commands
+                .send(VoiceCommand::Stop { reply })
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            rx.await.map_err(|_| VoiceRejection::Protocol)?
+        })
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+    }
+    pub async fn mute(&self, muted: bool) -> Result<(), VoiceRejection> {
+        let (reply, rx) = oneshot::channel();
+        tokio::time::timeout(Duration::from_secs(8), async {
+            self.commands
+                .send(VoiceCommand::Mute { muted, reply })
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            rx.await.map_err(|_| VoiceRejection::Protocol)?
+        })
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+    }
+}
+pub fn channel() -> (
+    RealtimeHandle,
+    RealtimeControls,
+    broadcast::Receiver<VoiceEvent>,
+) {
+    let audio_abort = Arc::default();
+    let invalidated = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let (commands, rx) = mpsc::channel(8);
+    let (events, receiver) = broadcast::channel(32);
+    (
+        RealtimeHandle {
+            audio_abort: Arc::clone(&audio_abort),
+            invalidated: invalidated.clone(),
+            commands,
+            events: events.clone(),
+        },
+        RealtimeControls {
+            audio_abort,
+            invalidated,
+            commands: rx,
+            events,
+        },
+        receiver,
+    )
+}
+pub(crate) struct BridgeTask(tokio::task::JoinHandle<()>);
+impl Drop for BridgeTask {
+    fn drop(&mut self) {
+        self.0.abort();
+    }
+}
+
+/// Stops routing realtime notifications once the bridge ends, so a text-only
+/// runtime goes back to plain stdout handling.
+struct VoiceSubscription {
+    client: RpcClient,
+    overflow: Arc<std::sync::atomic::AtomicBool>,
+}
+impl Drop for VoiceSubscription {
+    fn drop(&mut self) {
+        self.client.unsubscribe_voice(&self.overflow);
+    }
+}
+
+pub(super) fn attach(
+    client: RpcClient,
+    thread: String,
+    executable: PathBuf,
+    context: ThreadContext,
+    controls: RealtimeControls,
+) -> BridgeTask {
+    let abort = controls.audio_abort.clone();
+    let invalidated = controls.invalidated.clone();
+    let (mut wire, overflow) = client.subscribe_voice(move || {
+        invalidated.store(true, Ordering::Release);
+        if let Some((_, cancel)) = abort.lock().unwrap().as_ref() {
+            cancel.cancel();
+        }
+    });
+    // Moved into the task so it unsubscribes even when aborted before polling.
+    let subscription = VoiceSubscription {
+        client: client.clone(),
+        overflow: overflow.clone(),
+    };
+    BridgeTask(tokio::spawn(async move {
+        let _subscription = subscription;
+        let RealtimeControls {
+            audio_abort,
+            invalidated,
+            mut commands,
+            events,
+        } = controls;
+        let mut native: Option<host::NativeHost> = None;
+        let mut external_active = false;
+        let mut external_reply: Option<oneshot::Sender<Result<remote::Sdp, VoiceRejection>>> = None;
+        let mut starting: Option<
+            futures::future::BoxFuture<'static, Result<Started, VoiceRejection>>,
+        > = None;
+        let mut start_reply: Option<oneshot::Sender<Result<(), VoiceRejection>>> = None;
+        let mut answer_tx: Option<oneshot::Sender<String>> = None;
+        let mut accepted_tx: Option<oneshot::Sender<()>> = None;
+        let mut expected_session = String::new();
+        let server_live = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let mut generation = 0;
+        let mut sequence = 0;
+        let mut timer = tokio::time::interval(Duration::from_millis(100));
+        timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        loop {
+            tokio::select! { biased;
+                command=commands.recv()=>match command {
+                    Some(VoiceCommand::Probe{external,reply})=>{let result=if invalidated.load(Ordering::Acquire){Err(VoiceRejection::InvalidLease)}else{probe_mode(&client,&executable,&context,external).await};let _=reply.send(if invalidated.load(Ordering::Acquire){Err(VoiceRejection::InvalidLease)}else{result});},
+                    Some(VoiceCommand::Start{voice,session_id,generation:next,reply})=>{
+                        if invalidated.load(Ordering::Acquire){let _=reply.send(Err(VoiceRejection::InvalidLease));continue;}
+                        if external_active || native.is_some() || starting.is_some() {let _=reply.send(Err(VoiceRejection::Busy));continue;}
+                        generation=next;sequence=0;
+                        let abort=CancellationToken::new();
+                        {let mut slot=audio_abort.lock().unwrap();
+                            if invalidated.load(Ordering::Acquire){let _=reply.send(Err(VoiceRejection::InvalidLease));continue;}
+                            *slot=Some((next,abort.clone()));
+                        }
+                        let (answer,answer_rx)=oneshot::channel();let (accepted,accepted_rx)=oneshot::channel();
+                        answer_tx=Some(answer);accepted_tx=Some(accepted);expected_session=session_id.clone();
+                        starting=Some(Box::pin({let client=client.clone();let thread=thread.clone();let executable=executable.clone();let context=context.clone();let server_live=server_live.clone();async move {
+                            start(client,thread,executable,context,voice,session_id,accepted_rx,answer_rx,abort,server_live).await.map(Started::Local)
+                        }}));
+                        start_reply=Some(reply);
+                    },
+                    Some(VoiceCommand::External{voice,session_id,generation:next,offer,reply})=>{
+                        if invalidated.load(Ordering::Acquire){let _=reply.send(Err(VoiceRejection::InvalidLease));continue;}
+                        if external_active || native.is_some() || starting.is_some(){let _=reply.send(Err(VoiceRejection::Busy));continue;}
+                        generation=next;sequence=0;
+                        let abort=CancellationToken::new();
+                        *audio_abort.lock().unwrap()=Some((next,abort.clone()));
+                        let (answer,answer_rx)=oneshot::channel();let (accepted,accepted_rx)=oneshot::channel();
+                        answer_tx=Some(answer);accepted_tx=Some(accepted);expected_session=session_id.clone();
+                        let client=client.clone();let thread=thread.clone();let context=context.clone();let server_live=server_live.clone();
+                        starting=Some(Box::pin(async move {
+                            tokio::select!{biased;
+                                _=abort.cancelled()=>Err(VoiceRejection::InvalidLease),
+                                answer=start_external(client,thread,context,voice,session_id,offer,accepted_rx,answer_rx,server_live)=>answer.map(Started::External),
+                            }
+                        }));
+                        external_reply=Some(reply);
+                    },
+                    Some(VoiceCommand::Mute{muted,reply})=>{
+                        let result=if let Some(host)=native.as_mut(){host.controls(muted).await}else{Err(VoiceRejection::Busy)};
+                        let failed=result.is_err();let _=reply.send(result);
+                        if failed {native=None;let _=events.send(VoiceEvent::Closed{generation,reason:Some(VoiceRejection::Protocol)});}
+                    },
+                    Some(VoiceCommand::Append{reply,..})=>{let _=reply.send(Err(VoiceRejection::Unsupported));},
+                    Some(VoiceCommand::Stop{reply})=>{
+                        let had_session=server_live.load(Ordering::Acquire);starting=None;native=None;external_active=false;
+                        if let Some(reply)=external_reply.take(){let _=reply.send(Err(VoiceRejection::InvalidLease));}
+                        if let Some(pending)=start_reply.take(){let _=pending.send(Err(VoiceRejection::InvalidLease));}
+                        let result=if had_session{
+                            let result=stop(&client,&thread).await;
+                            // Native stop acknowledges submission first. Drain its terminal event
+                            // before a successor can relabel old notifications with a new generation.
+                            let closed=tokio::time::timeout(Duration::from_secs(3),async {
+                                while let Some(notification)=wire.recv().await {
+                                    if let Incoming::Notification{method,params}=notification {
+                                        if params["threadId"]!=thread{continue;}
+                                        if method=="thread/realtime/closed" && params["reason"]=="requested"{server_live.store(false,Ordering::Release);return Ok::<_,VoiceRejection>(());}
+                                        if let Some(event)=normalize(&thread,generation,&mut sequence,&method,&params){let _=events.send(event);}
+                                    }
+                                }
+                                Err(VoiceRejection::Protocol)
+                            }).await;
+                            if result.is_err()||!matches!(closed,Ok(Ok(()))){let _=reply.send(Err(VoiceRejection::Protocol));break;}
+                            result
+                        }else{Ok(())};
+                        let _=events.send(VoiceEvent::Closed{generation,reason:None});let _=reply.send(result);
+                    },
+                    None=>break,
+                },
+                result=async{starting.as_mut().unwrap().await},if starting.is_some()=>{
+                    starting=None;
+                    match result {
+                        Ok(Started::Local(host))=>{native=Some(host);if let Some(reply)=start_reply.take(){let _=reply.send(Ok(()));}},
+                        Ok(Started::External(answer))=>{external_active=true;if let Some(reply)=external_reply.take(){let _=reply.send(Ok(answer));}},
+                        Err(reason)=>{
+                        if let Some(reply)=external_reply.take(){let _=reply.send(Err(reason));}
+                        if let Some(reply)=start_reply.take(){let _=reply.send(Err(reason));}
+                        let _=events.send(VoiceEvent::Closed{generation,reason:Some(reason)});
+                    }}
+                },
+                notification=wire.recv()=>match notification {
+                    Some(Incoming::Notification{method,params})=>{
+                        if method=="thread/realtime/closed" && params["threadId"]==thread {server_live.store(false,Ordering::Release);}
+                        if method=="account/updated" {native=None;starting=None;external_active=false;if let Some(reply)=external_reply.take(){let _=reply.send(Err(VoiceRejection::ChatgptRequired));}if let Some(reply)=start_reply.take(){let _=reply.send(Err(VoiceRejection::ChatgptRequired));}let _=events.send(VoiceEvent::Closed{generation,reason:Some(VoiceRejection::ChatgptRequired)});continue;}
+                        if params["threadId"]==thread && starting.is_some() {
+                            if method=="thread/realtime/started" {
+                                if params["version"]=="v3" && params["realtimeSessionId"]==expected_session {if let Some(tx)=accepted_tx.take(){let _=tx.send(());}}
+                                else {starting=None;if let Some(reply)=external_reply.take(){let _=reply.send(Err(VoiceRejection::Unsupported));}if let Some(reply)=start_reply.take(){let _=reply.send(Err(VoiceRejection::Unsupported));}let _=events.send(VoiceEvent::Closed{generation,reason:Some(VoiceRejection::Unsupported)});}
+                                continue;
+                            }
+                            if method=="thread/realtime/sdp" {
+                                if let Some(sdp)=params["sdp"].as_str().filter(|s|!s.is_empty()&&s.len()<=64*1024) {if let Some(tx)=answer_tx.take(){let _=tx.send(sdp.to_owned());}}
+                                continue;
+                            }
+                        }
+                        if external_active || native.is_some() || starting.is_some() {
+                            if let Some(event)=normalize(&thread,generation,&mut sequence,&method,&params) {
+                                let terminal=matches!(event,VoiceEvent::Closed{..}); let _=events.send(event);
+                                if terminal {native=None;starting=None;external_active=false;if let Some(reply)=external_reply.take(){let _=reply.send(Err(VoiceRejection::Protocol));}if let Some(reply)=start_reply.take(){let _=reply.send(Err(VoiceRejection::Protocol));}}
+                            }
+                        }
+                    },Some(_)=>{},None=>break,
+                },
+                _=timer.tick()=>{
+                    if overflow.load(Ordering::Acquire)||client.is_closed(){break;}
+                    if let Some(host)=native.as_mut(){ match host.levels().await {
+                        Ok((microphone,speaker))=>{let _=events.send(VoiceEvent::Levels{generation,microphone,speaker});},
+                        Err(reason)=>{native=None;let _=events.send(VoiceEvent::Closed{generation,reason:Some(reason)});}
+                    }}
+                }
+            }
+        }
+        let had_session = starting.take().is_some()
+            || native.is_some()
+            || external_active
+            || server_live.load(Ordering::Acquire);
+        drop(native);
+        if had_session {
+            let _ = stop(&client, &thread).await;
+        }
+        let _ = events.send(VoiceEvent::Closed {
+            generation,
+            reason: Some(VoiceRejection::Protocol),
+        });
+    }))
+}
+enum Started {
+    Local(host::NativeHost),
+    External(remote::Sdp),
+}
+
+async fn probe(
+    client: &RpcClient,
+    executable: &std::path::Path,
+    context: &ThreadContext,
+) -> Result<VoiceEligibility, VoiceRejection> {
+    probe_mode(client, executable, context, false).await
+}
+async fn probe_mode(
+    client: &RpcClient,
+    executable: &std::path::Path,
+    context: &ThreadContext,
+    external: bool,
+) -> Result<VoiceEligibility, VoiceRejection> {
+    if !external {
+        host::helper_path(executable)?;
+    }
+    tokio::time::timeout(Duration::from_secs(15), probe_details(client, context))
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+}
+async fn probe_details(
+    client: &RpcClient,
+    context: &ThreadContext,
+) -> Result<VoiceEligibility, VoiceRejection> {
+    if context.model_provider.as_deref() != Some("openai")
+        || !std::path::Path::new(&context.cwd).is_absolute()
+    {
+        return Err(VoiceRejection::ChatgptRequired);
+    }
+    let account = client
+        .request("account/read", json!({"refreshToken":false}))
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?;
+    if account["account"]["type"] != "chatgpt" {
+        return Err(VoiceRejection::ChatgptRequired);
+    }
+    let config = client
+        .request(
+            "config/read",
+            json!({"includeLayers":false,"cwd":context.cwd}),
+        )
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?;
+    let config = &config["config"];
+    if config["model_provider"]
+        .as_str()
+        .is_some_and(|p| p != "openai")
+        || config["model_providers"]["openai"].is_object()
+        || [
+            "experimental_realtime_ws_base_url",
+            "experimental_realtime_webrtc_call_base_url",
+            "experimental_realtime_ws_model",
+        ]
+        .iter()
+        .any(|k| !config[*k].is_null())
+    {
+        return Err(VoiceRejection::ChatgptRequired);
+    }
+    // No account/rateLimits/read: it is a ~1 s backend round trip, and ordinary
+    // quota may be exhausted while permitted credits remain. The native backend
+    // applies spend controls and the final usage decision.
+    let v = client
+        .request("thread/realtime/listVoices", json!({}))
+        .await
+        .map_err(|_| VoiceRejection::Unsupported)?;
+    let voices = v["voices"]["v1"]
+        .as_array()
+        .ok_or(VoiceRejection::Unsupported)?
+        .iter()
+        .filter_map(|v| v.as_str().map(str::to_owned))
+        .collect();
+    Ok(VoiceEligibility {
+        available: true,
+        reason: None,
+        ordinary_usage_allowed: None,
+        credits_excluded: false,
+        format: None,
+        duplex_verified: true,
+        native_webrtc: true,
+        voices,
+    })
+}
+async fn start(
+    client: RpcClient,
+    thread: String,
+    executable: PathBuf,
+    context: ThreadContext,
+    voice: Option<String>,
+    session_id: String,
+    accepted: oneshot::Receiver<()>,
+    answer: oneshot::Receiver<String>,
+    abort: CancellationToken,
+    server_live: Arc<std::sync::atomic::AtomicBool>,
+) -> Result<host::NativeHost, VoiceRejection> {
+    let eligible = probe(&client, &executable, &context).await?;
+    if voice.as_ref().is_some_and(|v| !eligible.voices.contains(v)) {
+        return Err(VoiceRejection::Unsupported);
+    }
+    let mut host = host::NativeHost::open(&host::helper_path(&executable)?, abort).await?;
+    let offer = host.exchange(json!({"type":"startTransport"}), 20).await?;
+    let sdp = offer["sdp"]
+        .as_str()
+        .filter(|s| !s.is_empty() && s.len() <= 64 * 1024)
+        .ok_or(VoiceRejection::Protocol)?;
+    if offer["type"] != "offer" {
+        return Err(VoiceRejection::Protocol);
+    }
+    let mut params = json!({"threadId":thread,"transport":{"type":"webrtc","sdp":sdp},"version":"v3","outputModality":"audio","realtimeSessionId":session_id,"clientManagedHandoffs":false,"includeStartupContext":true,
+        "realtimeStartInstructions":ORCHESTRATOR_INSTRUCTIONS,
+        "initialItems":[{"role":"developer","text":ORCHESTRATOR_INSTRUCTIONS}]});
+    if let Some(voice) = voice {
+        params["voice"] = json!(voice);
+    }
+    server_live.store(true, Ordering::Release);
+    tokio::time::timeout(
+        Duration::from_secs(30),
+        client.request("thread/realtime/start", params),
+    )
+    .await
+    .map_err(|_| VoiceRejection::Protocol)?
+    .map_err(|_| VoiceRejection::Protocol)?;
+    tokio::time::timeout(Duration::from_secs(30), accepted)
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+        .map_err(|_| VoiceRejection::Protocol)?;
+    let answer = tokio::time::timeout(Duration::from_secs(30), answer)
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+        .map_err(|_| VoiceRejection::Protocol)?;
+    host.expect(
+        json!({"type":"applyAnswer","sdp":answer}),
+        "transportReady",
+        20,
+    )
+    .await?;
+    host.expect(json!({"type":"openDevices"}), "devicesOpened", 5)
+        .await
+        .map_err(|_| VoiceRejection::DeviceUnavailable)?;
+    // Keep devices muted/suppressed until the engine confirms the owner stream.
+    Ok(host)
+}
+async fn start_external(
+    client: RpcClient,
+    thread: String,
+    context: ThreadContext,
+    voice: Option<String>,
+    session_id: String,
+    offer: remote::Sdp,
+    accepted: oneshot::Receiver<()>,
+    answer: oneshot::Receiver<String>,
+    server_live: Arc<std::sync::atomic::AtomicBool>,
+) -> Result<remote::Sdp, VoiceRejection> {
+    let eligible = tokio::time::timeout(Duration::from_secs(15), probe_details(&client, &context))
+        .await
+        .map_err(|_| VoiceRejection::Protocol)??;
+    if voice.as_ref().is_some_and(|v| !eligible.voices.contains(v)) {
+        return Err(VoiceRejection::Unsupported);
+    }
+    let mut params = json!({"threadId":thread,"transport":{"type":"webrtc","sdp":offer.expose()},"version":"v3","outputModality":"audio","realtimeSessionId":session_id,"clientManagedHandoffs":false,"includeStartupContext":true,
+        "realtimeStartInstructions":ORCHESTRATOR_INSTRUCTIONS,"initialItems":[{"role":"developer","text":ORCHESTRATOR_INSTRUCTIONS}]});
+    if let Some(voice) = voice {
+        params["voice"] = json!(voice);
+    }
+    server_live.store(true, Ordering::Release);
+    tokio::time::timeout(Duration::from_secs(90), async {
+        client
+            .request("thread/realtime/start", params)
+            .await
+            .map_err(|_| VoiceRejection::Protocol)?;
+        accepted.await.map_err(|_| VoiceRejection::Protocol)?;
+        remote::Sdp::new(answer.await.map_err(|_| VoiceRejection::Protocol)?)
+    })
+    .await
+    .map_err(|_| VoiceRejection::Protocol)?
+}
+
+async fn stop(client: &RpcClient, thread: &str) -> Result<(), VoiceRejection> {
+    tokio::time::timeout(
+        Duration::from_secs(2),
+        client.request("thread/realtime/stop", json!({"threadId":thread})),
+    )
+    .await
+    .map_err(|_| VoiceRejection::Protocol)?
+    .map_err(|_| VoiceRejection::Protocol)?;
+    Ok(())
+}
+
+/// Canonical completed items only. Legacy transcript/done has no stable item
+/// identity and is deliberately not committed alongside the canonical stream.
+pub(crate) fn normalize(
+    thread: &str,
+    generation: u64,
+    sequence: &mut u64,
+    method: &str,
+    p: &Value,
+) -> Option<VoiceEvent> {
+    if p.get("threadId")?.as_str()? != thread {
+        return None;
+    }
+    match method {
+        "thread/realtime/item/completed" => {
+            let item = p.get("item")?;
+            if item.get("type")?.as_str()? != "transcriptSegment" {
+                return None;
+            }
+            let text = item.get("text")?.as_str()?;
+            if text.len() > MAX_TRANSCRIPT_BYTES {
+                return None;
+            }
+            let role = match item.get("role")?.as_str()? {
+                "user" => VoiceRole::User,
+                "assistant" => VoiceRole::Assistant,
+                _ => return None,
+            };
+            Some(VoiceEvent::Final {
+                transcript: VoiceTranscript {
+                    session_id: item.get("realtimeSessionId")?.as_str()?.to_owned(),
+                    item_id: item.get("id")?.as_str()?.to_owned(),
+                    role,
+                    text: text.to_owned(),
+                    promoted_message_id: None,
+                },
+            })
+        }
+        "thread/realtime/outputAudio/delta" => {
+            let a = p.get("audio")?;
+            let data = a.get("data")?.as_str()?;
+            if data.len() > MAX_AUDIO_BYTES.div_ceil(3) * 4 {
+                return None;
+            }
+            let format = VoiceFormat {
+                encoding: VoiceEncoding::Pcm16Le,
+                sample_rate: u32::try_from(a.get("sampleRate")?.as_u64()?).ok()?,
+                channels: u16::try_from(a.get("numChannels")?.as_u64()?).ok()?,
+            };
+            if !format.validate(STANDARD.decode(data).ok()?.len()) {
+                return None;
+            }
+            *sequence += 1;
+            Some(VoiceEvent::Audio {
+                frame: VoiceFrame {
+                    generation,
+                    sequence: *sequence,
+                    format,
+                    data: data.to_owned(),
+                    item_id: a.get("itemId").and_then(Value::as_str).map(str::to_owned),
+                },
+            })
+        }
+        "thread/realtime/item/transcript/delta" => {
+            let text = p.get("delta")?.as_str()?;
+            (text.len() <= MAX_TRANSCRIPT_BYTES).then(|| VoiceEvent::Partial {
+                generation,
+                item_id: p.get("itemId").and_then(Value::as_str).map(str::to_owned),
+                text: text.to_owned(),
+            })
+        }
+        "thread/realtime/itemAdded"
+            if matches!(
+                p["item"]["type"].as_str(),
+                Some("input_audio_buffer.speech_started" | "response.cancelled")
+            ) =>
+        {
+            Some(VoiceEvent::InvalidatePlayout {
+                generation,
+                item_id: p["item"]["item_id"].as_str().unwrap_or_default().to_owned(),
+            })
+        }
+        "thread/realtime/closed" | "thread/realtime/error" => Some(VoiceEvent::Closed {
+            generation,
+            reason: (method.ends_with("error")).then_some(VoiceRejection::Protocol),
+        }),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn canonical_items_do_not_duplicate_legacy_or_foreign_threads() {
+        let p = json!({"threadId":"parent", "item":{"type":"transcriptSegment", "id":"item", "realtimeSessionId":"voice", "role":"user", "text":"hello"}});
+        let mut seq = 0;
+        assert!(matches!(
+            normalize("parent", 1, &mut seq, "thread/realtime/item/completed", &p),
+            Some(VoiceEvent::Final { .. })
+        ));
+        assert!(normalize("other", 1, &mut seq, "thread/realtime/item/completed", &p).is_none());
+        assert!(normalize("parent", 1, &mut seq, "thread/realtime/transcript/done", &p).is_none());
+    }
+}
diff --git a/crates/harness/src/codex/realtime_host.rs b/crates/harness/src/codex/realtime_host.rs
new file mode 100644
index 0000000000..fd6443d27b
--- /dev/null
+++ b/crates/harness/src/codex/realtime_host.rs
@@ -0,0 +1,3 @@
+//! Codex package resolver, shared with V2 desktop media: both use the audio
+//! helper of the device's standalone Codex installation.
+pub(super) use zeron_voice_media::{NativeHost, installed_helper as helper_path};
diff --git a/crates/harness/src/cursor/mod.rs b/crates/harness/src/cursor/mod.rs
index f4416021f5..2b4e3c1a53 100644
--- a/crates/harness/src/cursor/mod.rs
+++ b/crates/harness/src/cursor/mod.rs
@@ -516,6 +516,7 @@ async fn run_session(session: Session) {
         stderr_tail,
     } = session;
     let RunControls {
+        realtime: _,
         execution_lease: _execution_lease,
         request_input: _request_input,
         mut steering,
diff --git a/crates/harness/src/jsonrpc.rs b/crates/harness/src/jsonrpc.rs
index 339e15d2bf..5e160605df 100644
--- a/crates/harness/src/jsonrpc.rs
+++ b/crates/harness/src/jsonrpc.rs
@@ -44,12 +44,20 @@ type StdoutObserver = Box<dyn Fn(&str) + Send>;
 
 type Pending = Arc<Mutex<HashMap<i64, oneshot::Sender<Result<Value, String>>>>>;
 
+/// Where realtime voice notifications go instead of the session channel.
+struct VoiceRouter {
+    sender: mpsc::Sender<Incoming>,
+    overflow: Arc<AtomicBool>,
+    abort_media: Box<dyn Fn() + Send + Sync>,
+}
+
 #[derive(Clone)]
 pub(crate) struct RpcClient {
     next_id: Arc<AtomicI64>,
     pending: Pending,
     writer: mpsc::UnboundedSender<String>,
     closed: Arc<AtomicBool>,
+    voice_router: Arc<Mutex<Option<VoiceRouter>>>,
 }
 
 impl RpcClient {
@@ -69,12 +77,14 @@ impl RpcClient {
         let pending: Pending = Arc::default();
         let (incoming_tx, incoming_rx) = mpsc::channel(256);
         let closed = Arc::new(AtomicBool::new(false));
+        let voice_router = Arc::default();
         tokio::spawn(read_loop(
             stdout,
             Arc::clone(&pending),
             incoming_tx,
             closed.clone(),
             observer,
+            Arc::clone(&voice_router),
         ));
         (
             Self {
@@ -82,11 +92,41 @@ impl RpcClient {
                 pending,
                 writer: writer_tx,
                 closed,
+                voice_router,
             },
             incoming_rx,
         )
     }
 
+    /// Route `thread/realtime/*` notifications (and `account/updated`) to a
+    /// voice channel so stdout never waits for playout. Overflow is terminal:
+    /// the flag is set and `abort_media` runs.
+    pub fn subscribe_voice(
+        &self,
+        abort_media: impl Fn() + Send + Sync + 'static,
+    ) -> (mpsc::Receiver<Incoming>, Arc<AtomicBool>) {
+        let (tx, rx) = mpsc::channel(32);
+        let overflow = Arc::new(AtomicBool::new(false));
+        *self.voice_router.lock().expect("voice router") = Some(VoiceRouter {
+            sender: tx,
+            overflow: overflow.clone(),
+            abort_media: Box::new(abort_media),
+        });
+        (rx, overflow)
+    }
+
+    /// End the subscription identified by its `overflow` flag; a newer one is
+    /// left in place.
+    pub fn unsubscribe_voice(&self, overflow: &Arc<AtomicBool>) {
+        let mut router = self.voice_router.lock().expect("voice router");
+        if router
+            .as_ref()
+            .is_some_and(|r| Arc::ptr_eq(&r.overflow, overflow))
+        {
+            *router = None;
+        }
+    }
+
     pub fn is_closed(&self) -> bool {
         self.closed.load(Ordering::Acquire)
     }
@@ -228,6 +268,7 @@ async fn read_loop(
     tx: mpsc::Sender<Incoming>,
     closed: Arc<AtomicBool>,
     observer: Option<StdoutObserver>,
+    voice_router: Arc<Mutex<Option<VoiceRouter>>>,
 ) {
     let mut lines = BufReader::new(stdout).lines();
     // A read error ends the loop like EOF: either way the child's stdout is
@@ -289,6 +330,8 @@ async fn read_loop(
             }
             // Notification.
             (Some(method), None) => {
+                let realtime = method.starts_with("thread/realtime/");
+                let account_updated = method == "account/updated";
                 let incoming = Incoming::Notification {
                     method: method.to_owned(),
                     params: msg
@@ -296,6 +339,27 @@ async fn read_loop(
                         .map(Value::take)
                         .unwrap_or(Value::Null),
                 };
+                if let Some(router) = voice_router.lock().expect("voice router").as_ref() {
+                    if account_updated {
+                        // An account change ends any call; the session still sees it below.
+                        (router.abort_media)();
+                        if let Incoming::Notification { method, params } = &incoming {
+                            let copy = Incoming::Notification {
+                                method: method.clone(),
+                                params: params.clone(),
+                            };
+                            if router.sender.try_send(copy).is_err() {
+                                router.overflow.store(true, Ordering::Release);
+                            }
+                        }
+                    } else if realtime {
+                        if router.sender.try_send(incoming).is_err() {
+                            router.overflow.store(true, Ordering::Release);
+                            (router.abort_media)();
+                        }
+                        continue;
+                    }
+                }
                 if tx.send(incoming).await.is_err() {
                     return;
                 }
@@ -306,6 +370,9 @@ async fn read_loop(
     // EOF/read error: fail every awaiting request, then signal the loop.
     closed.store(true, Ordering::Release);
     pending.lock().expect("pending lock").clear();
+    if let Some(router) = voice_router.lock().expect("voice router").as_ref() {
+        (router.abort_media)();
+    }
     let _ = tx.send(Incoming::Eof).await;
 }
 
@@ -321,6 +388,7 @@ mod tests {
             pending: Arc::default(),
             writer,
             closed: Arc::new(AtomicBool::new(false)),
+            voice_router: Arc::default(),
         };
         client.notify("session/cancel", Some(json!({"sessionId": "parent"})));
         let frame: Value = serde_json::from_str(&receiver.try_recv().unwrap()).unwrap();
@@ -332,6 +400,23 @@ mod tests {
         assert!(client.pending.lock().unwrap().is_empty());
     }
 
+    #[test]
+    fn stale_voice_unsubscribe_keeps_the_newer_subscription() {
+        let client = RpcClient {
+            next_id: Arc::new(AtomicI64::new(0)),
+            pending: Arc::default(),
+            writer: mpsc::unbounded_channel().0,
+            closed: Arc::new(AtomicBool::new(false)),
+            voice_router: Arc::default(),
+        };
+        let (_old_rx, old) = client.subscribe_voice(|| {});
+        let (_new_rx, new) = client.subscribe_voice(|| {});
+        client.unsubscribe_voice(&old);
+        assert!(client.voice_router.lock().unwrap().is_some());
+        client.unsubscribe_voice(&new);
+        assert!(client.voice_router.lock().unwrap().is_none());
+    }
+
     #[tokio::test]
     async fn requests_after_eof_fail_without_entering_pending_map() {
         let (writer, mut receiver) = mpsc::unbounded_channel();
@@ -340,6 +425,7 @@ mod tests {
             pending: Arc::default(),
             writer,
             closed: Arc::new(AtomicBool::new(true)),
+            voice_router: Arc::default(),
         };
         let result = tokio::time::timeout(
             std::time::Duration::from_millis(100),
diff --git a/crates/harness/src/lib.rs b/crates/harness/src/lib.rs
index acefa20519..f82edf6b56 100644
--- a/crates/harness/src/lib.rs
+++ b/crates/harness/src/lib.rs
@@ -48,6 +48,7 @@ pub struct SteerMessage {
 
 /// Host-side controls handed to a run: input-request bridge + steering mailbox.
 pub struct RunControls {
+    pub realtime: Option<codex::realtime::RealtimeControls>,
     /// Shared execution gate held until the harness has shut down and reaped
     /// its subprocess, including when the host drops the event stream. Each
     /// detached session task must retain this lease through its cleanup.
@@ -159,6 +160,15 @@ pub trait Harness: Send + Sync {
         ))
     }
 
+    /// Bootstrap without a synthetic user prompt; providers opt in explicitly.
+    async fn start_idle(
+        &self,
+        _request: RunRequest,
+        _controls: RunControls,
+    ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
+        Err(HarnessError::Protocol("idle runtime unsupported".into()))
+    }
+
     /// Run one (persistent) session; the stream ends with `AgentEvent::Done`.
     async fn run(
         &self,
diff --git a/crates/harness/src/opencode/mod.rs b/crates/harness/src/opencode/mod.rs
index 35bb507508..74dc4b4ec6 100644
--- a/crates/harness/src/opencode/mod.rs
+++ b/crates/harness/src/opencode/mod.rs
@@ -1483,6 +1483,7 @@ async fn run_session(session: Session) {
         initial_native_command_selected,
     } = session;
     let RunControls {
+        realtime: _,
         execution_lease: _execution_lease,
         request_input,
         mut steering,
diff --git a/crates/harness/src/opencode/tests.rs b/crates/harness/src/opencode/tests.rs
index ee86b61e3b..8b3c4a72ff 100644
--- a/crates/harness/src/opencode/tests.rs
+++ b/crates/harness/src/opencode/tests.rs
@@ -255,6 +255,7 @@ impl TurnWire {
             server: Server::attached(base),
             event_tx,
             controls: RunControls {
+                realtime: None,
                 execution_lease: None,
                 request_input: Box::new(move |questions| {
                     let answer = answer.expect("fixture must not ask for input");
diff --git a/crates/harness/src/pi/mod.rs b/crates/harness/src/pi/mod.rs
index d4cb1660ae..743e7daf92 100644
--- a/crates/harness/src/pi/mod.rs
+++ b/crates/harness/src/pi/mod.rs
@@ -374,6 +374,7 @@ impl Harness for PiHarness {
             };
             // The lease lives through shutdown even if the consumer drops its stream.
             let RunControls {
+                realtime: _,
                 execution_lease: _lease,
                 request_input,
                 mut steering,
diff --git a/crates/harness/tests/acp.rs b/crates/harness/tests/acp.rs
index c7596f6d39..3768f72cba 100644
--- a/crates/harness/tests/acp.rs
+++ b/crates/harness/tests/acp.rs
@@ -56,6 +56,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
     let (steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/tests/acp_quiet.rs b/crates/harness/tests/acp_quiet.rs
index 38e08ea984..1793dbe652 100644
--- a/crates/harness/tests/acp_quiet.rs
+++ b/crates/harness/tests/acp_quiet.rs
@@ -60,6 +60,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
     let (steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions: Vec<UserInputQuestion>| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/tests/acp_stall.rs b/crates/harness/tests/acp_stall.rs
index 6acf1dafea..463cc2698a 100644
--- a/crates/harness/tests/acp_stall.rs
+++ b/crates/harness/tests/acp_stall.rs
@@ -37,6 +37,7 @@ async fn silent_agent_errors_via_the_prompt_stall_watchdog() {
     let (_steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |_| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/tests/claude.rs b/crates/harness/tests/claude.rs
index a759c72a6c..8809cea04a 100644
--- a/crates/harness/tests/claude.rs
+++ b/crates/harness/tests/claude.rs
@@ -60,6 +60,7 @@ fn controls(
     let (steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             let (tx, rx) = oneshot::channel();
@@ -291,6 +292,7 @@ async fn ask_user_question_round_trips_through_the_control_channel() {
     let token = CancellationToken::new();
     let seen = asked.clone();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             seen.lock().unwrap().extend(questions.iter().cloned());
diff --git a/crates/harness/tests/codex.rs b/crates/harness/tests/codex.rs
index 45c443fe4d..8fc09a6d3d 100644
--- a/crates/harness/tests/codex.rs
+++ b/crates/harness/tests/codex.rs
@@ -115,6 +115,7 @@ fn controls(
     let (steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             let (tx, rx) = oneshot::channel();
@@ -460,6 +461,7 @@ async fn approvals_round_trip_as_input_requests() {
     let token = CancellationToken::new();
     let seen = asked.clone();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             seen.lock().unwrap().extend(questions.iter().cloned());
@@ -1572,3 +1574,154 @@ async fn ordinary_followup_cannot_overtake_a_queued_native_command() {
         ]
     );
 }
+
+#[tokio::test]
+async fn idle_voice_runtime_has_no_initial_turn_and_preserves_mcp() {
+    let dir = tempfile::tempdir().unwrap();
+    let fixture =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/fake-codex-voice.py");
+    let driver = CodexHarness::new()
+        .with_executable(fixture)
+        .with_graces(Duration::from_millis(10), Duration::from_millis(100));
+    let mut req = request("must never be submitted");
+    req.cwd = dir.path().display().to_string();
+    req.mcp = Some(zeron_proto::McpServer {
+        name: "zeron".into(),
+        command: "zeron".into(),
+        args: vec!["mcp".into()],
+        env: Default::default(),
+    });
+    let (mut controls, steer, token) = controls("Yes");
+    let (voice, bridge, _events) = zeron_harness::codex::realtime::channel();
+    controls.realtime = Some(bridge);
+    let mut stream = driver.start_idle(req, controls).await.unwrap();
+    assert!(matches!(
+        tokio::time::timeout(Duration::from_secs(3), stream.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap(),
+        AgentEvent::SessionStarted { .. }
+    ));
+    let (reply, receive) = oneshot::channel();
+    voice
+        .commands
+        .send(zeron_harness::codex::realtime::VoiceCommand::Start {
+            voice: None,
+            session_id: "fixture-voice".into(),
+            generation: 1,
+            reply,
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        receive.await.unwrap(),
+        Err(zeron_proto::voice::VoiceRejection::NativeRuntimeUnavailable)
+    );
+    let calls = std::fs::read_to_string(dir.path().join("voice-wire.jsonl")).unwrap();
+    assert!(!calls.contains("turn/start"));
+    assert!(!calls.contains("thread/realtime/start"));
+    assert!(calls.contains("mcp_servers"));
+    steer
+        .send(SteerMessage {
+            prompt: "text remains usable".into(),
+            message_id: None,
+        })
+        .await
+        .unwrap();
+    tokio::time::timeout(Duration::from_secs(3), async {
+        while let Some(event) = stream.next().await {
+            if matches!(event.unwrap(), AgentEvent::Done { .. }) {
+                break;
+            }
+        }
+    })
+    .await
+    .unwrap();
+    token.cancel();
+    drop(stream);
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn external_voice_keeps_canonical_events_without_any_local_helper() {
+    use std::os::unix::fs::PermissionsExt;
+    use zeron_harness::codex::realtime::{VoiceCommand, channel};
+    use zeron_proto::voice::{VoiceEvent, remote::Sdp};
+    let dir = tempfile::tempdir().unwrap();
+    let binary = dir.path().join("bin/codex");
+    std::fs::create_dir_all(binary.parent().unwrap()).unwrap();
+    std::fs::copy(
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/fake-codex-voice-native.py"),
+        &binary,
+    )
+    .unwrap();
+    std::fs::set_permissions(&binary, std::fs::Permissions::from_mode(0o755)).unwrap();
+    let driver = CodexHarness::new().with_executable(binary);
+    let mut req = request("");
+    req.cwd = dir.path().display().to_string();
+    req.mcp = Some(zeron_proto::McpServer {
+        name: "zeron".into(),
+        command: "zeron".into(),
+        args: vec!["mcp".into()],
+        env: Default::default(),
+    });
+    let (mut controls, _steer, token) = controls("Yes");
+    let (voice, bridge, mut events) = channel();
+    controls.realtime = Some(bridge);
+    let mut stream = driver.start_idle(req, controls).await.unwrap();
+    assert!(matches!(
+        tokio::time::timeout(Duration::from_secs(3), stream.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap(),
+        AgentEvent::SessionStarted { .. }
+    ));
+    let pump = tokio::spawn(async move { while stream.next().await.is_some() {} });
+    assert!(voice.probe_external().await.unwrap().available);
+    assert_eq!(
+        voice.probe().await.unwrap_err(),
+        zeron_proto::voice::VoiceRejection::NativeRuntimeUnavailable
+    );
+    let (reply, answer) = oneshot::channel();
+    voice
+        .commands
+        .send(VoiceCommand::External {
+            voice: None,
+            session_id: "external-session".into(),
+            generation: 1,
+            offer: Sdp::new("fixture-offer".into()).unwrap(),
+            reply,
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        tokio::time::timeout(Duration::from_secs(3), answer)
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap()
+            .expose(),
+        "fixture-answer"
+    );
+    // Re-emission occurs after negotiation has completed, when there is no NativeHost.
+    std::fs::write(dir.path().join("replay-transcripts"), "true").unwrap();
+    tokio::time::timeout(Duration::from_secs(3), async {
+        loop {
+            if let VoiceEvent::Final { transcript } = events.recv().await.unwrap() {
+                assert_eq!(transcript.session_id, "external-session");
+                break;
+            }
+        }
+    })
+    .await
+    .unwrap();
+    voice.stop().await.unwrap();
+    assert!(!dir.path().join("helper-wire.jsonl").exists());
+    let wire = std::fs::read_to_string(dir.path().join("voice-wire.jsonl")).unwrap();
+    assert!(wire.contains("mcp_servers"));
+    assert!(!wire.contains("appendAudio"));
+    token.cancel();
+    pump.abort();
+}
diff --git a/crates/harness/tests/cursor.rs b/crates/harness/tests/cursor.rs
index 60a0c7d3dc..3f8c115f7c 100644
--- a/crates/harness/tests/cursor.rs
+++ b/crates/harness/tests/cursor.rs
@@ -50,6 +50,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
     let (steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |_| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/tests/fixtures/codex/voice-0.159.0.json b/crates/harness/tests/fixtures/codex/voice-0.159.0.json
new file mode 100644
index 0000000000..acf2c48c4e
--- /dev/null
+++ b/crates/harness/tests/fixtures/codex/voice-0.159.0.json
@@ -0,0 +1,463 @@
+{
+  "version": "0.159.0",
+  "schemas": {
+    "ThreadRealtimeAppendAudioParams": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "definitions": {
+        "ThreadRealtimeAudioChunk": {
+          "description": "EXPERIMENTAL - thread realtime audio chunk.",
+          "properties": {
+            "data": {
+              "type": "string"
+            },
+            "itemId": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "numChannels": {
+              "format": "uint16",
+              "minimum": 0.0,
+              "type": "integer"
+            },
+            "sampleRate": {
+              "format": "uint32",
+              "minimum": 0.0,
+              "type": "integer"
+            },
+            "samplesPerChannel": {
+              "format": "uint32",
+              "minimum": 0.0,
+              "type": [
+                "integer",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "data",
+            "numChannels",
+            "sampleRate"
+          ],
+          "type": "object"
+        }
+      },
+      "description": "EXPERIMENTAL - append audio input to thread realtime.",
+      "properties": {
+        "audio": {
+          "$ref": "#/definitions/ThreadRealtimeAudioChunk"
+        },
+        "threadId": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "audio",
+        "threadId"
+      ],
+      "title": "ThreadRealtimeAppendAudioParams",
+      "type": "object"
+    },
+    "ThreadRealtimeItemAddedNotification": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "description": "EXPERIMENTAL - raw non-audio thread realtime item emitted by the backend.",
+      "properties": {
+        "item": true,
+        "threadId": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "item",
+        "threadId"
+      ],
+      "title": "ThreadRealtimeItemAddedNotification",
+      "type": "object"
+    },
+    "ThreadRealtimeOutputAudioDeltaNotification": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "definitions": {
+        "ThreadRealtimeAudioChunk": {
+          "description": "EXPERIMENTAL - thread realtime audio chunk.",
+          "properties": {
+            "data": {
+              "type": "string"
+            },
+            "itemId": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "numChannels": {
+              "format": "uint16",
+              "minimum": 0.0,
+              "type": "integer"
+            },
+            "sampleRate": {
+              "format": "uint32",
+              "minimum": 0.0,
+              "type": "integer"
+            },
+            "samplesPerChannel": {
+              "format": "uint32",
+              "minimum": 0.0,
+              "type": [
+                "integer",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "data",
+            "numChannels",
+            "sampleRate"
+          ],
+          "type": "object"
+        }
+      },
+      "description": "EXPERIMENTAL - streamed output audio emitted by thread realtime.",
+      "properties": {
+        "audio": {
+          "$ref": "#/definitions/ThreadRealtimeAudioChunk"
+        },
+        "threadId": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "audio",
+        "threadId"
+      ],
+      "title": "ThreadRealtimeOutputAudioDeltaNotification",
+      "type": "object"
+    },
+    "ThreadRealtimeStartParams": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "definitions": {
+        "CodexResponseHandoffMode": {
+          "enum": [
+            "thinking",
+            "commentary",
+            "bemTags"
+          ],
+          "type": "string"
+        },
+        "ConversationTextRole": {
+          "enum": [
+            "user",
+            "developer",
+            "assistant"
+          ],
+          "type": "string"
+        },
+        "RealtimeConversationVersion": {
+          "enum": [
+            "v1",
+            "v2",
+            "v3"
+          ],
+          "type": "string"
+        },
+        "RealtimeOutputModality": {
+          "enum": [
+            "text",
+            "audio"
+          ],
+          "type": "string"
+        },
+        "RealtimeVoice": {
+          "enum": [
+            "alloy",
+            "arbor",
+            "ash",
+            "ballad",
+            "breeze",
+            "cedar",
+            "coral",
+            "cove",
+            "echo",
+            "ember",
+            "juniper",
+            "maple",
+            "marin",
+            "sage",
+            "shimmer",
+            "sol",
+            "spruce",
+            "vale",
+            "verse"
+          ],
+          "type": "string"
+        },
+        "ThreadRealtimeInitialItem": {
+          "description": "EXPERIMENTAL - role-bearing text item included when a realtime V3 session starts.",
+          "properties": {
+            "role": {
+              "$ref": "#/definitions/ConversationTextRole"
+            },
+            "text": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "role",
+            "text"
+          ],
+          "type": "object"
+        },
+        "ThreadRealtimeStartTransport": {
+          "description": "EXPERIMENTAL - transport used by thread realtime.",
+          "oneOf": [
+            {
+              "properties": {
+                "type": {
+                  "enum": [
+                    "websocket"
+                  ],
+                  "title": "WebsocketThreadRealtimeStartTransportType",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "type"
+              ],
+              "title": "WebsocketThreadRealtimeStartTransport",
+              "type": "object"
+            },
+            {
+              "properties": {
+                "sdp": {
+                  "description": "SDP offer generated by a WebRTC RTCPeerConnection after configuring audio and the realtime events data channel.",
+                  "type": "string"
+                },
+                "type": {
+                  "enum": [
+                    "webrtc"
+                  ],
+                  "title": "WebrtcThreadRealtimeStartTransportType",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "sdp",
+                "type"
+              ],
+              "title": "WebrtcThreadRealtimeStartTransport",
+              "type": "object"
+            },
+            {
+              "properties": {
+                "callId": {
+                  "description": "Identifier of a realtime call already created and negotiated by the client.",
+                  "type": "string"
+                },
+                "type": {
+                  "enum": [
+                    "existingCall"
+                  ],
+                  "title": "ExistingCallThreadRealtimeStartTransportType",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "callId",
+                "type"
+              ],
+              "title": "ExistingCallThreadRealtimeStartTransport",
+              "type": "object"
+            }
+          ]
+        }
+      },
+      "description": "EXPERIMENTAL - start a thread-scoped realtime session.",
+      "properties": {
+        "backendReasoningStatus": {
+          "description": "Relays public reasoning summaries as quiet context for realtime V3 delegations. Defaults to false.",
+          "type": "boolean"
+        },
+        "clientManagedHandoffs": {
+          "description": "Leaves Codex response handoffs to the client's explicit append calls instead of forwarding them automatically. Defaults to false.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "codexResponseHandoffChannelPrefixes": {
+          "additionalProperties": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "description": "Overrides BEM channel prefixes by `analysis`, `commentary`, or `final`. Omitted channels retain their default uppercase bracketed prefixes.",
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "codexResponseHandoffMode": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/CodexResponseHandoffMode"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Selects how automatic Codex responses are routed in Frameless Bidi sessions. Omitted values default to `thinking`. Realtime V1 and V2 ignore this setting."
+        },
+        "codexResponseItemPrefix": {
+          "description": "Optional prefix added to automatic Codex response items when `codexResponsesAsItems` is true.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "codexResponsesAsItems": {
+          "description": "Sends automatic Codex responses as realtime conversation items instead of handoff appends.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "delegationAckFiller": {
+          "description": "Controls whether a realtime V3 delegation produces an acknowledgement filler. Omitted values preserve the Realtime API's default behavior.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "flushTranscriptTailOnSessionEnd": {
+          "description": "Routes any transcript tail remaining at session end through Codex. Defaults to false. TODO: Remove this rollout knob once transcript-tail flushing is always enabled.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "includeStartupContext": {
+          "description": "Set to false to start without Codex's startup context. Omitted or null includes it.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "initialItems": {
+          "description": "Adds complete role-bearing text items to the initial Frameless Bidi session history. This is only supported by realtime V3 and is sent during session startup. Requests are limited to 128 items and 8,192 estimated text tokens in total.",
+          "items": {
+            "$ref": "#/definitions/ThreadRealtimeInitialItem"
+          },
+          "type": [
+            "array",
+            "null"
+          ]
+        },
+        "model": {
+          "description": "Overrides the configured realtime model for this session only.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "outputModality": {
+          "allOf": [
+            {
+              "$ref": "#/definitions/RealtimeOutputModality"
+            }
+          ],
+          "description": "Selects text or audio output for the realtime session. Transport and voice stay independent so clients can choose how they connect separately from what the model emits."
+        },
+        "prompt": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "realtimeEndInstructions": {
+          "description": "Developer instructions given to the backing Codex model when this realtime session ends.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "realtimeSessionId": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "realtimeStartInstructions": {
+          "description": "Developer instructions given to the backing Codex model when this realtime session starts.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "threadId": {
+          "type": "string"
+        },
+        "transport": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ThreadRealtimeStartTransport"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "version": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RealtimeConversationVersion"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Overrides the configured realtime protocol version for this session only."
+        },
+        "voice": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RealtimeVoice"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "required": [
+        "outputModality",
+        "threadId"
+      ],
+      "title": "ThreadRealtimeStartParams",
+      "type": "object"
+    },
+    "ThreadRealtimeTranscriptDoneNotification": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "description": "EXPERIMENTAL - final transcript text emitted when realtime completes a transcript part.",
+      "properties": {
+        "role": {
+          "type": "string"
+        },
+        "text": {
+          "description": "Final complete text for the transcript part.",
+          "type": "string"
+        },
+        "threadId": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "role",
+        "text",
+        "threadId"
+      ],
+      "title": "ThreadRealtimeTranscriptDoneNotification",
+      "type": "object"
+    }
+  }
+}
diff --git a/crates/harness/tests/fixtures/fake-codex-voice-host.py b/crates/harness/tests/fixtures/fake-codex-voice-host.py
new file mode 100755
index 0000000000..fd1b38c703
--- /dev/null
+++ b/crates/harness/tests/fixtures/fake-codex-voice-host.py
@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+"""Offline Codex native helper. Length-prefixed controls; never opens hardware/network."""
+import json, pathlib, struct, sys, os, time
+root=pathlib.Path(__file__).resolve().parents[3]
+if sys.argv[1:] == ['--build-commit']:
+    print('fixture-build');sys.exit(0)
+log=root/'helper-wire.jsonl'
+(root/'helper.pid').write_text(str(os.getpid()))
+def receive():
+    header=sys.stdin.buffer.read(4)
+    if not header:return None
+    length=struct.unpack('>I',header)[0]
+    if length>128*1024:raise ValueError('overflow')
+    return json.loads(sys.stdin.buffer.read(length))
+def send(value):
+    payload=json.dumps(value).encode();sys.stdout.buffer.write(struct.pack('>I',len(payload))+payload);sys.stdout.buffer.flush()
+try:
+    while (frame:=receive()) is not None:
+        with log.open('a') as out:out.write(json.dumps(frame)+'\n')
+        kind=frame['type']
+        if kind=='hello':assert frame=={'type':'hello','protocol':1,'buildCommit':'fixture-build'};send({'type':'ready'})
+        elif kind=='initializeRuntime':send({'type':'runtimeReady'})
+        elif kind=='startTransport':send({'type':'offer','sdp':'fixture-offer'})
+        elif kind=='applyAnswer':assert frame['sdp']=='fixture-answer';send({'type':'transportReady'})
+        elif kind=='openDevices':
+            if (root/'helper-mode').exists() and (root/'helper-mode').read_text().strip()=='exit-open':sys.exit(25)
+            send({'type':'devicesOpened'})
+        elif kind=='setAudioControls':
+            if (root/'helper-mode').exists() and (root/'helper-mode').read_text().strip()=='exit-controls':sys.exit(26)
+            if (root/'helper-mode').exists() and (root/'helper-mode').read_text().strip()=='stall-controls':
+                (root/'controls-stalled').write_text('true');time.sleep(60)
+            send({'type':'audioControlsApplied'})
+        elif kind=='inspectAudio':send({'type':'audioState','state':{'microphonePeak':1024,'speakerPeak':0}})
+        elif kind=='close':send({'type':'closed'});break
+        else:raise ValueError('unexpected command')
+finally:
+    with log.open('a') as out:out.write('{"type":"exited"}\n')
diff --git a/crates/harness/tests/fixtures/fake-codex-voice-native.py b/crates/harness/tests/fixtures/fake-codex-voice-native.py
new file mode 100755
index 0000000000..5997468016
--- /dev/null
+++ b/crates/harness/tests/fixtures/fake-codex-voice-native.py
@@ -0,0 +1,69 @@
+#!/usr/bin/python3
+"""Offline native app-server with WebRTC signaling and canonical voice events."""
+import json, pathlib, sys, threading, time
+root=pathlib.Path(__file__).resolve().parents[1]
+session=None
+account_initialized=False
+thread='idle-thread'
+wire_lock=threading.Lock()
+def send(v):
+    with wire_lock:print(json.dumps(v),flush=True)
+def notify(method,params):send({'method':method,'params':dict(threadId=thread,**params)})
+def identity_watch():
+    while True:
+        if (root/'identity-updated').exists():
+            (root/'identity-updated').unlink()
+            send({'method':'account/updated','params':{'authMode':'chatgpt'}})
+            (root/'identity-notified').write_text('true')
+        if (root/'replay-transcripts').exists() and session:
+            (root/'replay-transcripts').unlink()
+            for role,item,text in [('user','u1','Make a local Codex task'),('assistant','a1','I can do that.')]:
+                notify('thread/realtime/item/completed',{'item':{'type':'transcriptSegment','id':item,'realtimeSessionId':session,'role':role,'text':text}})
+            (root/'replay-sent').write_text('true')
+        time.sleep(0.01)
+threading.Thread(target=identity_watch,daemon=True).start()
+for line in sys.stdin:
+    frame=json.loads(line);method=frame.get('method')
+    with (root/'voice-wire.jsonl').open('a') as out:out.write(json.dumps(frame)+'\n')
+    if 'id' not in frame:continue
+    result={}
+    if method=='config/read':
+        result={'config':json.loads((root/'project-config').read_text()) if frame.get('params',{}).get('cwd') and (root/'project-config').exists() else {}}
+    elif method=='account/read':
+        if account_initialized and (root/'probe-delay').exists():
+            (root/'probing').write_text('true')
+            while not (root/'probe-release').exists():time.sleep(0.01)
+        result={'account':{'type':(root/'account-mode').read_text().strip() if (root/'account-mode').exists() else 'chatgpt'}}
+        if not account_initialized:
+            # Native Codex announces its initial account before answering the
+            # first account/read, even when no login or account switch occurred.
+            send({'method':'account/updated','params':{'authMode':'chatgpt' if result['account']['type']=='chatgpt' else 'apikey','planType':None}})
+            account_initialized=True
+    elif method=='account/rateLimits/read':result=json.loads((root/'rate-limits').read_text()) if (root/'rate-limits').exists() else {'ordinaryUsageAllowed':True}
+    elif method=='thread/realtime/listVoices':result={'voices':{'v1':['juniper','ember'],'v2':['alloy'],'defaultV1':'juniper','defaultV2':'alloy'}}
+    elif method in ('thread/start','thread/resume'):result={'thread':{'id':thread,'turns':[]},'cwd':frame['params'].get('cwd',str(root)),'modelProvider':(root/'thread-provider').read_text().strip() if (root/'thread-provider').exists() else 'openai'}
+    elif method=='turn/start':result={'turn':{'id':'text-turn'}}
+    elif method=='thread/realtime/start':
+        p=frame['params'];assert p['transport']=={'type':'webrtc','sdp':'fixture-offer'};assert p['version']=='v3';assert p['outputModality']=='audio';assert p['clientManagedHandoffs'] is False;assert p['includeStartupContext'] is True
+        assert 'Zeron MCP' in p['realtimeStartInstructions'] and p['initialItems']==[{'role':'developer','text':p['realtimeStartInstructions']}]
+        session=p['realtimeSessionId']
+    elif method=='thread/realtime/appendAudio':raise RuntimeError('subscription voice must never append PCM')
+    send({'id':frame['id'],'result':result})
+    if method=='thread/realtime/start':
+        notify('thread/realtime/started',{'realtimeSessionId':session,'version':'v3'})
+        notify('thread/realtime/sdp',{'sdp':'fixture-answer'})
+        for role,item,text in [('user','u1','Make a local Codex task'),('user','u1','Make a local Codex task'),('assistant','a1','I can do that.')]:
+            notify('thread/realtime/item/transcript/delta',{'itemId':item,'delta':text})
+            notify('thread/realtime/item/completed',{'item':{'type':'transcriptSegment','id':item,'realtimeSessionId':session,'role':role,'text':text}})
+            notify('thread/realtime/transcript/done',{'role':role,'text':text})
+        if (root/'conversation-only').exists():continue
+        notify('turn/started',{'turn':{'id':'native-task'}})
+        notify('item/agentMessage/delta',{'turnId':'native-task','itemId':'task-reply','delta':'Native task output'})
+        notify('thread/realtime/item/completed',{'item':{'type':'bemItemPromoted','id':'promotion','realtimeSessionId':session,'turnId':'native-task','itemId':'task-reply','presentation':{'type':'wholeItem'}}})
+    elif method=='thread/realtime/stop':
+        if (root/'spontaneous-close').exists():notify('thread/realtime/closed',{'reason':'transport_closed'})
+        def closed():
+            time.sleep(0.1 if (root/'delayed-close').exists() else 0)
+            notify('thread/realtime/closed',{'reason':'requested'})
+        threading.Thread(target=closed,daemon=True).start()
+    elif method=='turn/start':notify('turn/completed',{'turn':{'id':'text-turn','status':'completed'}})
diff --git a/crates/harness/tests/fixtures/fake-codex-voice.py b/crates/harness/tests/fixtures/fake-codex-voice.py
new file mode 100755
index 0000000000..43cac0045e
--- /dev/null
+++ b/crates/harness/tests/fixtures/fake-codex-voice.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Offline app-server peer; any realtime start is a test failure."""
+import json
+import pathlib
+import sys
+for line in sys.stdin:
+    frame = json.loads(line)
+    method = frame.get('method')
+    with pathlib.Path('voice-wire.jsonl').open('a') as log:
+        log.write(json.dumps(frame) + '\n')
+    if 'id' not in frame:
+        continue
+    result = {}
+    if method == 'config/read':
+        result = {'config': {}}
+    elif method in ('thread/start', 'thread/resume'):
+        result = {'thread': {'id': 'idle-thread', 'turns': []}}
+    elif method == 'turn/start':
+        result = {'turn': {'id': 'text-turn'}}
+    elif method == 'thread/realtime/start':
+        sys.exit(98)
+    print(json.dumps({'id': frame['id'], 'result': result}), flush=True)
+    if method == 'turn/start':
+        print(json.dumps({'method': 'turn/completed', 'params': {'threadId': 'idle-thread', 'turn': {'id':'text-turn', 'status':'completed'}}}), flush=True)
diff --git a/crates/harness/tests/fixtures/fake-codex.sh b/crates/harness/tests/fixtures/fake-codex.sh
index 96fadb09ad..212ee253a3 100755
--- a/crates/harness/tests/fixtures/fake-codex.sh
+++ b/crates/harness/tests/fixtures/fake-codex.sh
@@ -26,6 +26,10 @@ has "$line" '"method":"initialized"' || exit 1
 
 # ---- thread start / resume -------------------------------------------------
 read -r line || exit 1
+if has "$line" '"method":"account/read"'; then
+  emit "{\"id\":$(rid "$line"),\"result\":{\"account\":null,\"requiresOpenaiAuth\":false}}"
+  read -r line || exit 1
+fi
 if has "$line" '"method":"config/read"'; then
   emit "{\"id\":$(rid "$line"),\"result\":{\"config\":{\"mcp_servers\":{\"test\":{\"enabled\":true}}}}}"
   read -r line || exit 1
diff --git a/crates/harness/tests/managed_install.rs b/crates/harness/tests/managed_install.rs
index 395926b550..81f75e3614 100644
--- a/crates/harness/tests/managed_install.rs
+++ b/crates/harness/tests/managed_install.rs
@@ -29,6 +29,7 @@ async fn managed_install_reaches_session_started() {
     let (_steer_tx, steering) = mpsc::channel(1);
     let interrupt = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(|_| tokio::sync::oneshot::channel().1),
         steering,
diff --git a/crates/harness/tests/managed_install_failure.rs b/crates/harness/tests/managed_install_failure.rs
index 89a6df1d87..9bc7fce875 100644
--- a/crates/harness/tests/managed_install_failure.rs
+++ b/crates/harness/tests/managed_install_failure.rs
@@ -38,6 +38,7 @@ async fn silent_npm_enoent_death_surfaces_decoded_error() {
     let harness = AcpHarness::grok();
     let (_steer_tx, steering) = mpsc::channel(1);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(|_| tokio::sync::oneshot::channel().1),
         steering,
diff --git a/crates/harness/tests/opencode.rs b/crates/harness/tests/opencode.rs
index 0be238e9b9..6631c64758 100644
--- a/crates/harness/tests/opencode.rs
+++ b/crates/harness/tests/opencode.rs
@@ -274,6 +274,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
     let (steer_tx, steering) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/tests/pi_live.rs b/crates/harness/tests/pi_live.rs
index 872fbb7bd0..dc08d0464e 100644
--- a/crates/harness/tests/pi_live.rs
+++ b/crates/harness/tests/pi_live.rs
@@ -68,6 +68,7 @@ async fn real_pi_mock_lifecycle() {
         let (steer, steering) = mpsc::channel(8);
         let interrupt = CancellationToken::new();
         let controls = RunControls {
+            realtime: None,
             execution_lease: None,
             steering,
             interrupt: interrupt.clone(),
@@ -173,6 +174,7 @@ async fn real_pi_mock_lifecycle() {
     // continues in a new session and says so instead of failing every message.
     let (_, steering) = mpsc::channel(1);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: CancellationToken::new(),
@@ -244,6 +246,7 @@ async fn real_pi_steering_bursts_share_the_next_model_call() {
     let cwd = dir.path();
     let (tx, steering) = mpsc::channel(8);
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: CancellationToken::new(),
diff --git a/crates/harness/tests/pi_rpc.rs b/crates/harness/tests/pi_rpc.rs
index 1ed3277747..edb3f381ca 100644
--- a/crates/harness/tests/pi_rpc.rs
+++ b/crates/harness/tests/pi_rpc.rs
@@ -32,6 +32,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
     let token = CancellationToken::new();
     (
         RunControls {
+            realtime: None,
             execution_lease: None,
             steering: rx,
             interrupt: token.clone(),
diff --git a/crates/harness/tests/real_acp_lifecycle.rs b/crates/harness/tests/real_acp_lifecycle.rs
index 7dd779e624..4704ff410f 100644
--- a/crates/harness/tests/real_acp_lifecycle.rs
+++ b/crates/harness/tests/real_acp_lifecycle.rs
@@ -14,6 +14,7 @@ async fn live_run(cancel: bool) {
     let (steer, steering) = mpsc::channel(8);
     let interrupt = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         steering,
         interrupt: interrupt.clone(),
diff --git a/crates/harness/tests/real_quiet_survey.rs b/crates/harness/tests/real_quiet_survey.rs
index 9d674af508..10adea37ce 100644
--- a/crates/harness/tests/real_quiet_survey.rs
+++ b/crates/harness/tests/real_quiet_survey.rs
@@ -22,6 +22,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
     let (steer_tx, steer_rx) = mpsc::channel(8);
     let token = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(move |questions: Vec<UserInputQuestion>| {
             let (tx, rx) = oneshot::channel();
diff --git a/crates/harness/tests/windows_native.rs b/crates/harness/tests/windows_native.rs
index 26e7e5fa10..5299f67f1a 100644
--- a/crates/harness/tests/windows_native.rs
+++ b/crates/harness/tests/windows_native.rs
@@ -226,6 +226,7 @@ async fn exercise(prompt: &str, resume: Option<&str>) {
     let (steer_tx, steering) = mpsc::channel(4);
     let interrupt = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(|_| {
             let (tx, rx) = oneshot::channel();
@@ -320,6 +321,7 @@ async fn exercise_tree(prompt: &str, drop_stream: bool) {
     let (_steer, steering) = mpsc::channel(1);
     let interrupt = CancellationToken::new();
     let controls = RunControls {
+        realtime: None,
         execution_lease: None,
         request_input: Box::new(|_| {
             let (_, rx) = oneshot::channel();
@@ -479,6 +481,7 @@ async fn batch_overrides_launch_through_cmd() {
         unsafe { std::env::set_var("ZERON_TEST_BATCH_ARGS_FILE", &received) };
         let (_steer, steering) = mpsc::channel(1);
         let controls = RunControls {
+            realtime: None,
             execution_lease: None,
             request_input: Box::new(|_| {
                 let (tx, rx) = oneshot::channel();
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index e83e88bcf2..0551261d29 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -680,6 +680,8 @@ impl Tools {
                 Some(key) => Some(self.zeron.resolve_chat(key).await?.id),
                 None => self.zeron.origin().chat_id.clone(),
             }
+            // A hidden voice orchestrator creates top-level sessions.
+            .filter(|parent| !zeron_proto::voice::is_orchestrator_chat(parent))
         };
         anyhow::ensure!(
             args.kind != Some(ChatKind::Side) || parent_chat_id.is_some(),
@@ -1007,7 +1009,8 @@ impl Tools {
 
     /// Prefix the sender's identity when this server speaks for a chat, so
     /// the receiving agent (and the human reading that transcript) can tell
-    /// an agent-to-agent message from a typed one.
+    /// an agent-to-agent message from a typed one. Reply instructions always
+    /// use the full id: display prefixes need not uniquely identify a chat.
     async fn attribute(&self, target: &Chat, text: &str) -> String {
         let Some(origin_id) = self.zeron.origin().chat_id.as_deref() else {
             return text.to_owned();
@@ -1027,7 +1030,7 @@ impl Tools {
         };
         format!(
             "[Message from Zeron chat {label}. Reply to it with the Zeron `send_message` tool, chat {}.]\n\n{text}",
-            short(origin_id)
+            origin_id
         )
     }
 
@@ -1248,6 +1251,7 @@ mod tests {
         dispatch_barrier: Option<tokio::sync::Barrier>,
         beta_parent: Option<String>,
         beta_remote: bool,
+        extra_chats: Vec<Value>,
         catalog_error: Option<&'static str>,
         reads: Mutex<Vec<(String, Value)>>,
     }
@@ -1288,7 +1292,8 @@ mod tests {
                     "id": "space-unique", "deviceId": "dev-remote", "path": "/repo/unique",
                     "gitDetected": true, "createdAt": "2026-09-01T00:00:00Z"
                 }])),
-                methods::WATCH_CHATS => stream(json!([
+                methods::WATCH_CHATS => {
+                    let mut chats = json!([
                     {
                         "id": "chat-alpha-1", "deviceId": "dev-local", "title": "Alpha",
                         "archived": false, "spaceId": "space-1",
@@ -1301,7 +1306,13 @@ mod tests {
                         "archived": false, "spaceId": "space-1",
                         "createdAt": "2026-09-02T00:00:00Z"
                     }
-                ])),
+                    ]);
+                    chats
+                        .as_array_mut()
+                        .unwrap()
+                        .extend(self.extra_chats.clone());
+                    stream(chats)
+                }
                 methods::WATCH_SESSIONS => stream(json!([])),
                 methods::LIST_HARNESSES if remote => RpcReply::Value(json!([
                     {"id":"codex", "name":"Remote Codex", "installed":true},
@@ -1425,11 +1436,85 @@ mod tests {
             "{prompt}"
         );
         assert!(prompt.ends_with("please review"));
+        assert!(prompt.contains("tool, chat chat-beta-2.]"), "{prompt}");
         assert_eq!(params["command"]["request"]["cwd"], "/repo/comet");
         assert_eq!(params["command"]["request"]["harness"], "claude-code");
         assert_eq!(params["command"]["request"]["model"], "opus");
     }
 
+    #[tokio::test]
+    async fn replies_use_the_full_id_with_multiple_voice_orchestrators() {
+        let first = "voice-orchestrator-11111111-1111-4111-8111-111111111111";
+        let second = "voice-orchestrator-22222222-2222-4222-8222-222222222222";
+        let world = Arc::new(World {
+            extra_chats: [first, second]
+                .into_iter()
+                .map(|id| {
+                    json!({
+                        "id": id, "deviceId": "dev-local", "title": "Voice session",
+                        "archived": false, "createdAt": "2026-10-01T00:00:00Z"
+                    })
+                })
+                .collect(),
+            ..Default::default()
+        });
+        let orchestrator = tools(
+            world.clone(),
+            Origin {
+                chat_id: Some(second.into()),
+                device_id: None,
+            },
+        );
+        let error = orchestrator
+            .zeron
+            .resolve_chat("voice-or")
+            .await
+            .unwrap_err();
+        assert!(error.to_string().contains("2 chats start with"), "{error}");
+        orchestrator
+            .call(
+                "send_message",
+                json!({
+                    "chat": "alpha", "text": "please review"
+                }),
+            )
+            .await
+            .unwrap();
+        let reply_id = {
+            let writes = world.writes.lock().unwrap();
+            let prompt = writes.last().unwrap().1["command"]["request"]["prompt"]
+                .as_str()
+                .unwrap();
+            prompt
+                .split_once("tool, chat ")
+                .unwrap()
+                .1
+                .split_once(".]\n\n")
+                .unwrap()
+                .0
+                .to_owned()
+        };
+        assert_eq!(reply_id, second);
+        let worker = tools(
+            world.clone(),
+            Origin {
+                chat_id: Some("chat-alpha-1".into()),
+                device_id: None,
+            },
+        );
+        worker
+            .call(
+                "send_message",
+                json!({
+                    "chat": reply_id, "text": "review complete"
+                }),
+            )
+            .await
+            .unwrap();
+        let writes = world.writes.lock().unwrap();
+        assert_eq!(writes.last().unwrap().1["chatId"], second);
+    }
+
     #[tokio::test]
     async fn auto_steers_busy_chats_even_at_turn_boundaries_or_after_long_quiet_tools() {
         let world = Arc::new(World::default());
@@ -2160,6 +2245,60 @@ mod tests {
         assert_eq!(result["turn"]["replies"], json!([]));
     }
 
+    #[tokio::test]
+    async fn remote_replies_do_not_require_synchronized_clocks() {
+        for host_skew_millis in [-1_000, 1_000] {
+            for wait in [true, false] {
+                let service = Arc::new(DelayedTurn {
+                    world: World {
+                        beta_remote: true,
+                        ..Default::default()
+                    },
+                    sent: Mutex::new(None),
+                    reply_delay: Duration::from_millis(450),
+                    never_reply: false,
+                    host_skew_millis,
+                });
+                let tools = Tools::new(Arc::new(Zeron::with_client(
+                    memory_client(service),
+                    Origin::default(),
+                )));
+                let sent = tools
+                    .call(
+                        "send_message",
+                        json!({
+                            "chat":"Beta", "text":"go", "wait":wait, "timeout_secs":2
+                        }),
+                    )
+                    .await
+                    .unwrap();
+                let result = if wait {
+                    sent
+                } else {
+                    tools
+                        .call(
+                            "wait_for_turn",
+                            json!({
+                                "chat":sent["chatId"], "timeout_secs":2
+                            }),
+                        )
+                        .await
+                        .unwrap()
+                };
+                assert_eq!(
+                    result["turn"]["outcome"], "completed",
+                    "offset={host_skew_millis}, wait={wait}: {result}"
+                );
+                assert_eq!(
+                    result["turn"]["replies"].as_array().unwrap().len(),
+                    1,
+                    "{result}"
+                );
+                assert_eq!(result["turn"]["replies"][0]["id"], "new-reply");
+            }
+        }
+    }
+
     #[tokio::test]
     async fn initialize_and_list_over_jsonrpc() {
         let world = Arc::new(World::default());
diff --git a/crates/mobile/Cargo.toml b/crates/mobile/Cargo.toml
index 12d8a1beaf..1e1845b303 100644
--- a/crates/mobile/Cargo.toml
+++ b/crates/mobile/Cargo.toml
@@ -21,6 +21,12 @@ required-features = ["bindgen"]
 bindgen = ["uniffi/cli"]
 
 [dependencies]
+zeron-voice-session.workspace = true
+zeron-orb.workspace = true
+zeron-veil.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+async-trait.workspace = true
 uniffi = "0.32"
 zeron-markdown.workspace = true
 zeron-text.workspace = true
diff --git a/crates/mobile/src/caption.rs b/crates/mobile/src/caption.rs
new file mode 100644
index 0000000000..bf1c59cdf1
--- /dev/null
+++ b/crates/mobile/src/caption.rs
@@ -0,0 +1,94 @@
+//! The voice call caption's streaming veil (`zeron-veil`), exactly as the
+//! desktop stage runs it. Offsets are UTF-16 so the platform can apply them to
+//! its attributed strings directly.
+use std::sync::Mutex;
+use std::time::Instant;
+use zeron_veil::CaptionVeil;
+
+/// A veiled UTF-16 range of the caption and its opacity (0..1).
+#[derive(Debug, Clone, PartialEq, uniffi::Record)]
+pub struct CaptionSpan {
+    pub start: u32,
+    pub end: u32,
+    pub alpha: f32,
+}
+
+#[derive(Debug, Clone, PartialEq, uniffi::Record)]
+pub struct CaptionFrame {
+    /// The tail of the utterance to show (ellipsized in front when long).
+    pub text: String,
+    pub spans: Vec<CaptionSpan>,
+    /// The previous utterance while it fades out, and its opacity.
+    pub previous: Option<String>,
+    pub previous_alpha: f32,
+    /// Something is still fading: ask for the next frame.
+    pub animating: bool,
+}
+
+/// One call's caption. Advance it whenever the caption changes and on every
+/// display frame while the last frame was `animating`.
+#[derive(uniffi::Object)]
+pub struct CaptionFader {
+    veil: Mutex<CaptionVeil>,
+}
+
+#[uniffi::export]
+impl CaptionFader {
+    #[uniffi::constructor]
+    pub fn new(max_chars: u32) -> std::sync::Arc<Self> {
+        std::sync::Arc::new(Self {
+            veil: Mutex::new(CaptionVeil::new(max_chars as usize)),
+        })
+    }
+
+    pub fn frame(&self, item: Option<String>, text: String, reduced_motion: bool) -> CaptionFrame {
+        let mut veil = self.veil.lock().unwrap();
+        let frame = veil.advance(item.as_deref(), &text, Instant::now(), reduced_motion);
+        let utf16 = |byte: usize| frame.text[..byte].encode_utf16().count() as u32;
+        let spans = frame
+            .spans
+            .iter()
+            .map(|(range, alpha)| CaptionSpan {
+                start: utf16(range.start),
+                end: utf16(range.end),
+                alpha: *alpha,
+            })
+            .collect();
+        let (previous, previous_alpha) = frame
+            .previous
+            .clone()
+            .map_or((None, 0.0), |(text, alpha)| (Some(text), alpha));
+        CaptionFrame {
+            text: frame.text,
+            spans,
+            previous,
+            previous_alpha,
+            animating: veil.is_animating(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spans_are_utf16_offsets_into_the_shown_tail() {
+        let fader = CaptionFader::new(160);
+        let frame = fader.frame(Some("a".into()), "Hola 👋 ".into(), false);
+        assert_eq!(frame.text, "Hola 👋");
+        // "👋" is two UTF-16 units: the whole caption spans 7 of them.
+        assert_eq!(
+            frame.spans,
+            vec![CaptionSpan {
+                start: 0,
+                end: 7,
+                alpha: 0.0
+            }]
+        );
+        assert!(frame.animating);
+        let frame = fader.frame(Some("b".into()), "Sí".into(), false);
+        assert_eq!(frame.previous.as_deref(), Some("Hola 👋"));
+        assert_eq!(frame.previous_alpha, 1.0);
+    }
+}
diff --git a/crates/mobile/src/client_ffi/mod.rs b/crates/mobile/src/client_ffi/mod.rs
index 02b480b041..80d8213f11 100644
--- a/crates/mobile/src/client_ffi/mod.rs
+++ b/crates/mobile/src/client_ffi/mod.rs
@@ -12,6 +12,8 @@
 //! (`snapshot()` / `subscribe()`), never over FFI.
 
 mod session;
+mod voice;
+pub use voice::*;
 mod types;
 
 use std::sync::Arc;
diff --git a/crates/mobile/src/client_ffi/voice.rs b/crates/mobile/src/client_ffi/voice.rs
new file mode 100644
index 0000000000..6eaa15f46d
--- /dev/null
+++ b/crates/mobile/src/client_ffi/voice.rs
@@ -0,0 +1,550 @@
+//! Bounded platform callbacks; no PCM or provider credentials cross UniFFI.
+//! The call state is reduced here (`zeron_voice_session::VoiceView`), so the
+//! platform renders typed snapshots exactly as the desktop reads them.
+use super::*;
+use crate::orb::VoiceOrb;
+use std::collections::HashMap;
+use std::sync::{
+    Mutex,
+    atomic::{AtomicBool, AtomicU64, Ordering},
+};
+use tokio::sync::{mpsc, oneshot, watch};
+use tokio_util::sync::CancellationToken;
+use zeron_proto::voice::{VoicePhase, VoiceRejection, VoiceRole, VoiceWork, remote::Sdp};
+use zeron_voice_session::{VoiceMediaEndpoint, VoiceView};
+
+#[derive(Clone, Copy, uniffi::Enum)]
+pub enum VoiceMediaOperation {
+    Prepare,
+    Offer,
+    ApplyAnswer,
+    SetMuted,
+    Levels,
+    Close,
+}
+#[derive(Clone, uniffi::Record)]
+pub struct VoiceMediaRequest {
+    pub request_id: u64,
+    pub operation: VoiceMediaOperation,
+    pub sdp: Option<String>,
+    pub muted: bool,
+}
+/// Why a platform media operation failed.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, uniffi::Enum)]
+pub enum VoiceMediaFailure {
+    PermissionDenied,
+    Unavailable,
+}
+#[uniffi::export(with_foreign)]
+pub trait VoiceMediaListener: Send + Sync {
+    fn on_request(&self, request: VoiceMediaRequest);
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, uniffi::Enum)]
+pub enum VoiceCallPhase {
+    Connecting,
+    Active,
+    Ending,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, uniffi::Enum)]
+pub enum VoiceCallWork {
+    Idle,
+    /// The orchestrator's Codex turn (or a delegation) is running.
+    Working,
+    /// Codex asked the user something; answer it in the transcript.
+    AwaitingInput,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, uniffi::Enum)]
+pub enum VoiceSpeaker {
+    User,
+    Assistant,
+}
+/// Everything a call screen shows. Ephemeral: never log or persist captions.
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct VoiceCallState {
+    pub phase: VoiceCallPhase,
+    pub orb: VoiceOrb,
+    /// Full id of the host's orchestrator chat (its canonical transcript).
+    pub chat_id: Option<String>,
+    pub work: VoiceCallWork,
+    pub muted: bool,
+    /// The assistant's voice is playing.
+    pub speaking: bool,
+    pub caption: String,
+    /// Set once the caption is a final segment; live partials have none.
+    pub caption_speaker: Option<VoiceSpeaker>,
+    /// The utterance the caption belongs to: a change is a new speaker turn.
+    pub caption_item: Option<String>,
+    /// Normalized 0…1 peaks (microphone is 0 while muted).
+    pub microphone: f32,
+    pub speaker: f32,
+    /// Styles the host offers, once it reports them.
+    pub voices: Vec<String>,
+}
+/// Why a call ended without the user hanging up.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, uniffi::Enum)]
+pub enum VoiceEndReason {
+    MicrophoneDenied,
+    AudioUnavailable,
+    /// Codex on the host must be signed in with ChatGPT.
+    SignInRequired,
+    UsageUnavailable,
+    /// The host already has a voice call.
+    Busy,
+    HostUnavailable,
+    /// The host's Zeron is too old or has remote voice disabled.
+    HostIncompatible,
+    ConnectionLost,
+}
+impl From<VoiceRejection> for VoiceEndReason {
+    fn from(reason: VoiceRejection) -> Self {
+        use VoiceRejection::*;
+        match reason {
+            MicrophonePermissionDenied => Self::MicrophoneDenied,
+            DeviceUnavailable | MicrophoneMetadataMissing => Self::AudioUnavailable,
+            ChatgptRequired => Self::SignInRequired,
+            IncludedUsageUnavailable | CreditExclusionUnverified => Self::UsageUnavailable,
+            Busy => Self::Busy,
+            RemoteHost => Self::HostUnavailable,
+            Disabled
+            | Unsupported
+            | WrongHarness
+            | NativeRuntimeUnavailable
+            | AudioFormatUnverified
+            | DuplexUnverified => Self::HostIncompatible,
+            InvalidLease | StaleGeneration | Overflow | Protocol => Self::ConnectionLost,
+        }
+    }
+}
+#[uniffi::export(with_foreign)]
+pub trait VoiceSessionListener: Send + Sync {
+    fn on_voice_state(&self, state: VoiceCallState);
+    /// Terminal, exactly once. `None` is an orderly end.
+    fn on_voice_closed(&self, reason: Option<VoiceEndReason>);
+}
+
+/// Hosts advertising this capability accept client-media voice calls.
+#[uniffi::export]
+pub fn voice_host_capability() -> String {
+    zeron_proto::voice::remote::CAPABILITY.into()
+}
+/// Codex voice styles to offer before a host reports its own.
+#[uniffi::export]
+pub fn default_voice_styles() -> Vec<String> {
+    zeron_proto::voice::DEFAULT_VOICES
+        .iter()
+        .map(|voice| (*voice).to_owned())
+        .collect()
+}
+
+fn call_state(view: &VoiceView) -> VoiceCallState {
+    VoiceCallState {
+        phase: match view.phase {
+            VoicePhase::Active => VoiceCallPhase::Active,
+            VoicePhase::Stopping | VoicePhase::Closed | VoicePhase::Failed => {
+                VoiceCallPhase::Ending
+            }
+            VoicePhase::Checking | VoicePhase::Starting => VoiceCallPhase::Connecting,
+        },
+        orb: VoiceOrb::from_state(view.orb_state()),
+        chat_id: view.chat_id().map(str::to_owned),
+        work: match view.work() {
+            VoiceWork::Idle => VoiceCallWork::Idle,
+            VoiceWork::Working => VoiceCallWork::Working,
+            VoiceWork::AwaitingInput => VoiceCallWork::AwaitingInput,
+        },
+        muted: view.muted(),
+        speaking: view.playing(),
+        caption: view.caption().to_owned(),
+        caption_speaker: view.caption_role().map(|role| match role {
+            VoiceRole::User => VoiceSpeaker::User,
+            VoiceRole::Assistant => VoiceSpeaker::Assistant,
+        }),
+        caption_item: view.caption_item().map(str::to_owned),
+        microphone: view.microphone_level(),
+        speaker: view.speaker_level(),
+        voices: view
+            .snapshot
+            .as_ref()
+            .map(|s| s.voices.clone())
+            .unwrap_or_default(),
+    }
+}
+
+struct Reply {
+    sdp: Option<String>,
+    microphone: u16,
+    speaker: u16,
+}
+struct PlatformMedia {
+    listener: Arc<dyn VoiceMediaListener>,
+    pending: Mutex<HashMap<u64, oneshot::Sender<Result<Reply, VoiceRejection>>>>,
+    next: AtomicU64,
+    closed: AtomicBool,
+}
+impl PlatformMedia {
+    async fn request(
+        &self,
+        operation: VoiceMediaOperation,
+        sdp: Option<String>,
+        muted: bool,
+    ) -> Result<Reply, VoiceRejection> {
+        let id = self.next.fetch_add(1, Ordering::Relaxed) + 1;
+        let (tx, rx) = oneshot::channel();
+        {
+            let mut pending = self.pending.lock().unwrap();
+            if self.closed.load(Ordering::Acquire) {
+                return Err(VoiceRejection::InvalidLease);
+            }
+            if pending.len() >= 4 {
+                return Err(VoiceRejection::Overflow);
+            }
+            pending.insert(id, tx);
+        }
+        struct Pending<'a>(&'a PlatformMedia, u64);
+        impl Drop for Pending<'_> {
+            fn drop(&mut self) {
+                self.0.pending.lock().unwrap().remove(&self.1);
+            }
+        }
+        let _pending = Pending(self, id);
+        self.listener.on_request(VoiceMediaRequest {
+            request_id: id,
+            operation,
+            sdp,
+            muted,
+        });
+        tokio::time::timeout(std::time::Duration::from_secs(30), rx)
+            .await
+            .map_err(|_| VoiceRejection::DeviceUnavailable)?
+            .map_err(|_| VoiceRejection::DeviceUnavailable)?
+    }
+}
+#[async_trait::async_trait]
+impl VoiceMediaEndpoint for PlatformMedia {
+    async fn prepare(&self) -> Result<(), VoiceRejection> {
+        self.request(VoiceMediaOperation::Prepare, None, true)
+            .await
+            .map(|_| ())
+    }
+    async fn offer(&self) -> Result<Sdp, VoiceRejection> {
+        Sdp::new(
+            self.request(VoiceMediaOperation::Offer, None, true)
+                .await?
+                .sdp
+                .ok_or(VoiceRejection::Protocol)?,
+        )
+    }
+    async fn apply_answer(&self, answer: Sdp) -> Result<(), VoiceRejection> {
+        self.request(
+            VoiceMediaOperation::ApplyAnswer,
+            Some(answer.expose().into()),
+            true,
+        )
+        .await
+        .map(|_| ())
+    }
+    async fn set_muted(&self, muted: bool) -> Result<(), VoiceRejection> {
+        self.request(VoiceMediaOperation::SetMuted, None, muted)
+            .await
+            .map(|_| ())
+    }
+    async fn levels(&self) -> Result<(u16, u16), VoiceRejection> {
+        let r = self
+            .request(VoiceMediaOperation::Levels, None, true)
+            .await?;
+        Ok((r.microphone, r.speaker))
+    }
+    fn close(&self) {
+        if self.closed.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        let pending = std::mem::take(&mut *self.pending.lock().unwrap());
+        for (_, tx) in pending {
+            let _ = tx.send(Err(VoiceRejection::InvalidLease));
+        }
+        self.listener.on_request(VoiceMediaRequest {
+            request_id: 0,
+            operation: VoiceMediaOperation::Close,
+            sdp: None,
+            muted: true,
+        });
+    }
+}
+
+#[derive(uniffi::Object)]
+pub struct VoiceCall {
+    media: Arc<PlatformMedia>,
+    cancel: CancellationToken,
+    muted: watch::Sender<bool>,
+}
+impl Drop for VoiceCall {
+    fn drop(&mut self) {
+        self.media.close();
+        self.cancel.cancel();
+    }
+}
+#[uniffi::export]
+impl VoiceCall {
+    pub fn set_muted(&self, muted: bool) {
+        if !self.cancel.is_cancelled() {
+            self.muted.send_replace(muted);
+        }
+    }
+    pub fn stop(&self) {
+        self.media.close();
+        self.cancel.cancel();
+    }
+    /// Late native callbacks simply miss the retired request. No resume is possible.
+    pub fn complete_media(
+        &self,
+        request_id: u64,
+        failure: Option<VoiceMediaFailure>,
+        sdp: Option<String>,
+        microphone: u16,
+        speaker: u16,
+    ) {
+        if self.media.closed.load(Ordering::Acquire) {
+            return;
+        }
+        if let Some(tx) = self.media.pending.lock().unwrap().remove(&request_id) {
+            let reply = match failure {
+                Some(VoiceMediaFailure::PermissionDenied) => {
+                    Err(VoiceRejection::MicrophonePermissionDenied)
+                }
+                Some(VoiceMediaFailure::Unavailable) => Err(VoiceRejection::DeviceUnavailable),
+                None if sdp.as_ref().is_some_and(|s| s.len() > 65_536) => {
+                    Err(VoiceRejection::DeviceUnavailable)
+                }
+                None => Ok(Reply {
+                    sdp,
+                    microphone,
+                    speaker,
+                }),
+            };
+            let _ = tx.send(reply);
+        }
+    }
+}
+
+/// Reduce owner events and local mute into call snapshots for the platform.
+async fn present(
+    listener: Arc<dyn VoiceSessionListener>,
+    mut events: mpsc::Receiver<zeron_proto::voice::VoiceEvent>,
+    muted: watch::Receiver<bool>,
+) {
+    let mut view = VoiceView::new();
+    listener.on_voice_state(call_state(&view));
+    let mut muted = Some(muted);
+    loop {
+        let changed = tokio::select! {
+            event = events.recv() => match event {
+                Some(event) => view.reduce(event, std::time::Instant::now()),
+                None => return,
+            },
+            changed = async { muted.as_mut().unwrap().changed().await }, if muted.is_some() => {
+                match changed {
+                    Ok(()) => {
+                        let value = *muted.as_mut().unwrap().borrow_and_update();
+                        view.set_muted(value)
+                    }
+                    // The call handle is gone; its cancellation ends us next.
+                    Err(_) => {
+                        muted = None;
+                        false
+                    }
+                }
+            }
+        };
+        if changed {
+            listener.on_voice_state(call_state(&view));
+        }
+    }
+}
+
+#[uniffi::export]
+impl CoreClient {
+    /// Returns immediately. Callbacks are dispatched on the core runtime; the
+    /// platform must hop to its media/UI executor and call complete_media.
+    pub fn start_voice(
+        &self,
+        host_device_id: String,
+        voice: Option<String>,
+        media: Arc<dyn VoiceMediaListener>,
+        listener: Arc<dyn VoiceSessionListener>,
+    ) -> Arc<VoiceCall> {
+        let platform = Arc::new(PlatformMedia {
+            listener: media,
+            pending: Default::default(),
+            next: AtomicU64::new(0),
+            closed: AtomicBool::new(false),
+        });
+        let cancel = self.client.voice_cancellation();
+        let (muted, rx) = watch::channel(false);
+        let presented_mute = rx.clone();
+        let handle = Arc::new(VoiceCall {
+            media: platform.clone(),
+            cancel: cancel.clone(),
+            muted,
+        });
+        let client = self.client.clone();
+        zc::runtime::handle().spawn(async move {
+            let (events, receiver) = mpsc::channel(32);
+            let forward = tokio::spawn(present(listener.clone(), receiver, presented_mute));
+            let operation = async {
+                let control = client
+                    .voice_transport(&host_device_id)
+                    .await
+                    .map_err(|_| VoiceRejection::RemoteHost)?;
+                let config = zeron_proto::ChatConfig {
+                    harness: zeron_proto::HarnessId::Codex,
+                    model: None,
+                    reasoning: None,
+                    model_options: Default::default(),
+                    sandbox: zeron_proto::SandboxLevel::WorkspaceWrite,
+                };
+                zeron_voice_session::run(
+                    control,
+                    platform.clone(),
+                    config,
+                    voice,
+                    cancel.clone(),
+                    events,
+                    rx,
+                )
+                .await
+            };
+            let result = tokio::select! {biased;_=cancel.cancelled()=>Ok(()),r=operation=>r};
+            platform.close();
+            // Every sender is gone: the presenter drains what was queued.
+            let _ = forward.await;
+            listener.on_voice_closed(result.err().map(VoiceEndReason::from));
+        });
+        handle
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use zeron_proto::voice::{VoiceEvent, VoiceSnapshot};
+    struct Listener(Mutex<Vec<u64>>);
+    impl VoiceMediaListener for Listener {
+        fn on_request(&self, r: VoiceMediaRequest) {
+            self.0.lock().unwrap().push(r.request_id);
+        }
+    }
+    fn media(listener: Arc<Listener>) -> Arc<PlatformMedia> {
+        Arc::new(PlatformMedia {
+            listener,
+            pending: Default::default(),
+            next: AtomicU64::new(0),
+            closed: AtomicBool::new(false),
+        })
+    }
+    #[tokio::test]
+    async fn close_releases_pending_callbacks_and_rejects_late_replies() {
+        let listener = Arc::new(Listener(Mutex::new(vec![])));
+        let media = media(listener.clone());
+        let clone = media.clone();
+        let task = tokio::spawn(async move { clone.offer().await });
+        tokio::task::yield_now().await;
+        media.close();
+        assert!(task.await.unwrap().is_err());
+        assert!(media.pending.lock().unwrap().is_empty());
+        let (muted, _) = watch::channel(false);
+        let call = VoiceCall {
+            media: media.clone(),
+            cancel: CancellationToken::new(),
+            muted,
+        };
+        call.complete_media(1, None, Some("late SDP".into()), 0, 0);
+        assert!(media.offer().await.is_err());
+        assert_eq!(
+            listener
+                .0
+                .lock()
+                .unwrap()
+                .iter()
+                .filter(|id| **id == 0)
+                .count(),
+            1
+        );
+    }
+
+    #[tokio::test]
+    async fn denied_microphone_is_reported_as_such() {
+        let listener = Arc::new(Listener(Mutex::new(vec![])));
+        let media = media(listener.clone());
+        let (muted, _) = watch::channel(false);
+        let call = VoiceCall {
+            media: media.clone(),
+            cancel: CancellationToken::new(),
+            muted,
+        };
+        let clone = media.clone();
+        let task = tokio::spawn(async move { clone.prepare().await });
+        while listener.0.lock().unwrap().is_empty() {
+            tokio::task::yield_now().await;
+        }
+        call.complete_media(1, Some(VoiceMediaFailure::PermissionDenied), None, 0, 0);
+        let reason = task.await.unwrap().unwrap_err();
+        assert_eq!(
+            VoiceEndReason::from(reason),
+            VoiceEndReason::MicrophoneDenied
+        );
+    }
+
+    struct States(Mutex<Vec<VoiceCallState>>);
+    impl VoiceSessionListener for States {
+        fn on_voice_state(&self, state: VoiceCallState) {
+            self.0.lock().unwrap().push(state);
+        }
+        fn on_voice_closed(&self, _: Option<VoiceEndReason>) {}
+    }
+
+    #[tokio::test]
+    async fn presenter_names_the_orchestrator_and_applies_local_mute_first() {
+        let states = Arc::new(States(Mutex::new(vec![])));
+        let (events, receiver) = mpsc::channel(8);
+        let (mute, muted) = watch::channel(false);
+        let task = tokio::spawn(present(states.clone(), receiver, muted));
+        events
+            .send(VoiceEvent::Snapshot {
+                snapshot: VoiceSnapshot {
+                    session_id: "s".into(),
+                    chat_id: "voice-orchestrator-full".into(),
+                    generation: 1,
+                    phase: VoicePhase::Active,
+                    muted: false,
+                    playing: false,
+                    work: VoiceWork::AwaitingInput,
+                    reason: None,
+                    voice: None,
+                    voices: vec!["maple".into()],
+                },
+            })
+            .await
+            .unwrap();
+        while states.0.lock().unwrap().len() < 2 {
+            tokio::task::yield_now().await;
+        }
+        mute.send_replace(true);
+        while states.0.lock().unwrap().len() < 3 {
+            tokio::task::yield_now().await;
+        }
+        drop(events);
+        task.await.unwrap();
+        let states = states.0.lock().unwrap();
+        assert_eq!(states[0].phase, VoiceCallPhase::Connecting);
+        assert_eq!(states[0].orb, VoiceOrb::Connecting);
+        assert_eq!(
+            states[1].chat_id.as_deref(),
+            Some("voice-orchestrator-full")
+        );
+        assert_eq!(states[1].work, VoiceCallWork::AwaitingInput);
+        assert_eq!(states[1].orb, VoiceOrb::AwaitingInput);
+        assert_eq!(states[1].voices, vec!["maple".to_owned()]);
+        assert!(states[2].muted);
+    }
+}
diff --git a/crates/mobile/src/lib.rs b/crates/mobile/src/lib.rs
index b291ff16a6..f54d888654 100644
--- a/crates/mobile/src/lib.rs
+++ b/crates/mobile/src/lib.rs
@@ -3,11 +3,15 @@
 //! - [`client_ffi`]: account, workspace and session state (wraps `zeron-client`).
 //! - [`layout`]: analytic transcript layout — markdown → measured display lists
 //!   (wraps `zeron-markdown` + `zeron-text`).
+//! - [`orb`]: the desktop's voice orb as paintable frames (wraps `zeron-orb`).
+//! - [`caption`]: the voice caption's streaming veil (wraps `zeron-veil`).
 
 uniffi::setup_scaffolding!("zeron_core");
 
 mod client_ffi;
 pub mod layout;
+pub mod caption;
+pub mod orb;
 pub mod wallpaper;
 
 /// Version handshake: the Swift/Kotlin bindings must match the linked library.
diff --git a/crates/mobile/src/orb.rs b/crates/mobile/src/orb.rs
new file mode 100644
index 0000000000..9c0a84509c
--- /dev/null
+++ b/crates/mobile/src/orb.rs
@@ -0,0 +1,192 @@
+//! The desktop's thinking orb for platform canvases. Geometry, clock, audio
+//! response and state crossfades come from `zeron-orb`, exactly as the GPUI
+//! widget runs them; the platform only strokes lines and fills disks.
+//!
+//! Frames are flat `f32` lists so a 30 fps loop crosses the FFI with two
+//! buffers instead of hundreds of records:
+//! - `lines`: `[x1, y1, x2, y2, width, white, alpha]` per segment;
+//! - `dots`: `[x, y, radius, white, alpha]` per disk, back to front.
+//!
+//! Coordinates are logical points in a `size × size` box. `white` is ink
+//! (0 = darkest on paper); dark appearances paint `1 - white`. Paint lines,
+//! then dots, onto a transparent canvas.
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+use zeron_orb::{OrbAnimator, OrbSize, OrbState, engine::Frame};
+
+/// The four tuned size presets (inline 20, avatar 64, large 96, hero 128).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, uniffi::Enum)]
+pub enum OrbPreset {
+    Inline,
+    Avatar,
+    Large,
+    Hero,
+}
+
+impl From<OrbPreset> for OrbSize {
+    fn from(preset: OrbPreset) -> Self {
+        match preset {
+            OrbPreset::Inline => OrbSize::Inline,
+            OrbPreset::Avatar => OrbSize::Avatar,
+            OrbPreset::Large => OrbSize::Large,
+            OrbPreset::Hero => OrbSize::Hero,
+        }
+    }
+}
+
+/// What the voice orb is showing, in call terms.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, uniffi::Enum)]
+pub enum VoiceOrb {
+    /// No call: the calm form of a muted orchestrator.
+    Idle,
+    Connecting,
+    Listening,
+    Speaking,
+    Working,
+    AwaitingInput,
+    Muted,
+}
+
+impl From<VoiceOrb> for OrbState {
+    fn from(orb: VoiceOrb) -> Self {
+        match orb {
+            VoiceOrb::Idle | VoiceOrb::Muted => OrbState::Breathing,
+            VoiceOrb::Connecting => OrbState::Connecting,
+            VoiceOrb::Listening => OrbState::Listening,
+            VoiceOrb::Speaking => OrbState::Composing,
+            VoiceOrb::Working => OrbState::Working,
+            VoiceOrb::AwaitingInput => OrbState::Solving,
+        }
+    }
+}
+
+impl VoiceOrb {
+    pub(crate) fn from_state(state: OrbState) -> Self {
+        match state {
+            OrbState::Connecting => VoiceOrb::Connecting,
+            OrbState::Listening => VoiceOrb::Listening,
+            OrbState::Composing => VoiceOrb::Speaking,
+            OrbState::Working => VoiceOrb::Working,
+            OrbState::Solving => VoiceOrb::AwaitingInput,
+            _ => VoiceOrb::Muted,
+        }
+    }
+}
+
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct OrbFrame {
+    /// Edge length of the artwork box, in logical points.
+    pub size: f32,
+    pub lines: Vec<f32>,
+    pub dots: Vec<f32>,
+}
+
+/// One animated orb. Calls are cheap and safe from any thread; drive
+/// [`OrbRenderer::next_frame`] from the display link.
+#[derive(uniffi::Object)]
+pub struct OrbRenderer {
+    inner: Mutex<Inner>,
+}
+
+struct Inner {
+    animator: OrbAnimator,
+    frame: Frame,
+}
+
+/// Below this the desktop paint path skips a primitive too.
+const MIN_ALPHA: f32 = 0.02;
+
+#[uniffi::export]
+impl OrbRenderer {
+    /// Crossfades state changes over 300 ms, like the desktop voice orbs.
+    #[uniffi::constructor]
+    pub fn new(preset: OrbPreset, orb: VoiceOrb) -> Arc<Self> {
+        Arc::new(Self {
+            inner: Mutex::new(Inner {
+                animator: OrbAnimator::new(orb.into(), preset.into())
+                    .with_transition(Duration::from_millis(300)),
+                frame: Frame::new(),
+            }),
+        })
+    }
+
+    pub fn set_orb(&self, orb: VoiceOrb) {
+        let inner = &mut *self.inner.lock().unwrap();
+        inner.animator.set_state(orb.into(), &inner.frame);
+    }
+
+    /// Normalized 0…1 peaks; they speed the motion up, never the geometry.
+    pub fn set_audio_levels(&self, microphone: f32, speaker: f32) {
+        self.inner
+            .lock()
+            .unwrap()
+            .animator
+            .set_audio_levels(microphone, speaker, Instant::now());
+    }
+
+    /// Advance to now and return the frame to paint. Time only accumulates
+    /// while `animating`; reduced motion shows the static representative frame.
+    pub fn next_frame(&self, animating: bool, reduced_motion: bool) -> OrbFrame {
+        let inner = &mut *self.inner.lock().unwrap();
+        inner
+            .animator
+            .tick(Instant::now(), animating && !reduced_motion, reduced_motion);
+        inner.animator.draw(&mut inner.frame);
+        let r_min = inner.animator.r_min();
+        let mut lines = Vec::with_capacity(inner.frame.lines.len() * 7);
+        for l in inner.frame.lines.iter().filter(|l| l.a >= MIN_ALPHA) {
+            lines.extend_from_slice(&[l.x1, l.y1, l.x2, l.y2, l.w, l.white, l.a]);
+        }
+        let mut dots = Vec::with_capacity(inner.frame.dots.len() * 5);
+        for d in inner.frame.dots.iter().filter(|d| d.a >= MIN_ALPHA) {
+            dots.extend_from_slice(&[d.x, d.y, d.r.max(r_min), d.white, d.a]);
+        }
+        OrbFrame {
+            size: inner.animator.pixels(),
+            lines,
+            dots,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_voice_orb_paints_finite_geometry_inside_its_box() {
+        for orb in [
+            VoiceOrb::Idle,
+            VoiceOrb::Connecting,
+            VoiceOrb::Listening,
+            VoiceOrb::Speaking,
+            VoiceOrb::Working,
+            VoiceOrb::AwaitingInput,
+            VoiceOrb::Muted,
+        ] {
+            let renderer = OrbRenderer::new(OrbPreset::Hero, orb);
+            renderer.set_audio_levels(0.5, 0.8);
+            let frame = renderer.next_frame(true, false);
+            assert_eq!(frame.size, 128.0);
+            assert!(!frame.dots.is_empty(), "{orb:?}");
+            assert_eq!(frame.dots.len() % 5, 0);
+            assert_eq!(frame.lines.len() % 7, 0);
+            assert!(frame.dots.iter().chain(&frame.lines).all(|v| v.is_finite()));
+            assert_eq!(
+                VoiceOrb::from_state(orb.into()),
+                match orb {
+                    VoiceOrb::Idle => VoiceOrb::Muted,
+                    orb => orb,
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn reduced_motion_is_a_still_frame() {
+        let renderer = OrbRenderer::new(OrbPreset::Avatar, VoiceOrb::Listening);
+        let first = renderer.next_frame(true, true);
+        std::thread::sleep(Duration::from_millis(20));
+        assert_eq!(first.dots, renderer.next_frame(true, true).dots);
+    }
+}
diff --git a/crates/orb/Cargo.toml b/crates/orb/Cargo.toml
new file mode 100644
index 0000000000..504bf7c273
--- /dev/null
+++ b/crates/orb/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "zeron-orb"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+# The thinking-orb animation engine without a renderer: desktop paints its
+# frames through GPUI, mobile through Core Graphics, from identical geometry.
+[dependencies]
diff --git a/crates/orb/src/animator.rs b/crates/orb/src/animator.rs
new file mode 100644
index 0000000000..345de9a5e5
--- /dev/null
+++ b/crates/orb/src/animator.rs
@@ -0,0 +1,300 @@
+//! Renderer-agnostic orb playback: the continuous clock, audio-driven speed
+//! and state crossfades. Hosts decide when to tick and paint the frames.
+use std::time::{Duration, Instant};
+
+use crate::{
+    REDUCED_MOTION_T,
+    engine::{Frame, draw_mode_into_resolved},
+    motion::{AnimationClock, AudioResponse},
+    presets::{Resolved, resolve_preset},
+    types::{OrbSize, OrbState},
+};
+
+struct StateTransition {
+    from: Frame,
+    source: Option<Resolved>,
+    started: f64,
+}
+
+/// Blend two frames by opacity with a smoothstep weight.
+pub fn crossfade(from: &Frame, to: &Frame, progress: f32, out: &mut Frame) {
+    out.clear();
+    let progress = progress.clamp(0.0, 1.0);
+    let weight = progress * progress * (3.0 - 2.0 * progress);
+    for (frame, opacity) in [(from, 1.0 - weight), (to, weight)] {
+        out.dots.extend(frame.dots.iter().filter_map(|dot| {
+            let mut dot = *dot;
+            dot.a *= opacity;
+            (dot.a >= 0.005).then_some(dot)
+        }));
+        out.lines.extend(frame.lines.iter().filter_map(|line| {
+            let mut line = *line;
+            line.a *= opacity;
+            (line.a >= 0.005).then_some(line)
+        }));
+    }
+}
+
+/// One orb's animation state. The engine takes continuous, unbounded time —
+/// its modes mix incommensurate frequencies, so there is no seamless wrap
+/// point — and this owns that clock.
+pub struct OrbAnimator {
+    state: OrbState,
+    size: OrbSize,
+    /// Multiplier on top of the preset's baked speed.
+    speed: f32,
+    clock: AnimationClock,
+    audio: Option<AudioResponse>,
+    transition_duration: Duration,
+    transition: Option<StateTransition>,
+    resolved: Resolved,
+    target_frame: Frame,
+    t: f32,
+}
+
+impl OrbAnimator {
+    pub fn new(state: OrbState, size: OrbSize) -> Self {
+        Self {
+            state,
+            size,
+            speed: 1.0,
+            clock: AnimationClock::default(),
+            audio: None,
+            transition_duration: Duration::ZERO,
+            transition: None,
+            resolved: resolve_preset(state, size),
+            target_frame: Frame::new(),
+            t: 0.0,
+        }
+    }
+
+    /// Crossfade state geometry without restarting the clock.
+    pub fn with_transition(mut self, duration: Duration) -> Self {
+        self.set_transition(duration);
+        self
+    }
+
+    pub fn set_transition(&mut self, duration: Duration) {
+        self.transition_duration = duration;
+    }
+
+    pub fn state(&self) -> OrbState {
+        self.state
+    }
+
+    pub fn size(&self) -> OrbSize {
+        self.size
+    }
+
+    pub fn speed(&self) -> f32 {
+        self.speed
+    }
+
+    /// Logical edge length of the preset's artwork.
+    pub fn pixels(&self) -> f32 {
+        self.size.pixels()
+    }
+
+    /// Smallest painted dot radius for the current preset.
+    pub fn r_min(&self) -> f32 {
+        self.resolved.opts.r_min.unwrap_or(0.3)
+    }
+
+    pub fn is_running(&self) -> bool {
+        self.clock.is_running()
+    }
+
+    pub fn is_transitioning(&self) -> bool {
+        self.transition.is_some()
+    }
+
+    /// Change state. `visible` is the frame on screen now: an interrupted
+    /// fade continues from its visible composite instead of jumping back.
+    pub fn set_state(&mut self, state: OrbState, visible: &Frame) -> bool {
+        if self.state == state {
+            return false;
+        }
+        self.transition = (!self.transition_duration.is_zero()
+            && self.clock.is_running()
+            && (!visible.dots.is_empty() || !visible.lines.is_empty()))
+        .then(|| StateTransition {
+            from: visible.clone(),
+            // Animate the outgoing form, unless it is itself mid-fade.
+            source: self.transition.is_none().then(|| self.resolved.clone()),
+            started: self.clock.active_seconds,
+        });
+        self.state = state;
+        self.resolved = resolve_preset(state, self.size);
+        true
+    }
+
+    pub fn set_size(&mut self, size: OrbSize) -> bool {
+        if self.size == size {
+            return false;
+        }
+        self.size = size;
+        self.resolved = resolve_preset(self.state, size);
+        true
+    }
+
+    pub fn set_speed(&mut self, speed: f32) -> bool {
+        let speed = if speed.is_finite() {
+            speed.clamp(0.0, 100.0)
+        } else {
+            1.0
+        };
+        let changed = self.speed != speed;
+        self.speed = speed;
+        changed
+    }
+
+    /// Audio affects only visual motion, with independent microphone and
+    /// speaker envelopes.
+    pub fn set_audio_levels(&mut self, microphone: f32, speaker: f32, now: Instant) -> bool {
+        self.audio
+            .get_or_insert_with(|| AudioResponse::new(now))
+            .set(microphone, speaker, now)
+    }
+
+    /// Freeze accumulated time (paused, hidden or reduced motion).
+    pub fn stop(&mut self, now: Instant) {
+        self.clock.stop(now);
+    }
+
+    pub fn cancel_transition(&mut self) {
+        self.transition = None;
+    }
+
+    /// Advance the clock to `now`. Time only accumulates while `animating`.
+    pub fn tick(&mut self, now: Instant, animating: bool, reduced: bool) {
+        let audio_speed = self.audio.as_ref().map_or(1.0, |audio| audio.speed(now));
+        let rate = f64::from(self.resolved.speed) * f64::from(self.speed) * audio_speed;
+        self.clock.advance(now, rate, animating);
+        self.t = if reduced {
+            REDUCED_MOTION_T
+        } else {
+            self.clock.seconds as f32
+        };
+        if reduced {
+            self.transition = None;
+        }
+    }
+
+    /// Geometry at the last tick, in the preset's logical pixels.
+    pub fn draw(&mut self, out: &mut Frame) {
+        let progress = self.transition.as_ref().map_or(1.0, |transition| {
+            ((self.clock.active_seconds - transition.started)
+                / self.transition_duration.as_secs_f64()) as f32
+        });
+        if progress >= 1.0 {
+            self.transition = None;
+        }
+        let size = self.size.pixels();
+        let Some(transition) = &mut self.transition else {
+            // The allocation-free path outside a fade.
+            draw_mode_into_resolved(self.resolved.mode, size, self.t, &self.resolved.opts, out);
+            return;
+        };
+        draw_mode_into_resolved(
+            self.resolved.mode,
+            size,
+            self.t,
+            &self.resolved.opts,
+            &mut self.target_frame,
+        );
+        if let Some(source) = &transition.source {
+            draw_mode_into_resolved(
+                source.mode,
+                size,
+                self.t,
+                &source.opts,
+                &mut transition.from,
+            );
+        }
+        crossfade(&transition.from, &self.target_frame, progress, out);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::engine::{Dot, Line};
+
+    #[test]
+    fn state_crossfade_preserves_endpoints_and_blends_dots_and_lines() {
+        let from = Frame {
+            dots: vec![Dot::new(1.0, 2.0, 0.0, 1.0, 0.5)],
+            lines: vec![Line {
+                x1: 0.0,
+                y1: 0.0,
+                x2: 1.0,
+                y2: 1.0,
+                white: 0.5,
+                a: 1.0,
+                w: 1.0,
+            }],
+        };
+        let to = Frame {
+            dots: vec![Dot::new(3.0, 4.0, 0.0, 1.0, 0.5)],
+            lines: vec![],
+        };
+        let mut out = Frame::new();
+        crossfade(&from, &to, 0.0, &mut out);
+        assert_eq!(out.dots.len(), 1);
+        assert_eq!(out.dots[0].x, 1.0);
+        assert_eq!(out.lines[0].a, 1.0);
+        crossfade(&from, &to, 0.5, &mut out);
+        assert_eq!(out.dots.len(), 2);
+        assert_eq!(out.dots[0].a, 0.5);
+        assert_eq!(out.dots[1].a, 0.5);
+        assert_eq!(out.lines[0].a, 0.5);
+        crossfade(&from, &to, 1.0, &mut out);
+        assert_eq!(out.dots.len(), 1);
+        assert_eq!(out.dots[0].x, 3.0);
+        assert!(out.lines.is_empty());
+    }
+
+    #[test]
+    fn interrupted_state_transition_starts_from_the_visible_frame() {
+        let now = Instant::now();
+        let mut orb = OrbAnimator::new(OrbState::Working, OrbSize::Avatar)
+            .with_transition(Duration::from_millis(300));
+        orb.tick(now, true, false);
+        let mut visible = Frame::new();
+        visible
+            .dots
+            .push(Dot::new(42.0, 0.0, 0.0, 1.0, 0.5).with_a(0.4));
+        assert!(orb.set_state(OrbState::Listening, &visible));
+        assert_eq!(orb.transition.as_ref().unwrap().from.dots[0].x, 42.0);
+        assert!(orb.transition.as_ref().unwrap().source.is_some());
+        visible.dots[0].a = 0.2;
+        orb.set_state(OrbState::Composing, &visible);
+        let transition = orb.transition.as_ref().unwrap();
+        assert_eq!(transition.from.dots[0].a, 0.2);
+        // A fade from a fade keeps the composite rather than redrawing it.
+        assert!(transition.source.is_none());
+        orb.tick(now + Duration::from_millis(16), false, true);
+        assert!(orb.transition.is_none());
+        assert!(!orb.is_running());
+    }
+
+    #[test]
+    fn stopped_orbs_switch_state_without_a_fade_and_finish_fades() {
+        let now = Instant::now();
+        let mut orb = OrbAnimator::new(OrbState::Working, OrbSize::Hero)
+            .with_transition(Duration::from_millis(300));
+        let mut frame = Frame::new();
+        orb.tick(now, false, false);
+        orb.draw(&mut frame);
+        orb.set_state(OrbState::Listening, &frame);
+        assert!(!orb.is_transitioning());
+        orb.tick(now, true, false);
+        orb.draw(&mut frame);
+        orb.set_state(OrbState::Composing, &frame);
+        assert!(orb.is_transitioning());
+        orb.tick(now + Duration::from_millis(400), true, false);
+        orb.draw(&mut frame);
+        assert!(!orb.is_transitioning());
+        assert!(!frame.dots.is_empty());
+    }
+}
diff --git a/crates/orb/src/engine/braid.rs b/crates/orb/src/engine/braid.rs
new file mode 100644
index 0000000000..1168e10e3e
--- /dev/null
+++ b/crates/orb/src/engine/braid.rs
@@ -0,0 +1,58 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Braid: three strands plait around the sphere — the "weaving" state.
+
+use crate::engine::{
+    core::{Dot, Frame, frac, make_proj, radius_scale, with_fib_dirs},
+    profiles::{MAX_GHOST_N, MAX_STRAND_N, ModeOpts, count_usize},
+};
+use std::f32::consts::PI;
+
+pub fn draw_braid_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let r = (size / 2.0) * 0.76;
+    let pt = make_proj(t * 0.4, 0.3, cx, cy, 1.0);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+
+    let dots = &mut out.dots;
+    let ghost_n = count_usize(o.ghost_n, 150.0, 0, MAX_GHOST_N as usize);
+    let strand_n = count_usize(o.strand_n, 52.0, 0, MAX_STRAND_N as usize);
+    let inv_r = 1.0 / r;
+    dots.reserve(ghost_n.saturating_add(strand_n.saturating_mul(3)));
+
+    with_fib_dirs(ghost_n, |directions| {
+        for d in directions {
+            let (px, py, z) = pt.project(d[0] * r, d[1] * r, d[2] * r);
+            let depth = (z * inv_r + 1.0) / 2.0;
+            dots.push(Dot::new(px, py, z, 0.8 * rs, 0.78).with_a(0.1 + 0.22 * depth));
+        }
+    });
+
+    let turns = o.turns.unwrap_or(3.0);
+    let r_base = o.r_base.unwrap_or(1.2);
+    let r_depth = o.r_depth.unwrap_or(1.8);
+    let inv_strand = 1.0 / strand_n as f32;
+    for s in 0..3 {
+        let phase = (s as f32 / 3.0) * 2.0 * PI;
+        for i in 0..strand_n {
+            let u = (frac(i as f32 * inv_strand + t * 0.045) * 2.0 - 1.0) * 0.96;
+            let surf = (1.0 - u * u).max(0.0).sqrt();
+            let end_fade = ((0.96 - u.abs()) / 0.12).clamp(0.0, 1.0);
+            let a = u * PI * turns + phase;
+            let weave = 1.0 + 0.075 * (u * PI * turns * 2.0 + phase * 2.0 + t * 0.8).sin();
+            let rr = surf * r * weave;
+            let (px, py, zr) = pt.project(a.cos() * rr, u * r * weave, a.sin() * rr);
+            let depth = (zr * inv_r + 1.0) / 2.0;
+            dots.push(
+                Dot::new(
+                    px,
+                    py,
+                    zr,
+                    (r_base + r_depth * depth) * rs,
+                    0.55 - 0.45 * depth,
+                )
+                .with_a(end_fade * (0.45 + 0.55 * depth)),
+            );
+        }
+    }
+}
diff --git a/crates/orb/src/engine/concepts.rs b/crates/orb/src/engine/concepts.rs
new file mode 100644
index 0000000000..92ec0d0a97
--- /dev/null
+++ b/crates/orb/src/engine/concepts.rs
@@ -0,0 +1,195 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Original low-density orb concepts: focus, gyroscope, and memory echoes.
+//!
+//! These modes deliberately reuse the engine's existing count/radius knobs and
+//! emit dots only, keeping them on the cheapest GPUI paint path.
+
+use crate::engine::{
+    core::{Dot, Frame, frac, make_proj, radius_scale, with_unit_circle},
+    profiles::{MAX_LANES, MAX_PARTICLES, MAX_SEGS, ModeOpts, count_usize},
+};
+use std::f32::consts::PI;
+
+/// Iris-like streams converge on a small, steady focal core.
+pub fn draw_focus_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let center = size / 2.0;
+    let extent = size * 0.38 * o.spread.unwrap_or(1.0);
+    let lanes = count_usize(o.lanes, 6.0, 1, MAX_LANES as usize);
+    let segs = count_usize(o.segs, 12.0, 1, MAX_SEGS as usize);
+    let core_n = count_usize(o.particles, 5.0, 1, MAX_PARTICLES as usize);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+    let r_base = o.r_base.unwrap_or(0.9);
+    let r_depth = o.r_depth.unwrap_or(1.25);
+    let total = lanes.saturating_mul(segs).saturating_add(core_n);
+    out.dots.reserve(total);
+
+    // Close and reopen a six-blade aperture without collapsing the samples
+    // into a star. Every blade keeps a continuous curved silhouette; only its
+    // inner edge moves, so the concept remains readable in a frozen frame.
+    let openness = 0.5 + 0.5 * (t * 0.9).sin();
+    let inner = 0.12 + 0.2 * openness;
+    let rotation = t * 0.11;
+    let inv_segs = 1.0 / segs as f32;
+    with_unit_circle(lanes, |directions| {
+        for (lane, direction) in directions.iter().enumerate() {
+            for i in 0..segs {
+                let u = (i as f32 + 0.5) * inv_segs;
+                let radial = inner + (1.0 - inner) * u;
+                let curl = (0.88 - 0.24 * openness) * (1.0 - u).powf(1.25);
+                let twist = rotation + curl;
+                let (st, ct) = twist.sin_cos();
+                let dx = direction[0] * ct - direction[1] * st;
+                let dy = direction[0] * st + direction[1] * ct;
+                let inner_weight = 1.0 - u;
+                let shimmer = 0.96 + 0.05 * (t * 1.4 + lane as f32 * 0.8).sin();
+                out.dots.push(
+                    Dot::new(
+                        center + dx * extent * radial,
+                        center + dy * extent * radial,
+                        0.0,
+                        (r_base + r_depth * inner_weight) * shimmer * rs,
+                        0.12 + 0.52 * u,
+                    )
+                    .with_a(0.48 + 0.52 * (PI * u).sin()),
+                );
+            }
+        }
+    });
+
+    // A tiny breathing nucleus makes the destination legible at inline size.
+    let core_radius = size * (0.035 + 0.004 * (t * 1.5).sin());
+    with_unit_circle(core_n, |circle| {
+        for p in circle {
+            out.dots.push(Dot::new(
+                center + p[0] * core_radius,
+                center + p[1] * core_radius,
+                0.0,
+                (r_base + r_depth * 1.15) * rs,
+                0.08,
+            ));
+        }
+    });
+}
+
+/// Three inference loops carry thoughts in alternating directions.
+pub fn draw_gyroscope_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let center = size / 2.0;
+    let radius = size * 0.385 * o.spread.unwrap_or(1.0);
+    let rings = count_usize(o.lanes, 3.0, 1, MAX_LANES as usize).min(6);
+    let segs = count_usize(o.segs, 24.0, 3, MAX_SEGS as usize);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+    let r_base = o.r_base.unwrap_or(0.8);
+    let r_depth = o.r_depth.unwrap_or(1.5);
+    let proj = make_proj(t * 0.055, 0.18, center, center, radius);
+    out.dots
+        .reserve(rings.saturating_mul(segs.saturating_add(2)));
+
+    with_unit_circle(segs, |circle| {
+        for ring in 0..rings {
+            let spread = if rings > 1 {
+                ring as f32 / (rings - 1) as f32 - 0.5
+            } else {
+                0.0
+            };
+            let tilt_x = spread * 1.55 + 0.12 * (t * 0.16 + ring as f32).sin();
+            let tilt_y = ring as f32 * PI / rings as f32 + 0.32;
+            let (sx, cx) = tilt_x.sin_cos();
+            let (sy, cy) = tilt_y.sin_cos();
+            let direction = if ring % 2 == 0 { 1.0 } else { -1.0 };
+            let orient = |ca: f32, sa: f32| {
+                let y1 = sa * cx;
+                let z1 = sa * sx;
+                (ca * cy + z1 * sy, y1, -ca * sy + z1 * cy)
+            };
+
+            for p in circle {
+                let (x, y, z) = orient(p[0], p[1]);
+                let (px, py, depth_z) = proj.project(x, y, z);
+                let depth = (depth_z + 1.0) * 0.5;
+                out.dots.push(
+                    Dot::new(
+                        px,
+                        py,
+                        depth_z,
+                        (r_base * 0.9 + r_depth * 0.5 * depth) * rs,
+                        0.62 - 0.34 * depth,
+                    )
+                    .with_a(0.34 + 0.4 * depth),
+                );
+            }
+
+            // A leading thought and a softer echo make direction and velocity
+            // legible without turning the complete track into visual noise.
+            let travel =
+                t * (0.72 + ring as f32 * 0.08) * direction + ring as f32 * 2.0 * PI / rings as f32;
+            for (trail, offset) in [0.0, -0.22 * direction].into_iter().enumerate() {
+                let (sa, ca) = (travel + offset).sin_cos();
+                let (x, y, z) = orient(ca, sa);
+                let (px, py, depth_z) = proj.project(x, y, z);
+                let depth = (depth_z + 1.0) * 0.5;
+                let strength = if trail == 0 { 1.0 } else { 0.48 };
+                out.dots.push(
+                    Dot::new(
+                        px,
+                        py,
+                        depth_z + 0.002,
+                        (r_base + r_depth * depth + 1.65 * strength) * rs,
+                        0.44 - 0.42 * depth - 0.2 * strength,
+                    )
+                    .with_a((0.55 + 0.45 * depth) * strength),
+                );
+            }
+        }
+    });
+}
+
+/// Concentric echoes emerge from a stable core and dissolve at the boundary.
+pub fn draw_echo_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let center = size / 2.0;
+    let extent = size * 0.4 * o.spread.unwrap_or(1.0);
+    let rings = count_usize(o.lanes, 4.0, 1, MAX_LANES as usize);
+    let segs = count_usize(o.segs, 18.0, 3, MAX_SEGS as usize);
+    let core_n = count_usize(o.particles, 3.0, 1, MAX_PARTICLES as usize);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+    let r_base = o.r_base.unwrap_or(0.85);
+    let r_depth = o.r_depth.unwrap_or(1.05);
+    out.dots
+        .reserve(rings.saturating_mul(segs).saturating_add(core_n));
+
+    with_unit_circle(segs, |circle| {
+        for ring in 0..rings {
+            let phase = frac(t * 0.14 + ring as f32 / rings as f32);
+            let radius = extent * (0.13 + 0.87 * phase);
+            let life = (PI * phase).sin().max(0.0);
+            let turn = ring as f32 * 0.37 - t * 0.1;
+            let (st, ct) = turn.sin_cos();
+            for p in circle {
+                let x = p[0] * ct - p[1] * st;
+                let y = p[0] * st + p[1] * ct;
+                out.dots.push(
+                    Dot::new(
+                        center + x * radius,
+                        center + y * radius,
+                        0.0,
+                        (r_base + r_depth * (1.0 - phase)) * rs,
+                        0.18 + 0.52 * phase,
+                    )
+                    .with_a(life.powf(0.58)),
+                );
+            }
+        }
+    });
+
+    let core_radius = size * 0.025;
+    with_unit_circle(core_n, |circle| {
+        for p in circle {
+            out.dots.push(Dot::new(
+                center + p[0] * core_radius,
+                center + p[1] * core_radius,
+                0.0,
+                (r_base + r_depth * 1.4) * rs,
+                0.06,
+            ));
+        }
+    });
+}
diff --git a/crates/orb/src/engine/core.rs b/crates/orb/src/engine/core.rs
new file mode 100644
index 0000000000..fc55d78e54
--- /dev/null
+++ b/crates/orb/src/engine/core.rs
@@ -0,0 +1,232 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Shared primitives for the dotted 3D thought-orbs.
+//! Ported from thinking-orbs / inkform (HalftoneSphere lineage).
+
+use std::{cell::RefCell, f32::consts::PI};
+
+type Vec3 = [f32; 3];
+type Vec2 = [f32; 2];
+
+thread_local! {
+    /// Per-thread topology caches, indexed directly by sample count. Public
+    /// draw inputs are capped before reaching these helpers, so the sparse
+    /// vectors stay small while lookup remains O(1).
+    static FIBONACCI_DIRECTIONS: RefCell<Vec<Option<Box<[Vec3]>>>> = const { RefCell::new(Vec::new()) };
+    static UNIT_CIRCLES: RefCell<Vec<Option<Box<[Vec2]>>>> = const { RefCell::new(Vec::new()) };
+}
+
+/// A projected, depth-shaded disk.
+#[derive(Clone, Copy, Debug)]
+pub struct Dot {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub r: f32,
+    /// Ink value: 0 = darkest ink on paper. Mirrored on dark themes.
+    pub white: f32,
+    pub a: f32,
+}
+
+impl Dot {
+    pub fn new(x: f32, y: f32, z: f32, r: f32, white: f32) -> Self {
+        Self {
+            x,
+            y,
+            z,
+            r,
+            white,
+            a: 1.0,
+        }
+    }
+
+    pub fn with_a(mut self, a: f32) -> Self {
+        self.a = a;
+        self
+    }
+}
+
+/// A stroked edge between two projected points (the `connecting` web).
+#[derive(Clone, Copy, Debug)]
+pub struct Line {
+    pub x1: f32,
+    pub y1: f32,
+    pub x2: f32,
+    pub y2: f32,
+    pub white: f32,
+    pub a: f32,
+    pub w: f32,
+}
+
+/// Frame geometry produced by a mode painter (backend-agnostic).
+#[derive(Clone, Debug, Default)]
+pub struct Frame {
+    pub dots: Vec<Dot>,
+    pub lines: Vec<Line>,
+}
+
+impl Frame {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Drop all geometry but keep the allocated capacity, so a steady-state
+    /// animation loop reuses one pair of buffers forever.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.dots.clear();
+        self.lines.clear();
+    }
+}
+
+/// Spin + tilt + orthographic projection, precomputed once per frame.
+///
+/// This used to be a `Box<dyn Fn>`, which meant a heap allocation on every
+/// `draw_mode` call and an indirect call per dot. As a plain struct it is
+/// stack-allocated and `project` inlines into the dot loops.
+#[derive(Clone, Copy, Debug)]
+pub struct Proj {
+    st: f32,
+    ct: f32,
+    sy: f32,
+    cyw: f32,
+    cx: f32,
+    cy: f32,
+    scale: f32,
+}
+
+impl Proj {
+    #[inline]
+    pub fn project(&self, x: f32, y: f32, z: f32) -> (f32, f32, f32) {
+        let x1 = x * self.cyw + z * self.sy;
+        let z1 = -x * self.sy + z * self.cyw;
+        let y1 = y * self.ct - z1 * self.st;
+        let z2 = y * self.st + z1 * self.ct;
+        (self.cx + x1 * self.scale, self.cy - y1 * self.scale, z2)
+    }
+}
+
+#[inline]
+pub fn lerp(a: f32, b: f32, f: f32) -> f32 {
+    a + (b - a) * f
+}
+
+#[inline]
+pub fn frac(x: f32) -> f32 {
+    x - x.floor()
+}
+
+/// Deterministic hash in [0, 1).
+///
+/// The magic numbers are the canonical GLSL `fract(sin(dot(...)) * 43758.5453)`
+/// constants, kept verbatim from upstream so the generated dot layouts match.
+/// They carry more digits than `f32` can hold; that is intentional — they are
+/// quoted as written, and truncating them would be a gratuitous divergence.
+#[inline]
+#[allow(clippy::excessive_precision)]
+pub fn hash_d(a: f32, b: f32) -> f32 {
+    let h = (a * 12.9898 + b * 78.233).sin() * 43758.5453;
+    h - h.floor()
+}
+
+/// Value noise on a 2D lattice — smooth, deterministic, cheap.
+pub fn vnoise(x: f32, y: f32) -> f32 {
+    let xi = x.floor();
+    let yi = y.floor();
+    let mut fx = x - xi;
+    let mut fy = y - yi;
+    fx = fx * fx * (3.0 - 2.0 * fx);
+    fy = fy * fy * (3.0 - 2.0 * fy);
+    let a = hash_d(xi, yi);
+    let b = hash_d(xi + 1.0, yi);
+    let c = hash_d(xi, yi + 1.0);
+    let d = hash_d(xi + 1.0, yi + 1.0);
+    a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy
+}
+
+/// Stable directions on a unit sphere (Fibonacci lattice).
+pub fn fib_dir(i: usize, n: usize) -> (f32, f32, f32) {
+    let golden = PI * (3.0 - 5.0_f32.sqrt());
+    let y = 1.0 - (2.0 * (i as f32 + 0.5)) / n as f32;
+    let rad = (1.0 - y * y).sqrt();
+    let a = i as f32 * golden;
+    (rad * a.cos(), y, rad * a.sin())
+}
+
+/// Borrow the stable Fibonacci sphere for `n` points from a thread-local cache.
+/// Profiles reuse the same handful of sanitized counts every frame, so their
+/// square roots and trigonometry are normally paid only once.
+pub fn with_fib_dirs<R>(n: usize, f: impl FnOnce(&[Vec3]) -> R) -> R {
+    FIBONACCI_DIRECTIONS.with(|cell| {
+        let mut cache = cell.borrow_mut();
+        if cache.len() <= n {
+            cache.resize_with(n + 1, || None);
+        }
+        let directions = cache[n].get_or_insert_with(|| {
+            (0..n)
+                .map(|i| {
+                    let (x, y, z) = fib_dir(i, n);
+                    [x, y, z]
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+        });
+        f(directions)
+    })
+}
+
+/// Borrow evenly spaced `(cos θ, sin θ)` samples for a closed circle.
+/// Circle topology occurs in almost every mode and is invariant across frames.
+pub fn with_unit_circle<R>(n: usize, f: impl FnOnce(&[Vec2]) -> R) -> R {
+    UNIT_CIRCLES.with(|cell| {
+        let mut cache = cell.borrow_mut();
+        if cache.len() <= n {
+            cache.resize_with(n + 1, || None);
+        }
+        let circle = cache[n].get_or_insert_with(|| {
+            let step = 2.0 * PI / n.max(1) as f32;
+            (0..n)
+                .map(|i| {
+                    let a = i as f32 * step;
+                    [a.cos(), a.sin()]
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+        });
+        f(circle)
+    })
+}
+
+/// Shortest signed angular distance, wrapped to (-π, π].
+#[inline]
+pub fn angle_delta(a: f32, b: f32) -> f32 {
+    (a - b).sin().atan2((a - b).cos())
+}
+
+/// Shared spin + tilt + orthographic projection.
+pub fn make_proj(yaw: f32, tilt: f32, cx: f32, cy: f32, scale: f32) -> Proj {
+    Proj {
+        st: tilt.sin(),
+        ct: tilt.cos(),
+        sy: yaw.sin(),
+        cyw: yaw.cos(),
+        cx,
+        cy,
+        scale,
+    }
+}
+
+/// Dot radii were tuned for a 300pt frame; sub-linear scaling keeps small
+/// spinners legible. Lower pow = radii shrink less with size.
+#[inline]
+pub fn radius_scale(size: f32, pow: f32) -> f32 {
+    (size / 300.0).powf(pow)
+}
+
+/// Z-sort far→near so nearer dots paint over farther ones.
+///
+/// `sort_unstable_by` is used deliberately: it sorts in place (the stable sort
+/// allocates a scratch buffer every call) and ties only happen between dots at
+/// identical depth, where paint order is visually irrelevant.
+pub fn sort_dots(dots: &mut [Dot]) {
+    dots.sort_unstable_by(|a, b| a.z.partial_cmp(&b.z).unwrap_or(std::cmp::Ordering::Equal));
+}
diff --git a/crates/orb/src/engine/lattice.rs b/crates/orb/src/engine/lattice.rs
new file mode 100644
index 0000000000..319797d509
--- /dev/null
+++ b/crates/orb/src/engine/lattice.rs
@@ -0,0 +1,292 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Sphere-lattice modes: globe (searching), rubik (solving), wave (listening).
+
+use crate::engine::{
+    core::{Dot, Frame, angle_delta, hash_d, make_proj, radius_scale, with_unit_circle},
+    profiles::{MAX_LATTICE_RINGS, MAX_LON_DENSITY, MAX_MOVE_COUNT, ModeOpts, count_usize},
+};
+use std::{cell::RefCell, f32::consts::PI};
+
+struct Move {
+    axis: u8,
+    lo: f32,
+    hi: f32,
+    ang: f32,
+}
+
+thread_local! {
+    /// Scratch for Rubik band moves — reused every frame so Solving is
+    /// allocation-free in steady state.
+    static MOVES: RefCell<Vec<Move>> = const { RefCell::new(Vec::new()) };
+    static AMOUNTS: RefCell<Vec<f32>> = const { RefCell::new(Vec::new()) };
+}
+
+fn solve_cycle_into(
+    time: f32,
+    count: usize,
+    slot_dur: f32,
+    rest: f32,
+    amount: &mut Vec<f32>,
+) -> (i32, f32) {
+    amount.clear();
+    amount.resize(count, 0.0);
+    let mut active = -1_i32;
+    if count == 0 {
+        return (active, 0.0);
+    }
+    let cyc = 2.0 * count as f32 * slot_dur + rest;
+    let tc = time % cyc;
+    if tc < 2.0 * count as f32 * slot_dur {
+        // The guard above and this division are two independent float
+        // operations, so rounding can let `tc / slot_dur` reach `2 * count`
+        // even though `tc < 2 * count * slot_dur` held — e.g. count = 9,
+        // slot_dur = 0.42, tc = 7.559999466. Without the clamp `2*count-1-slot`
+        // wraps to `usize::MAX` and the loop below indexes out of bounds.
+        let slot = ((tc / slot_dur).floor() as usize).min(2 * count - 1);
+        let p = (tc - slot as f32 * slot_dur) / slot_dur;
+        let p = p.clamp(0.0, 1.0);
+        let ep = p * p * (3.0 - 2.0 * p);
+        let emphasis = (PI * p).sin().max(0.0).sqrt();
+        if slot < count {
+            for a in amount.iter_mut().take(slot) {
+                *a = 1.0;
+            }
+            amount[slot] = ep;
+            active = slot as i32;
+        } else {
+            let u = 2 * count - 1 - slot;
+            for a in amount.iter_mut().take(u) {
+                *a = 1.0;
+            }
+            if u < count {
+                amount[u] = 1.0 - ep;
+            }
+            active = u as i32;
+        }
+        return (active, emphasis);
+    }
+    (active, 0.0)
+}
+
+fn apply_moves(
+    pt3: (f32, f32, f32),
+    moves: &[Move],
+    amounts: &[f32],
+    active: i32,
+) -> (f32, f32, f32, bool) {
+    let (mut x, mut y, mut z) = pt3;
+    let mut in_active = false;
+    for (i, mv) in moves.iter().enumerate() {
+        if amounts[i] <= 0.0 {
+            continue;
+        }
+        let coord = match mv.axis {
+            0 => x,
+            1 => y,
+            _ => z,
+        };
+        if coord < mv.lo || coord >= mv.hi {
+            continue;
+        }
+        if i as i32 == active {
+            in_active = true;
+        }
+        let a = mv.ang * amounts[i];
+        let ca = a.cos();
+        let sa = a.sin();
+        match mv.axis {
+            0 => {
+                let y2 = y * ca - z * sa;
+                z = y * sa + z * ca;
+                y = y2;
+            }
+            1 => {
+                let x2 = x * ca + z * sa;
+                z = -x * sa + z * ca;
+                x = x2;
+            }
+            _ => {
+                let x2 = x * ca - y * sa;
+                y = x * sa + y * ca;
+                x = x2;
+            }
+        }
+    }
+    (x, y, z, in_active)
+}
+
+fn make_moves_into(count: usize, moves: &mut Vec<Move>) {
+    moves.clear();
+    moves.reserve(count);
+    for i in 0..count {
+        let i_f = i as f32;
+        let axis = (hash_d(i_f, 2.3) * 3.0).floor().min(2.0) as u8;
+        let lo = -1.0 + 0.5 * (hash_d(i_f, 5.9) * 4.0).floor().min(3.0);
+        let dir = if hash_d(i_f, 7.7) < 0.5 { 1.0 } else { -1.0 };
+        moves.push(Move {
+            axis,
+            lo,
+            hi: lo + 0.5,
+            ang: dir * PI / 2.0,
+        });
+    }
+}
+
+/// Globe: lat/long field, a scan meridian sweeps — searching.
+pub fn draw_globe_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let spin = 0.5;
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let radius = (size / 2.0) * 0.82;
+    let tilt = 0.4 + 0.06 * (t * 0.35).sin();
+    let pt = make_proj(t * spin, tilt, cx, cy, radius);
+    let scan = t * (spin + (1.7 - spin) * o.scan_mul.unwrap_or(1.0));
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+    let dim_base = o.dim_base.unwrap_or(1.0);
+
+    let dots = &mut out.dots;
+    let lat_rings = count_usize(o.lat_rings, 17.0, 1, MAX_LATTICE_RINGS as usize);
+    let lon_density = o.lon_density.unwrap_or(44.0).clamp(1.0, MAX_LON_DENSITY);
+    let r_base = o.r_base.unwrap_or(0.6);
+    let r_depth = o.r_depth.unwrap_or(1.7);
+    let r_boost = o.r_boost.unwrap_or(1.0);
+    let ink_far = o.ink_far.unwrap_or(0.62);
+    let ink_span = o.ink_span.unwrap_or(0.54);
+    let inv_lat = 1.0 / lat_rings as f32;
+
+    for li in 0..=lat_rings {
+        let lat = -PI / 2.0 + (li as f32 * inv_lat) * PI;
+        let cos_lat = lat.cos();
+        let sin_lat = lat.sin();
+        let lon_count = ((cos_lat.abs() * lon_density).round() as usize).max(1);
+        let lon_step = 2.0 * PI / lon_count as f32;
+        with_unit_circle(lon_count, |circle| {
+            for (lj, p) in circle.iter().enumerate() {
+                let lon = lj as f32 * lon_step;
+                let (clon, slon) = (p[0], p[1]);
+                let (px, py, z) = pt.project(cos_lat * clon, sin_lat, cos_lat * slon);
+                let depth = (z + 1.0) / 2.0;
+                let d = angle_delta(lon + t * spin, scan);
+                let boost = (-(d * d) / 0.18).exp() * z.max(0.0);
+                dots.push(
+                    Dot::new(
+                        px,
+                        py,
+                        z,
+                        (r_base + r_depth * depth + r_boost * boost) * rs,
+                        ink_far - ink_span * depth,
+                    )
+                    .with_a(dim_base + (1.0 - dim_base) * boost.min(1.0)),
+                );
+            }
+        });
+    }
+}
+
+/// Rubik: bands twist in quarter turns, scramble → solve — solving.
+pub fn draw_rubik_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let r = (size / 2.0) * 0.82;
+    // Keep the lattice almost still so each quarter-turn reads as the action,
+    // rather than getting lost inside a continuously spinning globe.
+    let pt = make_proj(t * 0.12, 0.35 + 0.035 * (t * 0.45).sin(), cx, cy, r);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+    let move_count = count_usize(o.move_count, 14.0, 0, MAX_MOVE_COUNT as usize);
+
+    MOVES.with(|moves_cell| {
+        AMOUNTS.with(|amounts_cell| {
+            let mut moves = moves_cell.borrow_mut();
+            let mut amounts = amounts_cell.borrow_mut();
+            if moves.len() != move_count {
+                make_moves_into(move_count, &mut moves);
+            }
+            let (active, emphasis) = solve_cycle_into(t, move_count, 0.58, 1.35, &mut amounts);
+
+            let dots = &mut out.dots;
+            let lat_rings = count_usize(o.lat_rings, 15.0, 1, MAX_LATTICE_RINGS as usize);
+            let lon_density = o.lon_density.unwrap_or(40.0).clamp(1.0, MAX_LON_DENSITY);
+            let r_base = o.r_base.unwrap_or(0.6);
+            let r_depth = o.r_depth.unwrap_or(1.7);
+            let r_active = o.r_active.unwrap_or(0.3);
+            let ink_far = o.ink_far.unwrap_or(0.62);
+            let ink_span = o.ink_span.unwrap_or(0.54);
+            let inv_lat = 1.0 / lat_rings as f32;
+
+            for li in 0..=lat_rings {
+                let lat = -PI / 2.0 + (li as f32 * inv_lat) * PI;
+                let cos_lat = lat.cos();
+                let sin_lat = lat.sin();
+                let lon_count = ((cos_lat.abs() * lon_density).round() as usize).max(1);
+                with_unit_circle(lon_count, |circle| {
+                    for p in circle {
+                        let (x, y, z, in_active) = apply_moves(
+                            (cos_lat * p[0], sin_lat, cos_lat * p[1]),
+                            &moves,
+                            &amounts,
+                            active,
+                        );
+                        let (px, py, zr) = pt.project(x, y, z);
+                        let depth = (zr + 1.0) / 2.0;
+                        let active_mix = if in_active { emphasis } else { 0.0 };
+                        dots.push(
+                            Dot::new(
+                                px,
+                                py,
+                                zr,
+                                (r_base + r_depth * depth + r_active * 2.1 * active_mix) * rs,
+                                ink_far - ink_span * depth - 0.24 * active_mix,
+                            )
+                            .with_a(0.58 + 0.14 * depth + 0.28 * active_mix),
+                        );
+                    }
+                });
+            }
+        });
+    });
+}
+
+/// Wave: a waveform rolls through the rings — listening.
+pub fn draw_wave_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let r = (size / 2.0) * 0.874;
+    let pt = make_proj(t * 0.18, 0.38, cx, cy, 1.0);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+
+    let dots = &mut out.dots;
+    let rings = count_usize(o.rings, 15.0, 1, MAX_LATTICE_RINGS as usize);
+    let lon_density = o.lon_density.unwrap_or(40.0).clamp(1.0, MAX_LON_DENSITY);
+    let r_base = o.r_base.unwrap_or(0.6);
+    let r_depth = o.r_depth.unwrap_or(1.7);
+    let inv_rings = 1.0 / rings as f32;
+    let inv_r = 1.0 / r;
+
+    for ri in 0..=rings {
+        let lat = -PI / 2.0 + (ri as f32 * inv_rings) * PI;
+        let cos_lat = lat.cos();
+        let sin_lat = lat.sin();
+        let w =
+            0.62 * (t * 2.1 - ri as f32 * 0.52).sin() + 0.38 * (t * 1.27 + ri as f32 * 0.83).sin();
+        let rr = r * (0.88 + 0.105 * w);
+        let lon_count = ((cos_lat.abs() * lon_density).round() as usize).max(1);
+        let crest = w.max(0.0);
+        let crest_r = 1.0 + 0.4 * crest;
+        let crest_ink = 0.1 * crest;
+        with_unit_circle(lon_count, |circle| {
+            for p in circle {
+                let (clon, slon) = (p[0], p[1]);
+                let (px, py, z) =
+                    pt.project(cos_lat * clon * rr, sin_lat * rr, cos_lat * slon * rr);
+                let depth = (z * inv_r + 1.0) / 2.0;
+                dots.push(Dot::new(
+                    px,
+                    py,
+                    z,
+                    (r_base + r_depth * depth) * crest_r * rs,
+                    0.66 - 0.56 * depth - crest_ink,
+                ));
+            }
+        });
+    }
+}
diff --git a/crates/orb/src/engine/mod.rs b/crates/orb/src/engine/mod.rs
new file mode 100644
index 0000000000..1cc153c7bd
--- /dev/null
+++ b/crates/orb/src/engine/mod.rs
@@ -0,0 +1,82 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Backend-agnostic animation engine (ported from thinking-orbs).
+
+mod braid;
+mod concepts;
+mod core;
+mod lattice;
+mod morph;
+mod orbits;
+mod profiles;
+mod ribbon;
+mod web;
+
+pub use core::{Dot, Frame, Line, Proj, make_proj, sort_dots};
+pub use profiles::{
+    MAX_ICON_D, MAX_MORPH_DOTS, MAX_NODE_N, MAX_SIZE, MIN_SIZE, ModeOpts, base_profile,
+    sanitize_mode_opts, sanitize_size, scale_counts, scale_radii,
+};
+
+use crate::types::ModeKey;
+use braid::draw_braid_into;
+use concepts::{draw_echo_into, draw_focus_into, draw_gyroscope_into};
+use lattice::{draw_globe_into, draw_rubik_into, draw_wave_into};
+use morph::draw_morph_into;
+use orbits::draw_orbits_into;
+use ribbon::draw_ribbon_into;
+use web::draw_web_into;
+
+/// Paint one frame for the given mode into an existing [`Frame`], reusing its
+/// buffers.
+///
+/// This is the allocation-free entry point for the **geometry** buffers: `out`
+/// is cleared but keeps its capacity, so a steady-state animation loop performs
+/// no heap growth after the first frame (the Solving mode reuses thread-local
+/// scratch for its move tables). Prefer this over [`draw_mode`] in render loops.
+///
+/// `size` and every count-like field of `opts` are sanitized (finite + hard
+/// ceilings) before geometry runs — see [`sanitize_mode_opts`].
+pub fn draw_mode_into(mode: ModeKey, size: f32, t: f32, opts: &ModeOpts, out: &mut Frame) {
+    let size = sanitize_size(size);
+    let opts = sanitize_mode_opts(opts);
+    let t = if t.is_finite() { t } else { 0.0 };
+    draw_mode_into_resolved(mode, size, t, &opts, out);
+}
+
+/// Fast path for the widget's already-sanitized, size-bounded presets.
+///
+/// Only for options from [`crate::resolve_preset`], which are already finite
+/// and bounded: it skips the 40-field clone/sanitize pass on every widget
+/// tick. Arbitrary options must go through [`draw_mode_into`].
+#[doc(hidden)]
+pub fn draw_mode_into_resolved(mode: ModeKey, size: f32, t: f32, opts: &ModeOpts, out: &mut Frame) {
+    out.clear();
+    match mode {
+        ModeKey::Orbits => draw_orbits_into(size, t, opts, out),
+        ModeKey::Globe => draw_globe_into(size, t, opts, out),
+        ModeKey::Rubik => draw_rubik_into(size, t, opts, out),
+        ModeKey::Wave => draw_wave_into(size, t, opts, out),
+        ModeKey::Web => draw_web_into(size, t, opts, out),
+        ModeKey::Braid => draw_braid_into(size, t, opts, out),
+        ModeKey::Ribbon | ModeKey::Ring => draw_ribbon_into(size, t, opts, out),
+        ModeKey::Morph => draw_morph_into(size, t, opts, out),
+        ModeKey::Focus => draw_focus_into(size, t, opts, out),
+        ModeKey::Gyroscope => draw_gyroscope_into(size, t, opts, out),
+        ModeKey::Echo => draw_echo_into(size, t, opts, out),
+    }
+    // Face-on modes intentionally emit z=0 in painter order, so a comparison
+    // sort cannot change their result. Avoid it entirely.
+    if !matches!(mode, ModeKey::Focus | ModeKey::Echo) {
+        sort_dots(&mut out.dots);
+    }
+}
+
+/// Paint one frame for the given mode into a fresh [`Frame`].
+///
+/// Convenience wrapper around [`draw_mode_into`] for one-off calls and tests;
+/// it allocates. Render loops should use [`draw_mode_into`] instead.
+pub fn draw_mode(mode: ModeKey, size: f32, t: f32, opts: &ModeOpts) -> Frame {
+    let mut frame = Frame::new();
+    draw_mode_into(mode, size, t, opts, &mut frame);
+    frame
+}
diff --git a/crates/orb/src/engine/morph.rs b/crates/orb/src/engine/morph.rs
new file mode 100644
index 0000000000..4c5467b727
--- /dev/null
+++ b/crates/orb/src/engine/morph.rs
@@ -0,0 +1,172 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Morph: dotted outline cycling circle → triangle → square — "shaping".
+
+use crate::engine::{
+    core::{Dot, Frame},
+    profiles::{MAX_MORPH_DOTS, ModeOpts},
+};
+use std::f32::consts::PI;
+
+/// Outline resolution used to re-parameterise the blended shape by arc length.
+const M_SAMPLES: usize = 160;
+/// Largest vertex count across the shipped polygons (square, incl. the
+/// repeated closing vertex).
+const MAX_VERTS: usize = 8;
+
+const TRIANGLE: [(f32, f32); 3] = [(0.0, -0.26), (0.24, 0.16), (-0.24, 0.16)];
+const SQUARE: [(f32, f32); 4] = [(0.0, -0.2), (0.2, -0.2), (0.2, 0.2), (-0.2, 0.2)];
+
+fn smooth_e(x: f32) -> f32 {
+    x * x * (3.0 - 2.0 * x)
+}
+
+fn circle_path(f: f32) -> (f32, f32) {
+    let a = -PI / 2.0 + f * 2.0 * PI;
+    (a.cos() * 0.24, a.sin() * 0.24)
+}
+
+/// Arc-length parameterisation of a closed polygon.
+///
+/// Used to be a `Box<dyn Fn>` built three times per frame; now it is a plain
+/// stack value with fixed-capacity length table.
+struct PolyPath {
+    verts: &'static [(f32, f32)],
+    lengths: [f32; MAX_VERTS],
+    total: f32,
+}
+
+impl PolyPath {
+    fn new(verts: &'static [(f32, f32)]) -> Self {
+        debug_assert!(verts.len() <= MAX_VERTS);
+        let mut lengths = [0.0; MAX_VERTS];
+        let mut total = 0.0;
+        let v = verts.len();
+        for i in 0..v {
+            let a = verts[i];
+            let b = verts[(i + 1) % v];
+            let l = (b.0 - a.0).hypot(b.1 - a.1);
+            lengths[i] = l;
+            total += l;
+        }
+        Self {
+            verts,
+            lengths,
+            total,
+        }
+    }
+
+    fn at(&self, f: f32) -> (f32, f32) {
+        let v = self.verts.len();
+        let mut target = f * self.total;
+        let mut i = 0;
+        // Bounds check first: `i` can never leave `0..v`.
+        while i < v - 1 && target > self.lengths[i] {
+            target -= self.lengths[i];
+            i += 1;
+        }
+        let a = self.verts[i];
+        let b = self.verts[(i + 1) % v];
+        let ff = if self.lengths[i] > 0.0 {
+            (target / self.lengths[i]).min(1.0)
+        } else {
+            0.0
+        };
+        (a.0 + (b.0 - a.0) * ff, a.1 + (b.1 - a.1) * ff)
+    }
+}
+
+enum Shape {
+    Circle,
+    Poly(PolyPath),
+}
+
+impl Shape {
+    fn at(&self, f: f32) -> (f32, f32) {
+        match self {
+            Shape::Circle => circle_path(f),
+            Shape::Poly(p) => p.at(f),
+        }
+    }
+}
+
+fn morph_n(d: f32) -> usize {
+    let n = (34.0 * d).round().max(6.0);
+    (n as usize).clamp(6, MAX_MORPH_DOTS)
+}
+
+const HOLD: f32 = 1.4;
+const MORPH: f32 = 0.9;
+const SEG: f32 = HOLD + MORPH;
+
+pub fn draw_morph_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cycle = [
+        Shape::Circle,
+        Shape::Poly(PolyPath::new(&TRIANGLE)),
+        Shape::Poly(PolyPath::new(&SQUARE)),
+    ];
+    let k_len = cycle.len();
+    let tc = t.rem_euclid(SEG * k_len as f32);
+    let k = ((tc / SEG).floor() as usize).min(k_len - 1);
+    let local = tc - k as f32 * SEG;
+    let m = if local > HOLD {
+        smooth_e((local - HOLD) / MORPH)
+    } else {
+        0.0
+    };
+    let sprd = o.spread.unwrap_or(1.0);
+
+    let p_a = &cycle[k];
+    let p_b = &cycle[(k + 1) % k_len];
+
+    // Fixed-size stack scratch — no per-frame heap traffic.
+    let mut pts = [(0.0f32, 0.0f32); M_SAMPLES];
+    let mut lengths = [0.0f32; M_SAMPLES];
+    let inv_samples = 1.0 / M_SAMPLES as f32;
+    for (i, p) in pts.iter_mut().enumerate() {
+        let f = i as f32 * inv_samples;
+        let a = p_a.at(f);
+        let b = p_b.at(f);
+        *p = (
+            (a.0 + (b.0 - a.0) * m) * sprd,
+            (a.1 + (b.1 - a.1) * m) * sprd,
+        );
+    }
+    let mut total = 0.0f32;
+    for i in 0..M_SAMPLES {
+        let a = pts[i];
+        let b = pts[(i + 1) % M_SAMPLES];
+        let l = (b.0 - a.0).hypot(b.1 - a.1);
+        lengths[i] = l;
+        total += l;
+    }
+
+    let n = morph_n(o.icon_d.unwrap_or(1.0));
+    let re = o.r_dot.unwrap_or(0.021) * 1.35 * sprd;
+    let pulse = 1.0 + 0.018 * (t * 2.35).sin();
+
+    let dots = &mut out.dots;
+    dots.reserve(n);
+    let c2 = size / 2.0;
+    let radius = (re * size).max(0.35);
+    let mut seg = 0usize;
+    let mut acc = 0.0f32;
+    let inv_n = 1.0 / n as f32;
+    for k2 in 0..n {
+        let target = k2 as f32 * inv_n * total;
+        // Bounds check first: `seg` can never leave `0..M_SAMPLES`.
+        while seg < M_SAMPLES - 1 && acc + lengths[seg] < target {
+            acc += lengths[seg];
+            seg += 1;
+        }
+        let a = pts[seg];
+        let b = pts[(seg + 1) % M_SAMPLES];
+        let f = if lengths[seg] > 0.0 {
+            ((target - acc) / lengths[seg]).min(1.0)
+        } else {
+            0.0
+        };
+        let x = (a.0 + (b.0 - a.0) * f) * pulse;
+        let y = (a.1 + (b.1 - a.1) * f) * pulse;
+        dots.push(Dot::new(c2 + x * size, c2 + y * size, 0.0, radius, 0.1));
+    }
+}
diff --git a/crates/orb/src/engine/orbits.rs b/crates/orb/src/engine/orbits.rs
new file mode 100644
index 0000000000..b29b30fb8d
--- /dev/null
+++ b/crates/orb/src/engine/orbits.rs
@@ -0,0 +1,90 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Orbits: particles on tilted orbits — the "working" state.
+
+use crate::engine::{
+    core::{Dot, Frame, hash_d, make_proj, radius_scale, with_unit_circle},
+    profiles::{MAX_GHOST_N, MAX_ORBIT_N, MAX_PARTICLES, ModeOpts, count_usize},
+};
+use std::f32::consts::PI;
+
+pub fn draw_orbits_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let r = (size / 2.0) * 0.82;
+    let pt = make_proj(t * 0.12, 0.3, cx, cy, 1.0);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+
+    let orbit_n = count_usize(o.orbit_n, 12.0, 0, MAX_ORBIT_N as usize);
+    let ghost_n = count_usize(o.ghost_n, 40.0, 0, MAX_GHOST_N as usize);
+    let particles = count_usize(o.particles, 3.0, 0, MAX_PARTICLES as usize);
+
+    let dots = &mut out.dots;
+    let per_orbit = ghost_n.saturating_add(particles);
+    dots.reserve(orbit_n.saturating_mul(per_orbit));
+    let ghost_r = o.ghost_r.unwrap_or(0.9) * rs;
+    let ghost_a = o.ghost_a.unwrap_or(0.5);
+    let part_r = o.part_r.unwrap_or(1.2);
+    let part_r_depth = o.part_r_depth.unwrap_or(1.6);
+
+    for orb in 0..orbit_n {
+        let orb_f = orb as f32;
+        let h1 = hash_d(orb_f, 1.7);
+        let h2 = hash_d(orb_f, 5.2);
+        let h3 = hash_d(orb_f, 8.9);
+        let ro = r * (0.45 + 0.52 * h1);
+        let th = h1 * 2.0 * PI;
+        let phi = (2.0 * h2 - 1.0).acos();
+        // Build a stable plane basis by crossing the normal with whichever
+        // world axis is least parallel to it.
+        let nx = phi.sin() * th.cos();
+        let ny = phi.cos();
+        let nz = phi.sin() * th.sin();
+        let (mut ux, mut uy, mut uz) = if nz.abs() < 0.9 {
+            (-ny, nx, 0.0)
+        } else {
+            (0.0, -nz, ny)
+        };
+        let ul = (ux * ux + uy * uy + uz * uz).sqrt().max(1e-6);
+        ux /= ul;
+        uy /= ul;
+        uz /= ul;
+        let vx = ny * uz - nz * uy;
+        let vy = nz * ux - nx * uz;
+        let vz = nx * uy - ny * ux;
+        let speed = (0.25 + 0.55 * h3) * if h3 > 0.5 { 1.0 } else { -1.0 };
+        let inv_ro = 1.0 / ro;
+
+        // Ghost topology is invariant; reuse its unit-circle samples instead
+        // of evaluating 2 × orbit_n × ghost_n trig functions every frame.
+        with_unit_circle(ghost_n, |circle| {
+            for p in circle {
+                let (ca, sa) = (p[0], p[1]);
+                let (px, py, z) = pt.project(
+                    (ux * ca + vx * sa) * ro,
+                    (uy * ca + vy * sa) * ro,
+                    (uz * ca + vz * sa) * ro,
+                );
+                let depth = (z * inv_ro + 1.0) / 2.0;
+                dots.push(Dot::new(px, py, z, ghost_r, 0.72).with_a(ghost_a * (0.4 + 0.6 * depth)));
+            }
+        });
+        // the particles doing the work
+        for m in 0..particles {
+            let a = t * speed + (m as f32 / particles as f32) * 2.0 * PI + h2 * 6.0;
+            let (ca, sa) = (a.cos(), a.sin());
+            let (px, py, z) = pt.project(
+                (ux * ca + vx * sa) * ro,
+                (uy * ca + vy * sa) * ro,
+                (uz * ca + vz * sa) * ro,
+            );
+            let depth = (z * inv_ro + 1.0) / 2.0;
+            dots.push(Dot::new(
+                px,
+                py,
+                z,
+                (part_r + part_r_depth * depth) * rs,
+                0.3 - 0.22 * depth,
+            ));
+        }
+    }
+}
diff --git a/crates/orb/src/engine/profiles.rs b/crates/orb/src/engine/profiles.rs
new file mode 100644
index 0000000000..78640cbdd2
--- /dev/null
+++ b/crates/orb/src/engine/profiles.rs
@@ -0,0 +1,385 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Density profiles + the multiplier machinery that scales them.
+
+/// Hard ceilings for count-like knobs. Preset values sit well below these;
+/// they only bite adversarial or mistaken power-user inputs.
+pub const MAX_LATTICE_RINGS: f32 = 128.0;
+pub const MAX_LON_DENSITY: f32 = 256.0;
+pub const MAX_ORBIT_N: f32 = 64.0;
+pub const MAX_GHOST_N: f32 = 512.0;
+pub const MAX_PARTICLES: f32 = 16.0;
+pub const MAX_NODE_N: f32 = 128.0;
+pub const MAX_SIGNALS: f32 = 64.0;
+pub const MAX_STRAND_N: f32 = 256.0;
+pub const MAX_LANES: f32 = 32.0;
+pub const MAX_SEGS: f32 = 512.0;
+pub const MAX_MOVE_COUNT: f32 = 64.0;
+pub const MAX_ICON_D: f32 = 8.0;
+/// Max dots the Morph painter will emit after `icon_d` is applied.
+pub const MAX_MORPH_DOTS: usize = 512;
+/// Logical size (px) accepted by [`crate::engine::draw_mode_into`].
+pub const MIN_SIZE: f32 = 1.0;
+pub const MAX_SIZE: f32 = 1024.0;
+
+/// Free-form numeric knobs for mode painters (mirrors upstream `ModeOpts`).
+///
+/// **Power-user / advanced API.** The normal path is the host widget /
+/// [`crate::resolve_preset`], which only ever pass hand-tuned finite values.
+///
+/// If you build a [`ModeOpts`] yourself and pass it to
+/// [`crate::engine::draw_mode`] / [`crate::engine::draw_mode_into`], every count-like field is
+/// clamped by [`sanitize_mode_opts`] before geometry runs:
+///
+/// | Field family | Range after sanitize |
+/// |--------------|----------------------|
+/// | lattice rings / density | 1…128 / 1…256 |
+/// | `orbit_n`, `ghost_n`, `particles` | 0…64 / 0…512 / 0…16 |
+/// | `node_n`, `signals` | 0…128 / 0…64 |
+/// | `strand_n`, `lanes`, `segs` | 0…256 / 1…32 / 1…512 |
+/// | `move_count` | 0…64 |
+/// | `icon_d` | 0.02…8 |
+///
+/// Non-finite values fall back to the field default used by the painter.
+/// New fields may be added without a major version bump.
+#[derive(Clone, Debug, Default)]
+#[non_exhaustive]
+pub struct ModeOpts {
+    // lattice
+    pub lat_rings: Option<f32>,
+    pub lon_density: Option<f32>,
+    pub rings: Option<f32>,
+    pub r_base: Option<f32>,
+    pub r_depth: Option<f32>,
+    pub r_boost: Option<f32>,
+    pub r_active: Option<f32>,
+    pub ink_far: Option<f32>,
+    pub ink_span: Option<f32>,
+    pub rs_pow: Option<f32>,
+    pub r_min: Option<f32>,
+    pub move_count: Option<f32>,
+    pub scan_mul: Option<f32>,
+    pub dim_base: Option<f32>,
+    // orbits
+    pub orbit_n: Option<f32>,
+    pub ghost_n: Option<f32>,
+    pub ghost_r: Option<f32>,
+    pub ghost_a: Option<f32>,
+    pub particles: Option<f32>,
+    pub part_r: Option<f32>,
+    pub part_r_depth: Option<f32>,
+    // web
+    pub node_n: Option<f32>,
+    pub thr: Option<f32>,
+    pub signals: Option<f32>,
+    pub node_r: Option<f32>,
+    pub node_r_depth: Option<f32>,
+    pub line_w: Option<f32>,
+    // braid
+    pub strand_n: Option<f32>,
+    pub turns: Option<f32>,
+    // ribbon / ring
+    pub lanes: Option<f32>,
+    pub segs: Option<f32>,
+    pub face_on: Option<f32>,
+    pub spin: Option<f32>,
+    pub band_mul: Option<f32>,
+    pub wob_mul: Option<f32>,
+    // morph
+    pub r_dot: Option<f32>,
+    pub icon_d: Option<f32>,
+    pub spread: Option<f32>,
+    pub r_size_mul: Option<f32>,
+}
+
+/// Clamp a free-form float option into a finite range, or leave `None`.
+fn clamp_opt(v: Option<f32>, min: f32, max: f32) -> Option<f32> {
+    v.and_then(|x| {
+        if x.is_finite() {
+            Some(x.clamp(min, max))
+        } else {
+            None
+        }
+    })
+}
+
+/// Return a safe copy of `opts` with every count-like / radius-like knob
+/// finite and within the hard ceilings above.
+///
+/// Called automatically by [`crate::engine::draw_mode_into`]. Safe to call yourself
+/// when composing custom profiles.
+pub fn sanitize_mode_opts(opts: &ModeOpts) -> ModeOpts {
+    ModeOpts {
+        lat_rings: clamp_opt(opts.lat_rings, 1.0, MAX_LATTICE_RINGS),
+        lon_density: clamp_opt(opts.lon_density, 1.0, MAX_LON_DENSITY),
+        rings: clamp_opt(opts.rings, 1.0, MAX_LATTICE_RINGS),
+        r_base: clamp_opt(opts.r_base, 0.0, 64.0),
+        r_depth: clamp_opt(opts.r_depth, 0.0, 64.0),
+        r_boost: clamp_opt(opts.r_boost, 0.0, 64.0),
+        r_active: clamp_opt(opts.r_active, 0.0, 64.0),
+        ink_far: clamp_opt(opts.ink_far, 0.0, 1.0),
+        ink_span: clamp_opt(opts.ink_span, 0.0, 2.0),
+        rs_pow: clamp_opt(opts.rs_pow, 0.05, 4.0),
+        r_min: clamp_opt(opts.r_min, 0.0, 32.0),
+        move_count: clamp_opt(opts.move_count, 0.0, MAX_MOVE_COUNT),
+        scan_mul: clamp_opt(opts.scan_mul, 0.0, 16.0),
+        dim_base: clamp_opt(opts.dim_base, 0.0, 1.0),
+        orbit_n: clamp_opt(opts.orbit_n, 0.0, MAX_ORBIT_N),
+        ghost_n: clamp_opt(opts.ghost_n, 0.0, MAX_GHOST_N),
+        ghost_r: clamp_opt(opts.ghost_r, 0.0, 64.0),
+        ghost_a: clamp_opt(opts.ghost_a, 0.0, 1.0),
+        particles: clamp_opt(opts.particles, 0.0, MAX_PARTICLES),
+        part_r: clamp_opt(opts.part_r, 0.0, 64.0),
+        part_r_depth: clamp_opt(opts.part_r_depth, 0.0, 64.0),
+        node_n: clamp_opt(opts.node_n, 0.0, MAX_NODE_N),
+        thr: clamp_opt(opts.thr, 0.0, 4.0),
+        signals: clamp_opt(opts.signals, 0.0, MAX_SIGNALS),
+        node_r: clamp_opt(opts.node_r, 0.0, 64.0),
+        node_r_depth: clamp_opt(opts.node_r_depth, 0.0, 64.0),
+        line_w: clamp_opt(opts.line_w, 0.0, 32.0),
+        strand_n: clamp_opt(opts.strand_n, 0.0, MAX_STRAND_N),
+        turns: clamp_opt(opts.turns, 0.0, 32.0),
+        lanes: clamp_opt(opts.lanes, 1.0, MAX_LANES),
+        segs: clamp_opt(opts.segs, 1.0, MAX_SEGS),
+        face_on: clamp_opt(opts.face_on, 0.0, 1.0),
+        spin: clamp_opt(opts.spin, -16.0, 16.0),
+        band_mul: clamp_opt(opts.band_mul, 0.05, 8.0),
+        wob_mul: clamp_opt(opts.wob_mul, 0.0, 8.0),
+        r_dot: clamp_opt(opts.r_dot, 0.0, 1.0),
+        icon_d: clamp_opt(opts.icon_d, 0.02, MAX_ICON_D),
+        spread: clamp_opt(opts.spread, 0.05, 4.0),
+        r_size_mul: clamp_opt(opts.r_size_mul, 0.0, 64.0),
+    }
+}
+
+/// Clamp the logical paint size in pixels.
+pub fn sanitize_size(size: f32) -> f32 {
+    if size.is_finite() {
+        size.clamp(MIN_SIZE, MAX_SIZE)
+    } else {
+        64.0
+    }
+}
+
+/// Interpret a count-like option as `usize` after sanitization has run.
+///
+/// Prefer calling this on already-sanitized opts. Non-finite / missing use
+/// `default`; the result is always in `min..=max`.
+#[inline]
+pub fn count_usize(v: Option<f32>, default: f32, min: usize, max: usize) -> usize {
+    let x = match v {
+        Some(x) if x.is_finite() => x,
+        _ => default,
+    };
+    let lo = min as f32;
+    let hi = max as f32;
+    (x.round().clamp(lo, hi)) as usize
+}
+
+/// Scale total dot density. 2-D lattices (rings × dots-per-ring) take √scale
+/// each side so the TOTAL scales by `scale`. Flat lists scale linearly.
+pub fn scale_counts(opts: &ModeOpts, scale: f32) -> ModeOpts {
+    let mut out = opts.clone();
+    let scale = if scale.is_finite() && scale > 0.0 {
+        scale
+    } else {
+        1.0
+    };
+    let rt = scale.sqrt();
+
+    // Upstream COUNT_PAIRS: latRings×lonDensity first (owns lonDensity),
+    // then rings×lonDensity only if latRings was absent.
+    if let (Some(va), Some(vb)) = (out.lat_rings, out.lon_density) {
+        out.lat_rings = Some((va * rt).round().clamp(2.0, MAX_LATTICE_RINGS));
+        out.lon_density = Some((vb * rt).round().clamp(2.0, MAX_LON_DENSITY));
+    } else if let (Some(va), Some(vb)) = (out.rings, out.lon_density) {
+        out.rings = Some((va * rt).round().clamp(2.0, MAX_LATTICE_RINGS));
+        out.lon_density = Some((vb * rt).round().clamp(2.0, MAX_LON_DENSITY));
+    }
+    // lanes × segs pair
+    if let (Some(va), Some(vb)) = (out.lanes, out.segs) {
+        out.lanes = Some((va * rt).round().clamp(2.0, MAX_LANES));
+        out.segs = Some((vb * rt).round().clamp(2.0, MAX_SEGS));
+    }
+
+    // linear count keys (0 means opt-out — do not resurrect)
+    let scale_key = |v: Option<f32>, max: f32| match v {
+        Some(0.0) => Some(0.0),
+        Some(v) if v.is_finite() => Some((v * scale).round().clamp(1.0, max)),
+        Some(_) => None,
+        None => None,
+    };
+    out.orbit_n = scale_key(out.orbit_n, MAX_ORBIT_N);
+    out.ghost_n = scale_key(out.ghost_n, MAX_GHOST_N);
+    out.node_n = scale_key(out.node_n, MAX_NODE_N);
+    out.strand_n = scale_key(out.strand_n, MAX_STRAND_N);
+    out.signals = scale_key(out.signals, MAX_SIGNALS);
+
+    if let Some(v) = out.icon_d {
+        if v.is_finite() {
+            out.icon_d = Some((v * scale).clamp(0.02, MAX_ICON_D));
+        } else {
+            out.icon_d = None;
+        }
+    }
+    out
+}
+
+/// Scale every key that sets a dot's rendered radius.
+pub fn scale_radii(opts: &ModeOpts, scale: f32) -> ModeOpts {
+    let mut out = opts.clone();
+    let scale = if scale.is_finite() { scale } else { 1.0 };
+    let mul = |v: Option<f32>| v.and_then(|x| x.is_finite().then_some(x * scale));
+    out.r_base = mul(out.r_base);
+    out.r_depth = mul(out.r_depth);
+    out.r_active = mul(out.r_active);
+    out.r_dot = mul(out.r_dot);
+    out.ghost_r = mul(out.ghost_r);
+    out.part_r = mul(out.part_r);
+    out.part_r_depth = mul(out.part_r_depth);
+    out.node_r = mul(out.node_r);
+    out.node_r_depth = mul(out.node_r_depth);
+    out.r_size_mul = Some(out.r_size_mul.unwrap_or(1.0) * scale);
+    out
+}
+
+impl ModeOpts {
+    /// The base profile for `mode`, then hand the mutable options over for the
+    /// power-user tweaks a preset cannot express. The struct is
+    /// `#[non_exhaustive]`, so this is the only way to build one outside the
+    /// crate.
+    pub fn fill(mode: crate::types::ModeKey, f: impl FnOnce(&mut Self)) -> Self {
+        let mut opts = base_profile(mode);
+        f(&mut opts);
+        opts
+    }
+}
+
+/// Base (fine) profiles per mode, before preset multipliers.
+pub fn base_profile(mode: crate::types::ModeKey) -> ModeOpts {
+    use crate::types::ModeKey::*;
+    match mode {
+        Globe => ModeOpts {
+            lat_rings: Some(17.0),
+            lon_density: Some(44.0),
+            r_base: Some(0.6),
+            r_depth: Some(1.7),
+            r_boost: Some(1.0),
+            ink_far: Some(0.62),
+            ink_span: Some(0.54),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Orbits => ModeOpts {
+            orbit_n: Some(12.0),
+            ghost_n: Some(40.0),
+            ghost_r: Some(0.9),
+            ghost_a: Some(0.5),
+            particles: Some(3.0),
+            part_r: Some(1.2),
+            part_r_depth: Some(1.6),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Rubik => ModeOpts {
+            lat_rings: Some(15.0),
+            lon_density: Some(40.0),
+            move_count: Some(14.0),
+            r_base: Some(0.6),
+            r_depth: Some(1.7),
+            r_active: Some(0.3),
+            ink_far: Some(0.62),
+            ink_span: Some(0.54),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Wave => ModeOpts {
+            rings: Some(15.0),
+            lon_density: Some(40.0),
+            r_base: Some(0.6),
+            r_depth: Some(1.7),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Web => ModeOpts {
+            node_n: Some(30.0),
+            thr: Some(0.72),
+            signals: Some(5.0),
+            node_r: Some(1.4),
+            node_r_depth: Some(1.8),
+            line_w: Some(0.8),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Braid => ModeOpts {
+            strand_n: Some(52.0),
+            turns: Some(3.0),
+            ghost_n: Some(150.0),
+            r_base: Some(1.2),
+            r_depth: Some(1.8),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Ribbon => ModeOpts {
+            lanes: Some(5.0),
+            segs: Some(88.0),
+            ghost_n: Some(150.0),
+            r_base: Some(1.1),
+            r_depth: Some(1.7),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Ring => ModeOpts {
+            lanes: Some(5.0),
+            segs: Some(88.0),
+            ghost_n: Some(0.0),
+            face_on: Some(1.0),
+            r_base: Some(1.1),
+            r_depth: Some(1.7),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Morph => ModeOpts {
+            r_dot: Some(0.021),
+            icon_d: Some(1.0),
+            r_min: Some(0.25),
+            ..Default::default()
+        },
+        Focus => ModeOpts {
+            lanes: Some(6.0),
+            segs: Some(12.0),
+            particles: Some(5.0),
+            r_base: Some(0.9),
+            r_depth: Some(1.25),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Gyroscope => ModeOpts {
+            lanes: Some(3.0),
+            segs: Some(28.0),
+            r_base: Some(0.8),
+            r_depth: Some(1.5),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+        Echo => ModeOpts {
+            lanes: Some(4.0),
+            segs: Some(18.0),
+            particles: Some(3.0),
+            r_base: Some(0.85),
+            r_depth: Some(1.05),
+            rs_pow: Some(0.6),
+            r_min: Some(0.3),
+            ..Default::default()
+        },
+    }
+}
diff --git a/crates/orb/src/engine/ribbon.rs b/crates/orb/src/engine/ribbon.rs
new file mode 100644
index 0000000000..2b4ae5568a
--- /dev/null
+++ b/crates/orb/src/engine/ribbon.rs
@@ -0,0 +1,110 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Ribbon / ring: undulating sash or face-on breathing ring.
+
+use crate::engine::{
+    core::{Dot, Frame, make_proj, radius_scale, with_fib_dirs},
+    profiles::{MAX_GHOST_N, MAX_LANES, MAX_SEGS, ModeOpts, count_usize},
+};
+use std::f32::consts::PI;
+
+pub fn draw_ribbon_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let r = (size / 2.0) * 0.78;
+    let spin = o.spin.unwrap_or(1.0);
+    let cam_tilt = 0.3;
+    let pt = make_proj(t * 0.1 * spin, cam_tilt, cx, cy, 1.0);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+    let face_on = o.face_on.unwrap_or(0.0) != 0.0;
+
+    let dots = &mut out.dots;
+    let ghost_n = count_usize(o.ghost_n, 150.0, 0, MAX_GHOST_N as usize);
+    let inv_r = 1.0 / r;
+    dots.reserve(ghost_n);
+    with_fib_dirs(ghost_n, |directions| {
+        for d in directions {
+            let (px, py, z) = pt.project(d[0] * r, d[1] * r, d[2] * r);
+            let depth = (z * inv_r + 1.0) / 2.0;
+            dots.push(Dot::new(px, py, z, 0.8 * rs, 0.78).with_a(0.1 + 0.22 * depth));
+        }
+    });
+
+    let ya = t * 0.24 * spin;
+    let ta = if face_on {
+        -cam_tilt
+    } else {
+        0.55 + 0.3 * (t * 0.18).sin() * spin
+    };
+    let ux = ya.cos();
+    let uy = 0.0;
+    let uz = ya.sin();
+    let (sta, cta) = (ta.sin(), ta.cos());
+    let vx = -uz * sta;
+    let vy = cta;
+    let vz = ux * sta;
+    // plane normal n = u × v
+    let nx = uy * vz - uz * vy;
+    let ny = uz * vx - ux * vz;
+    let nz = ux * vy - uy * vx;
+
+    let wob_mul = o.wob_mul.unwrap_or(1.0);
+    let wob_amp = 0.23 * wob_mul;
+    let base_r = if face_on {
+        r / (1.0 + 0.85 * wob_amp)
+    } else {
+        r
+    };
+
+    let base_lanes = o.lanes.unwrap_or(5.0).clamp(1.0, MAX_LANES);
+    let segs = count_usize(o.segs, 88.0, 1, MAX_SEGS as usize);
+    let lanes = (base_lanes * o.band_mul.unwrap_or(1.0))
+        .round()
+        .clamp(1.0, MAX_LANES) as usize;
+    let r_base = o.r_base.unwrap_or(1.1);
+    let r_depth = o.r_depth.unwrap_or(1.7);
+    let seg_step = 2.0 * PI / segs as f32;
+    let half = (lanes as f32 - 1.0) / 2.0;
+    let inv_half = 1.0 / half.max(1.0);
+    dots.reserve(lanes.saturating_mul(segs));
+
+    for w in 0..lanes {
+        let centered = w as f32 - half;
+        let lane_off = centered * 0.075;
+        let edge = centered.abs() * inv_half;
+        let edge_r = 1.0 - 0.25 * edge;
+        let edge_ink = 0.18 * edge;
+        for k in 0..segs {
+            let a = k as f32 * seg_step;
+            let (ca, sa) = (a.cos(), a.sin());
+            let breath = if face_on {
+                0.72 + 0.28 * (t * 0.48).sin()
+            } else {
+                1.0
+            };
+            let wob = (0.16 * (a * 3.0 - t * 1.7 + w as f32 * 0.22).sin()
+                + 0.07 * (a * 5.0 + t * 1.1).sin())
+                * wob_mul
+                * breath;
+            let radial = if face_on { 1.0 + wob } else { 1.0 };
+            let off = if face_on { lane_off } else { lane_off + wob };
+            let x = ux * ca + vx * sa + nx * off;
+            let y = uy * ca + vy * sa + ny * off;
+            let z = uz * ca + vz * sa + nz * off;
+            let l = (x * x + y * y + z * z).sqrt();
+            let inv_l = if l > 1e-6 { 1.0 / l } else { 0.0 };
+            let rr = base_r * radial * inv_l;
+            let (px, py, zr) = pt.project(x * rr, y * rr, z * rr);
+            let depth = (zr * inv_r + 1.0) / 2.0;
+            dots.push(
+                Dot::new(
+                    px,
+                    py,
+                    zr,
+                    (r_base + r_depth * depth) * edge_r * rs,
+                    0.52 - 0.44 * depth + edge_ink,
+                )
+                .with_a(0.4 + 0.6 * depth),
+            );
+        }
+    }
+}
diff --git a/crates/orb/src/engine/web.rs b/crates/orb/src/engine/web.rs
new file mode 100644
index 0000000000..3b7ad3603c
--- /dev/null
+++ b/crates/orb/src/engine/web.rs
@@ -0,0 +1,120 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Web: a constellation wires itself — the "connecting" state.
+
+use crate::engine::{
+    core::{Dot, Frame, Line, frac, hash_d, lerp, make_proj, radius_scale, vnoise, with_fib_dirs},
+    profiles::{MAX_NODE_N, MAX_SIGNALS, ModeOpts, count_usize},
+};
+use std::cell::RefCell;
+
+thread_local! {
+    /// Reused between frames so the steady-state animation loop never
+    /// allocates. Holds `(unit_x, unit_y, unit_z, proj_x, proj_y, proj_z)`
+    /// per node: projecting once up front turns the O(n²) edge scan from
+    /// ~2n² projections into n.
+    static NODES: RefCell<Vec<[f32; 6]>> = const { RefCell::new(Vec::new()) };
+    static EDGES: RefCell<Vec<(usize, usize)>> = const { RefCell::new(Vec::new()) };
+}
+
+pub fn draw_web_into(size: f32, t: f32, o: &ModeOpts, out: &mut Frame) {
+    let cx = size / 2.0;
+    let cy = size / 2.0;
+    let r = (size / 2.0) * 0.8 * o.spread.unwrap_or(1.0);
+    let pt = make_proj(t * 0.12, 0.32, cx, cy, r);
+    let rs = radius_scale(size, o.rs_pow.unwrap_or(0.6));
+
+    let node_n = count_usize(o.node_n, 30.0, 0, MAX_NODE_N as usize);
+    let thr = o.thr.unwrap_or(0.72);
+    let node_r = o.node_r.unwrap_or(1.4);
+    let node_r_depth = o.node_r_depth.unwrap_or(1.8);
+    let line_w = (o.line_w.unwrap_or(0.8) * rs).max(0.6);
+    let inv_thr = if thr > 0.0 { 1.0 / thr } else { 0.0 };
+
+    NODES.with(|cell| {
+        EDGES.with(|edges_cell| {
+            let mut nodes = cell.borrow_mut();
+            let mut edges = edges_cell.borrow_mut();
+            nodes.clear();
+            edges.clear();
+            nodes.reserve(node_n);
+
+            with_fib_dirs(node_n, |directions| {
+                for (i, d) in directions.iter().enumerate() {
+                    let i_f = i as f32;
+                    let x = d[0] + 0.3 * (vnoise(i_f * 0.31 + 9.0, t * 0.24) - 0.5) * 2.0;
+                    let y = d[1] + 0.3 * (vnoise(i_f * 0.53 + 27.0, t * 0.21) - 0.5) * 2.0;
+                    let z = d[2] + 0.3 * (vnoise(i_f * 0.77 + 55.0, t * 0.27) - 0.5) * 2.0;
+                    let l = (x * x + y * y + z * z).sqrt();
+                    let inv_l = if l > 1e-6 { 1.0 / l } else { 0.0 };
+                    let (ux, uy, uz) = (x * inv_l, y * inv_l, z * inv_l);
+                    let (px, py, pz) = pt.project(ux, uy, uz);
+                    nodes.push([ux, uy, uz, px, py, pz]);
+                }
+            });
+
+            for i in 0..node_n {
+                let a = nodes[i];
+                for j in (i + 1)..node_n {
+                    let b = nodes[j];
+                    let dx = a[0] - b[0];
+                    let dy = a[1] - b[1];
+                    let dz = a[2] - b[2];
+                    let d2 = dx * dx + dy * dy + dz * dz;
+                    // Compare squared distances — avoids a sqrt for every
+                    // rejected pair, and most pairs are rejected.
+                    if d2 >= thr * thr {
+                        continue;
+                    }
+                    let dist = d2.sqrt();
+                    let depth = ((a[5] + b[5]) / 2.0 + 1.0) / 2.0;
+                    out.lines.push(Line {
+                        x1: a[3],
+                        y1: a[4],
+                        x2: b[3],
+                        y2: b[4],
+                        white: 0.42,
+                        a: (1.0 - dist * inv_thr) * (0.3 + 0.55 * depth),
+                        w: line_w,
+                    });
+                    edges.push((i, j));
+                }
+            }
+
+            for (i, n) in nodes.iter().enumerate() {
+                let depth = (n[5] + 1.0) / 2.0;
+                let pulse = 1.0 + 0.25 * (t * 1.4 + i as f32 * 2.7).sin();
+                out.dots.push(Dot::new(
+                    n[3],
+                    n[4],
+                    n[5],
+                    (node_r + node_r_depth * depth) * pulse * rs,
+                    0.55 - 0.45 * depth,
+                ));
+            }
+
+            let signals = count_usize(o.signals, 5.0, 0, MAX_SIGNALS as usize);
+            for s in 0..signals {
+                if edges.is_empty() {
+                    break;
+                }
+                let s_f = s as f32;
+                let journey = t * 0.48 + s_f * 3.73;
+                let cycle = journey.floor();
+                let edge_index = (hash_d(cycle, s_f * 4.7 + 1.3) * edges.len() as f32)
+                    .floor()
+                    .min((edges.len() - 1) as f32) as usize;
+                let (a, b) = edges[edge_index];
+                let f = frac(journey);
+                let px = lerp(nodes[a][3], nodes[b][3], f);
+                let py = lerp(nodes[a][4], nodes[b][4], f);
+                let zr = lerp(nodes[a][5], nodes[b][5], f);
+                let depth = (zr + 1.0) / 2.0;
+                let life = (std::f32::consts::PI * f).sin().max(0.0);
+                out.dots.push(
+                    Dot::new(px, py, zr, (node_r * 1.5 + node_r_depth * depth) * rs, 0.05)
+                        .with_a(life * (0.5 + 0.5 * depth)),
+                );
+            }
+        });
+    });
+}
diff --git a/crates/orb/src/lib.rs b/crates/orb/src/lib.rs
new file mode 100644
index 0000000000..0c91ab0eb3
--- /dev/null
+++ b/crates/orb/src/lib.rs
@@ -0,0 +1,23 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Thinking orbs — dotted loading indicators for AI & agent UIs, ported from
+//! gpui-thinking-orbs (MIT), itself a port of Jakub Antalik's thinking-orbs.
+//!
+//! Twelve hand-tuned animated states and four size presets, emitted as
+//! monochrome geometry ([`engine::Frame`]). Nothing here paints: the desktop
+//! widget renders frames through GPUI and the mobile apps through their native
+//! 2-D APIs, so every platform shows the same artwork.
+
+mod animator;
+mod motion;
+mod presets;
+mod types;
+
+pub mod engine;
+
+pub use animator::{OrbAnimator, crossfade};
+pub use motion::{AnimationClock, AudioResponse};
+pub use presets::{Resolved, resolve_preset};
+pub use types::{ModeKey, OrbSize, OrbState, OrbTheme};
+
+/// Reduced motion freezes every orb on this representative frame.
+pub const REDUCED_MOTION_T: f32 = 0.6;
diff --git a/crates/orb/src/motion.rs b/crates/orb/src/motion.rs
new file mode 100644
index 0000000000..f044f1d905
--- /dev/null
+++ b/crates/orb/src/motion.rs
@@ -0,0 +1,158 @@
+//! Continuous animation time and bounded, independent audio envelopes.
+use std::time::Instant;
+
+#[derive(Default)]
+pub struct AnimationClock {
+    pub seconds: f64,
+    pub active_seconds: f64,
+    last: Option<Instant>,
+    rate: f64,
+    running: bool,
+}
+
+impl AnimationClock {
+    pub fn advance(&mut self, now: Instant, rate: f64, running: bool) {
+        if let Some(last) = self.last {
+            if self.running {
+                let dt = now.saturating_duration_since(last).as_secs_f64();
+                self.seconds += dt * self.rate;
+                self.active_seconds += dt;
+            }
+        }
+        self.last = Some(now);
+        self.rate = rate;
+        self.running = running;
+    }
+
+    pub fn stop(&mut self, now: Instant) {
+        self.advance(now, self.rate, false);
+    }
+
+    pub fn is_running(&self) -> bool {
+        self.running
+    }
+}
+
+struct Envelope {
+    origin: f32,
+    target: f32,
+    changed: Instant,
+}
+
+impl Envelope {
+    fn new(now: Instant) -> Self {
+        Self {
+            origin: 0.0,
+            target: 0.0,
+            changed: now,
+        }
+    }
+
+    fn value(&self, now: Instant) -> f32 {
+        let tau = if self.target > self.origin {
+            0.080
+        } else {
+            0.300
+        };
+        let dt = now.saturating_duration_since(self.changed).as_secs_f32();
+        self.target + (self.origin - self.target) * (-dt / tau).exp()
+    }
+
+    fn set(&mut self, peak: f32, now: Instant) -> bool {
+        // Ignore quiet background noise; compress peaks without exceeding 1.
+        let peak = if peak.is_finite() {
+            peak.clamp(0.0, 1.0)
+        } else {
+            0.0
+        };
+        let x = ((peak - 0.015) / 0.985).max(0.0);
+        let target = 1.2 * x / (x + 0.2);
+        if self.target == target {
+            return false;
+        }
+        self.origin = self.value(now);
+        self.target = target;
+        self.changed = now;
+        true
+    }
+}
+
+pub struct AudioResponse {
+    microphone: Envelope,
+    speaker: Envelope,
+}
+
+impl AudioResponse {
+    pub fn new(now: Instant) -> Self {
+        Self {
+            microphone: Envelope::new(now),
+            speaker: Envelope::new(now),
+        }
+    }
+
+    pub fn set(&mut self, microphone: f32, speaker: f32, now: Instant) -> bool {
+        let mic_changed = self.microphone.set(microphone, now);
+        let speaker_changed = self.speaker.set(speaker, now);
+        mic_changed || speaker_changed
+    }
+
+    pub fn speed(&self, now: Instant) -> f64 {
+        let mic = self.microphone.value(now);
+        let speaker = self.speaker.value(now);
+        // A bounded, continuous combination, even when both sides overlap.
+        1.0 + f64::from((1.0 - (1.0 - mic) * (1.0 - speaker)).clamp(0.0, 1.0)) * 0.3
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    #[test]
+    fn changing_speed_after_long_uptime_preserves_position() {
+        let now = Instant::now();
+        let mut clock = AnimationClock::default();
+        clock.advance(now, 1.0, true);
+        let later = now + Duration::from_secs(3600);
+        clock.advance(later, 2.0, true);
+        assert_eq!(clock.seconds, 3600.0);
+        clock.advance(later + Duration::from_millis(100), 2.0, true);
+        assert!((clock.seconds - 3600.2).abs() < 1e-8);
+    }
+
+    #[test]
+    fn hidden_and_paused_time_does_not_advance_animation() {
+        let now = Instant::now();
+        let mut clock = AnimationClock::default();
+        clock.advance(now, 2.0, true);
+        clock.stop(now + Duration::from_secs(1));
+        clock.advance(now + Duration::from_secs(60), 3.0, true);
+        assert_eq!(clock.seconds, 2.0);
+        clock.advance(now + Duration::from_secs(61), 3.0, true);
+        assert_eq!(clock.seconds, 5.0);
+        assert_eq!(clock.active_seconds, 2.0);
+    }
+
+    #[test]
+    fn audio_ignores_noise_and_smooths_attack_release_and_channel_overlap() {
+        let now = Instant::now();
+        let mut audio = AudioResponse::new(now);
+        audio.set(0.01, f32::NAN, now);
+        assert_eq!(audio.speed(now + Duration::from_secs(1)), 1.0);
+        audio.set(1.0, 0.0, now);
+        assert_eq!(audio.speed(now), 1.0);
+        let attack = now + Duration::from_millis(80);
+        assert!((1.15..1.25).contains(&audio.speed(attack)));
+        let before = audio.speed(attack);
+        audio.set(0.0, 1.0, attack);
+        assert_eq!(audio.speed(attack), before);
+        for ms in 80..1000 {
+            assert!((1.0..=1.300001).contains(&audio.speed(now + Duration::from_millis(ms))));
+        }
+        let quiet = now + Duration::from_secs(1);
+        audio.set(0.0, 0.0, quiet);
+        assert!(audio.speed(quiet + Duration::from_millis(300)) > 1.05);
+        assert!(audio.speed(quiet + Duration::from_secs(3)) < 1.001);
+    }
+}
diff --git a/crates/orb/src/presets.rs b/crates/orb/src/presets.rs
new file mode 100644
index 0000000000..7fa5f6f9db
--- /dev/null
+++ b/crates/orb/src/presets.rs
@@ -0,0 +1,354 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Twelve states × four sizes — original ports plus library-native concepts.
+
+use crate::{
+    engine::{ModeOpts, base_profile, scale_counts, scale_radii},
+    types::{ModeKey, OrbSize, OrbState},
+};
+
+/// Fully resolved draw options for a (state, size) pair.
+#[derive(Clone, Debug)]
+pub struct Resolved {
+    pub mode: ModeKey,
+    pub speed: f32,
+    pub opts: ModeOpts,
+}
+
+struct Preset {
+    speed: f32,
+    count: f32,
+    size: f32,
+    // extra knobs merged after scaling
+    scan_mul: Option<f32>,
+    dim_base: Option<f32>,
+    spin: Option<f32>,
+    band_mul: Option<f32>,
+    wob_mul: Option<f32>,
+    spread: Option<f32>,
+}
+
+fn preset_for(mode: ModeKey, size: OrbSize) -> Preset {
+    use ModeKey::*;
+
+    // The large designs preserve each avatar preset's character while adding
+    // detail gradually. `scale_counts` understands each painter's topology
+    // (2-D lattices, flat lists, lane/segment pairs), so this is deliberately
+    // not a naive coordinate scale.
+    if matches!(size, OrbSize::Large | OrbSize::Hero) {
+        let mut preset = preset_for(mode, OrbSize::Avatar);
+        let (count, radius, speed) = match size {
+            OrbSize::Large => (1.15, 1.05, 0.95),
+            OrbSize::Hero => (1.30, 1.10, 0.90),
+            _ => unreachable!(),
+        };
+        preset.count *= count;
+        preset.size *= radius;
+        preset.speed *= speed;
+        return preset;
+    }
+
+    match (mode, size) {
+        (Orbits, OrbSize::Avatar) => Preset {
+            speed: 1.885,
+            count: 1.0,
+            size: 1.0,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Orbits, OrbSize::Inline) => Preset {
+            speed: 3.9,
+            count: 0.238,
+            size: 2.4,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Globe, OrbSize::Avatar) => Preset {
+            speed: 2.015,
+            count: 0.42,
+            size: 1.15,
+            scan_mul: Some(4.08),
+            dim_base: Some(0.45),
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Globe, OrbSize::Inline) => Preset {
+            speed: 2.665,
+            count: 0.105,
+            size: 1.75,
+            scan_mul: Some(4.335),
+            dim_base: Some(0.45),
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Rubik, OrbSize::Avatar) => Preset {
+            speed: 1.82,
+            count: 0.35,
+            size: 1.05,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Rubik, OrbSize::Inline) => Preset {
+            speed: 1.95,
+            count: 0.088,
+            size: 1.9,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Wave, OrbSize::Avatar) => Preset {
+            speed: 3.15,
+            count: 0.341,
+            size: 1.0,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Wave, OrbSize::Inline) => Preset {
+            speed: 3.35,
+            count: 0.105,
+            size: 1.6,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Web, OrbSize::Avatar) => Preset {
+            speed: 3.315,
+            count: 1.35,
+            size: 0.95,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Web, OrbSize::Inline) => Preset {
+            speed: 6.63,
+            count: 0.25,
+            size: 1.52,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Braid, OrbSize::Avatar) => Preset {
+            speed: 1.625,
+            count: 0.5,
+            size: 1.0,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Braid, OrbSize::Inline) => Preset {
+            speed: 2.75,
+            count: 0.1125,
+            size: 1.36,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: None,
+        },
+        (Ribbon, OrbSize::Avatar) => Preset {
+            speed: 1.95,
+            count: 0.25,
+            size: 0.85,
+            scan_mul: None,
+            dim_base: None,
+            spin: Some(0.0),
+            band_mul: Some(2.9),
+            wob_mul: Some(1.0),
+            spread: None,
+        },
+        (Ribbon, OrbSize::Inline) => Preset {
+            speed: 2.5,
+            count: 0.051,
+            size: 1.073,
+            scan_mul: None,
+            dim_base: None,
+            spin: Some(0.0),
+            band_mul: Some(3.6),
+            wob_mul: Some(1.0),
+            spread: None,
+        },
+        (Ring, OrbSize::Avatar) => Preset {
+            speed: 1.55,
+            count: 0.25,
+            size: 0.956,
+            scan_mul: None,
+            dim_base: None,
+            spin: Some(0.0),
+            band_mul: Some(2.8),
+            wob_mul: Some(0.368),
+            spread: None,
+        },
+        (Ring, OrbSize::Inline) => Preset {
+            speed: 2.1,
+            count: 0.028,
+            size: 1.622,
+            scan_mul: None,
+            dim_base: None,
+            spin: Some(0.0),
+            band_mul: Some(3.2),
+            wob_mul: Some(0.565),
+            spread: None,
+        },
+        (Morph, OrbSize::Avatar) => Preset {
+            speed: 2.405,
+            count: 0.702,
+            size: 0.395,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.45),
+        },
+        (Morph, OrbSize::Inline) => Preset {
+            speed: 2.08,
+            count: 0.53,
+            size: 1.011,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.45),
+        },
+        (Focus, OrbSize::Avatar) => Preset {
+            speed: 1.72,
+            count: 1.0,
+            size: 1.0,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.0),
+        },
+        (Focus, OrbSize::Inline) => Preset {
+            speed: 2.2,
+            count: 0.22,
+            size: 1.45,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.0),
+        },
+        (Gyroscope, OrbSize::Avatar) => Preset {
+            speed: 1.48,
+            count: 1.0,
+            size: 1.0,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.0),
+        },
+        (Gyroscope, OrbSize::Inline) => Preset {
+            speed: 2.05,
+            count: 0.25,
+            size: 1.55,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.0),
+        },
+        (Echo, OrbSize::Avatar) => Preset {
+            speed: 1.85,
+            count: 1.0,
+            size: 1.0,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.0),
+        },
+        (Echo, OrbSize::Inline) => Preset {
+            speed: 2.45,
+            count: 0.25,
+            size: 1.55,
+            scan_mul: None,
+            dim_base: None,
+            spin: None,
+            band_mul: None,
+            wob_mul: None,
+            spread: Some(1.0),
+        },
+        (_, OrbSize::Large | OrbSize::Hero) => unreachable!(),
+    }
+}
+
+/// Resolve a (state, size) pair to its mode + fully-scaled draw options.
+pub fn resolve_preset(state: OrbState, size: OrbSize) -> Resolved {
+    let mode = ModeKey::from_state(state);
+    let preset = preset_for(mode, size);
+    let mut opts = base_profile(mode);
+    if (preset.count - 1.0).abs() > f32::EPSILON {
+        opts = scale_counts(&opts, preset.count);
+    }
+    if (preset.size - 1.0).abs() > f32::EPSILON {
+        opts = scale_radii(&opts, preset.size);
+    }
+    if let Some(v) = preset.scan_mul {
+        opts.scan_mul = Some(v);
+    }
+    if let Some(v) = preset.dim_base {
+        opts.dim_base = Some(v);
+    }
+    if let Some(v) = preset.spin {
+        opts.spin = Some(v);
+    }
+    if let Some(v) = preset.band_mul {
+        opts.band_mul = Some(v);
+    }
+    if let Some(v) = preset.wob_mul {
+        opts.wob_mul = Some(v);
+    }
+    if let Some(v) = preset.spread {
+        opts.spread = Some(v);
+    }
+
+    Resolved {
+        mode,
+        speed: preset.speed,
+        opts,
+    }
+}
diff --git a/crates/orb/src/types.rs b/crates/orb/src/types.rs
new file mode 100644
index 0000000000..3a88b54cc8
--- /dev/null
+++ b/crates/orb/src/types.rs
@@ -0,0 +1,217 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Public types shared by the animation engine and the GPUI widget.
+
+/// The twelve shipped states — each a hand-tuned animation.
+///
+/// Marked `#[non_exhaustive]`: matching on this from another crate needs a
+/// wildcard arm, so shipping a tenth state is not a breaking change. Prefer
+/// [`OrbState::label`] / [`OrbState::as_str`] over matching where you can.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+pub enum OrbState {
+    /// Particles on tilted orbits.
+    #[default]
+    Working,
+    /// A scan meridian sweeps a dotted globe.
+    Searching,
+    /// Bands scramble in quarter turns, then click back.
+    Solving,
+    /// A waveform rolls through latitude rings.
+    Listening,
+    /// A constellation wires itself, packets running the edges.
+    Connecting,
+    /// Three strands plait around the sphere.
+    Weaving,
+    /// An undulating multi-band sash.
+    Composing,
+    /// A face-on ring slowly morphing.
+    Breathing,
+    /// A dotted outline morphs circle → triangle → square.
+    Shaping,
+    /// An iris of particles converges and relaxes around a focal point.
+    Focusing,
+    /// Counter-rotating great circles form a reasoning gyroscope.
+    Reasoning,
+    /// Concentric memory echoes travel out from a steady core.
+    Recalling,
+}
+
+impl OrbState {
+    /// All states in playground / gallery order.
+    ///
+    /// This is a slice so adding future states does not change its public type.
+    pub const ALL_STATES: &'static [OrbState] = &[
+        OrbState::Working,
+        OrbState::Searching,
+        OrbState::Solving,
+        OrbState::Listening,
+        OrbState::Connecting,
+        OrbState::Weaving,
+        OrbState::Composing,
+        OrbState::Breathing,
+        OrbState::Shaping,
+        OrbState::Focusing,
+        OrbState::Reasoning,
+        OrbState::Recalling,
+    ];
+
+    /// The original nine-state gallery.
+    ///
+    /// Kept at its original array type for source compatibility. New code
+    /// should iterate [`Self::ALL_STATES`].
+    #[deprecated(since = "0.2.0", note = "use OrbState::ALL_STATES")]
+    pub const ALL: [OrbState; 9] = [
+        OrbState::Working,
+        OrbState::Searching,
+        OrbState::Solving,
+        OrbState::Listening,
+        OrbState::Connecting,
+        OrbState::Weaving,
+        OrbState::Composing,
+        OrbState::Breathing,
+        OrbState::Shaping,
+    ];
+
+    /// Human-readable status label (matches upstream aria defaults).
+    pub fn label(self) -> &'static str {
+        match self {
+            OrbState::Working => "Working…",
+            OrbState::Searching => "Searching…",
+            OrbState::Solving => "Solving…",
+            OrbState::Listening => "Listening…",
+            OrbState::Connecting => "Connecting…",
+            OrbState::Weaving => "Weaving…",
+            OrbState::Composing => "Composing…",
+            OrbState::Breathing => "Thinking…",
+            OrbState::Shaping => "Shaping…",
+            OrbState::Focusing => "Focusing…",
+            OrbState::Reasoning => "Reasoning…",
+            OrbState::Recalling => "Recalling…",
+        }
+    }
+
+    /// Stable snake_case name (matches the web package `state` prop).
+    pub fn as_str(self) -> &'static str {
+        match self {
+            OrbState::Working => "working",
+            OrbState::Searching => "searching",
+            OrbState::Solving => "solving",
+            OrbState::Listening => "listening",
+            OrbState::Connecting => "connecting",
+            OrbState::Weaving => "weaving",
+            OrbState::Composing => "composing",
+            OrbState::Breathing => "breathing",
+            OrbState::Shaping => "shaping",
+            OrbState::Focusing => "focusing",
+            OrbState::Reasoning => "reasoning",
+            OrbState::Recalling => "recalling",
+        }
+    }
+}
+
+/// Rendered size in logical pixels. Four tuned presets ship: inline (20),
+/// avatar (64), large (96), and hero (128). Larger sizes add detail gradually
+/// instead of merely stretching the 64 px artwork.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+pub enum OrbSize {
+    /// Chat-avatar scale (64 logical px).
+    #[default]
+    Avatar,
+    /// Inline-text scale (20 logical px).
+    Inline,
+    /// Prominent status / card scale (96 logical px).
+    Large,
+    /// Hero / empty-state scale (128 logical px).
+    Hero,
+}
+
+impl OrbSize {
+    /// All sizes in compact-to-prominent gallery order.
+    pub const ALL_SIZES: &'static [OrbSize] = &[
+        OrbSize::Inline,
+        OrbSize::Avatar,
+        OrbSize::Large,
+        OrbSize::Hero,
+    ];
+
+    /// Logical pixel edge length of the orb.
+    pub fn pixels(self) -> f32 {
+        match self {
+            OrbSize::Inline => 20.0,
+            OrbSize::Avatar => 64.0,
+            OrbSize::Large => 96.0,
+            OrbSize::Hero => 128.0,
+        }
+    }
+
+    /// Stable lowercase name for controls and command-line arguments.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            OrbSize::Inline => "inline",
+            OrbSize::Avatar => "avatar",
+            OrbSize::Large => "large",
+            OrbSize::Hero => "hero",
+        }
+    }
+
+    /// Compact playground label.
+    pub fn label(self) -> &'static str {
+        match self {
+            OrbSize::Inline => "20 · inline",
+            OrbSize::Avatar => "64 · avatar",
+            OrbSize::Large => "96 · large",
+            OrbSize::Hero => "128 · hero",
+        }
+    }
+}
+
+/// Theme mode for monochrome ink on transparent canvas.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+pub enum OrbTheme {
+    /// Resolve from the window appearance (GPUI `WindowAppearance`).
+    #[default]
+    Auto,
+    /// Light ink for dark backgrounds.
+    Dark,
+    /// Dark ink for light backgrounds.
+    Light,
+}
+
+/// Internal mode keys — one painter per key. Grows in lockstep with
+/// [`OrbState`], hence `#[non_exhaustive]`.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ModeKey {
+    Orbits,
+    Globe,
+    Rubik,
+    Wave,
+    Web,
+    Braid,
+    Ribbon,
+    Ring,
+    Morph,
+    Focus,
+    Gyroscope,
+    Echo,
+}
+
+impl ModeKey {
+    pub fn from_state(state: OrbState) -> Self {
+        match state {
+            OrbState::Working => ModeKey::Orbits,
+            OrbState::Searching => ModeKey::Globe,
+            OrbState::Solving => ModeKey::Rubik,
+            OrbState::Listening => ModeKey::Wave,
+            OrbState::Connecting => ModeKey::Web,
+            OrbState::Weaving => ModeKey::Braid,
+            OrbState::Composing => ModeKey::Ribbon,
+            OrbState::Breathing => ModeKey::Ring,
+            OrbState::Shaping => ModeKey::Morph,
+            OrbState::Focusing => ModeKey::Focus,
+            OrbState::Reasoning => ModeKey::Gyroscope,
+            OrbState::Recalling => ModeKey::Echo,
+        }
+    }
+}
diff --git a/crates/proto/src/entities.rs b/crates/proto/src/entities.rs
index 1226139b07..7b93cf08d4 100644
--- a/crates/proto/src/entities.rs
+++ b/crates/proto/src/entities.rs
@@ -243,6 +243,12 @@ pub struct Chat {
 }
 
 impl Chat {
+    /// A session the user sees in chat lists: neither another chat's worker
+    /// (`parent_chat_id`) nor a hidden voice orchestrator.
+    pub fn is_top_level(&self) -> bool {
+        self.parent_chat_id.is_none() && !crate::voice::is_orchestrator_chat(&self.id)
+    }
+
     /// True when this chat syncs over the chat2 dumb relay.
     pub fn on_chat2(&self) -> bool {
         self.room_gen.unwrap_or(1) >= 2
diff --git a/crates/proto/src/lib.rs b/crates/proto/src/lib.rs
index b351940101..f1e02af319 100644
--- a/crates/proto/src/lib.rs
+++ b/crates/proto/src/lib.rs
@@ -12,6 +12,7 @@ pub mod motion;
 pub mod preview;
 pub mod sidebar_pins;
 pub mod view;
+pub mod voice;
 pub mod workspace;
 
 pub use agent::*;
diff --git a/crates/proto/src/voice.rs b/crates/proto/src/voice.rs
new file mode 100644
index 0000000000..8fac73f6ea
--- /dev/null
+++ b/crates/proto/src/voice.rs
@@ -0,0 +1,260 @@
+//! Ephemeral local voice contracts. These must never enter the document journal.
+use serde::{Deserialize, Serialize};
+pub mod remote;
+
+pub const MAX_AUDIO_BYTES: usize = 16_384;
+pub const MEDIA_QUEUE_FRAMES: usize = 8;
+pub const MAX_TRANSCRIPT_BYTES: usize = 32_768;
+
+/// Id prefix of the hidden chat that hosts a voice orchestrator session. It
+/// never takes a sidebar row, and chats it creates are top-level sessions
+/// rather than its side chats.
+pub const ORCHESTRATOR_CHAT_PREFIX: &str = "voice-orchestrator-";
+/// Title of every orchestrator chat; transcripts never trigger a titler.
+pub const ORCHESTRATOR_CHAT_TITLE: &str = "Voice session";
+/// Codex voice styles offered before a host reports its own list.
+pub const DEFAULT_VOICES: &[&str] = &[
+    "juniper", "maple", "spruce", "ember", "vale", "breeze", "arbor", "sol", "cove",
+];
+
+pub fn is_orchestrator_chat(chat_id: &str) -> bool {
+    chat_id.starts_with(ORCHESTRATOR_CHAT_PREFIX)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum VoiceRejection {
+    Disabled,
+    Unsupported,
+    RemoteHost,
+    WrongHarness,
+    ChatgptRequired,
+    IncludedUsageUnavailable,
+    CreditExclusionUnverified,
+    AudioFormatUnverified,
+    DuplexUnverified,
+    Busy,
+    InvalidLease,
+    StaleGeneration,
+    Overflow,
+    DeviceUnavailable,
+    MicrophonePermissionDenied,
+    MicrophoneMetadataMissing,
+    Protocol,
+    NativeRuntimeUnavailable,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VoiceEligibility {
+    pub available: bool,
+    #[serde(default)]
+    pub reason: Option<VoiceRejection>,
+    /// Provider-reported permission; None is unknown, never permission.
+    #[serde(default)]
+    pub ordinary_usage_allowed: Option<bool>,
+    pub credits_excluded: bool,
+    #[serde(default)]
+    pub format: Option<VoiceFormat>,
+    #[serde(default)]
+    pub duplex_verified: bool,
+    /// Native subscription WebRTC transport; PCM never leaves the voice helper.
+    #[serde(default)]
+    pub native_webrtc: bool,
+    #[serde(default)]
+    pub voices: Vec<String>,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum VoicePhase {
+    #[default]
+    Closed,
+    Checking,
+    Starting,
+    Active,
+    Stopping,
+    Failed,
+}
+impl VoicePhase {
+    pub fn replaces_composer(self) -> bool {
+        matches!(self, Self::Starting | Self::Active | Self::Stopping)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum VoiceWork {
+    #[default]
+    Idle,
+    Working,
+    AwaitingInput,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VoiceSnapshot {
+    pub session_id: String,
+    pub chat_id: String,
+    pub generation: u64,
+    pub phase: VoicePhase,
+    pub muted: bool,
+    pub playing: bool,
+    pub work: VoiceWork,
+    #[serde(default)]
+    pub reason: Option<VoiceRejection>,
+    #[serde(default)]
+    pub voice: Option<String>,
+    #[serde(default)]
+    pub voices: Vec<String>,
+}
+
+/// Debug deliberately omits the bearer secret. Not a durable preference.
+#[derive(Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VoiceLease {
+    pub session_id: String,
+    pub generation: u64,
+    pub token: String,
+}
+impl std::fmt::Debug for VoiceLease {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VoiceLease")
+            .field("session_id", &self.session_id)
+            .field("generation", &self.generation)
+            .finish_non_exhaustive()
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum VoiceEncoding {
+    Pcm16Le,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VoiceFormat {
+    pub encoding: VoiceEncoding,
+    pub sample_rate: u32,
+    pub channels: u16,
+}
+impl VoiceFormat {
+    pub fn validate(&self, bytes: usize) -> bool {
+        self.sample_rate == 24_000
+            && self.channels == 1
+            && bytes > 0
+            && bytes <= MAX_AUDIO_BYTES
+            && bytes.is_multiple_of(2)
+    }
+}
+
+/// Base64 PCM. No Debug implementation: audio must never be logged implicitly.
+#[derive(Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VoiceFrame {
+    pub generation: u64,
+    pub sequence: u64,
+    pub format: VoiceFormat,
+    pub data: String,
+    #[serde(default)]
+    pub item_id: Option<String>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum VoiceRole {
+    User,
+    Assistant,
+}
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VoiceTranscript {
+    pub session_id: String,
+    pub item_id: String,
+    pub role: VoiceRole,
+    pub text: String,
+    #[serde(default)]
+    pub promoted_message_id: Option<String>,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum VoiceEvent {
+    Snapshot {
+        snapshot: VoiceSnapshot,
+    },
+    Audio {
+        frame: VoiceFrame,
+    },
+    Partial {
+        generation: u64,
+        #[serde(default)]
+        item_id: Option<String>,
+        text: String,
+    },
+    Final {
+        transcript: VoiceTranscript,
+    },
+    InvalidatePlayout {
+        generation: u64,
+        item_id: String,
+    },
+    Levels {
+        generation: u64,
+        microphone: u16,
+        speaker: u16,
+    },
+    Closed {
+        generation: u64,
+        reason: Option<VoiceRejection>,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn unknown_permission_is_not_authorization_and_secrets_are_not_debugged() {
+        let old = r#"{"available":false,"creditsExcluded":false}"#;
+        let eligibility: VoiceEligibility = serde_json::from_str(old).unwrap();
+        assert_eq!(eligibility.ordinary_usage_allowed, None);
+        let lease = VoiceLease {
+            session_id: "id".into(),
+            generation: 1,
+            token: "SECRET".into(),
+        };
+        assert!(!format!("{lease:?}").contains("SECRET"));
+        assert!(serde_json::from_str::<VoiceEncoding>("\"unknown\"").is_err());
+        for phase in [
+            VoicePhase::Starting,
+            VoicePhase::Active,
+            VoicePhase::Stopping,
+        ] {
+            assert!(phase.replaces_composer());
+        }
+        assert!(!VoicePhase::Checking.replaces_composer());
+    }
+
+    #[test]
+    fn orchestrator_chats_are_never_top_level_sessions() {
+        let mut chat: crate::Chat = serde_json::from_value(serde_json::json!({
+            "id": format!("{ORCHESTRATOR_CHAT_PREFIX}1"),
+            "deviceId": "device",
+            "title": null,
+            "archived": false,
+            "cwd": null,
+            "branch": null,
+            "checkoutId": null,
+            "config": null,
+            "lastMessagePreview": null,
+            "lastMessageAt": null,
+            "createdAt": "2026-10-01T00:00:00Z",
+        }))
+        .unwrap();
+        assert!(!chat.is_top_level());
+        chat.id = "ordinary".into();
+        assert!(chat.is_top_level());
+        chat.parent_chat_id = Some("parent".into());
+        assert!(!chat.is_top_level());
+    }
+}
diff --git a/crates/proto/src/voice/remote.rs b/crates/proto/src/voice/remote.rs
new file mode 100644
index 0000000000..9a9a675f3a
--- /dev/null
+++ b/crates/proto/src/voice/remote.rs
@@ -0,0 +1,188 @@
+//! Ephemeral client-media control. Never persist these payloads in sync/queues.
+use super::{VoiceLease, VoiceRejection};
+use serde::{Deserialize, Deserializer, Serialize};
+use std::fmt;
+
+pub const CAPABILITY: &str = "voice-client-media-v1";
+pub const MAX_SDP_BYTES: usize = 64 * 1024;
+pub const HEARTBEAT_SECS: u64 = 5;
+pub const LEASE_SECS: u64 = 15;
+pub const ATTEMPT_TTL_SECS: u64 = 300;
+pub const MAX_ATTEMPTS: usize = 256;
+
+/// Random capability, not a timestamp or a user-chosen label.
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+#[serde(transparent)]
+pub struct AttemptKey(String);
+impl AttemptKey {
+    pub fn new() -> Self {
+        Self(uuid::Uuid::new_v4().to_string())
+    }
+    pub fn expose(&self) -> &str {
+        &self.0
+    }
+}
+impl Default for AttemptKey {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl fmt::Debug for AttemptKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("AttemptKey([redacted])")
+    }
+}
+impl<'de> Deserialize<'de> for AttemptKey {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        let s = String::deserialize(d)?;
+        let id = uuid::Uuid::parse_str(&s)
+            .map_err(|_| serde::de::Error::custom("invalid attempt key"))?;
+        if id.get_version_num() != 4 {
+            return Err(serde::de::Error::custom(
+                "attempt key must be random UUID v4",
+            ));
+        }
+        Ok(Self(id.to_string()))
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Serialize)]
+#[serde(transparent)]
+pub struct Sdp(String);
+impl Sdp {
+    pub fn new(value: String) -> Result<Self, VoiceRejection> {
+        if value.is_empty() || value.len() > MAX_SDP_BYTES {
+            return Err(VoiceRejection::Protocol);
+        }
+        Ok(Self(value))
+    }
+    pub fn expose(&self) -> &str {
+        &self.0
+    }
+}
+impl fmt::Debug for Sdp {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Sdp([redacted])")
+    }
+}
+impl<'de> Deserialize<'de> for Sdp {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        Self::new(String::deserialize(d)?)
+            .map_err(|_| serde::de::Error::custom("invalid SDP length"))
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Envelope<T> {
+    pub target_device_id: String,
+    pub payload: T,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Lease {
+    pub host_device_id: String,
+    pub voice: VoiceLease,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Capabilities {
+    pub protocol: String,
+    pub client_webrtc: bool,
+    pub voices: Vec<String>,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Prepare {
+    pub attempt_key: AttemptKey,
+    pub config: crate::ChatConfig,
+    #[serde(default)]
+    pub voice: Option<String>,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Prepared {
+    pub lease: Lease,
+    pub chat_id: String,
+    pub voices: Vec<String>,
+    pub heartbeat_seconds: u64,
+    pub lease_seconds: u64,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Negotiate {
+    pub lease: Lease,
+    pub negotiation_id: AttemptKey,
+    pub offer: Sdp,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Negotiated {
+    pub negotiation_id: AttemptKey,
+    pub answer: Sdp,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Confirm {
+    pub lease: Lease,
+    pub negotiation_id: AttemptKey,
+    pub muted: bool,
+}
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub enum MediaState {
+    Ready,
+    Failed,
+    Closed,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Report {
+    pub lease: Lease,
+    pub sequence: u64,
+    pub muted: bool,
+    pub state: MediaState,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Ack {
+    pub sequence: u64,
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Cancel {
+    pub attempt_key: AttemptKey,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn bounded_redacted_signaling_and_attempts() {
+        assert!(Sdp::new("é".repeat(MAX_SDP_BYTES / 2 + 1)).is_err());
+        assert!(serde_json::from_str::<Sdp>("\"\"").is_err());
+        let s = Sdp::new("SECRET SDP".into()).unwrap();
+        assert!(!format!("{s:?}").contains("SECRET"));
+        let key = AttemptKey::new();
+        assert!(!format!("{key:?}").contains(key.expose()));
+        assert_eq!(
+            serde_json::from_str::<AttemptKey>(&serde_json::to_string(&key).unwrap()).unwrap(),
+            key
+        );
+        assert!(serde_json::from_str::<AttemptKey>("\"predictable\"").is_err());
+        assert!(
+            serde_json::from_str::<Cancel>(&format!(
+                r#"{{"attemptKey":"{}","extra":1}}"#,
+                key.expose()
+            ))
+            .is_err()
+        );
+    }
+    #[test]
+    fn routed_payload_stays_strict() {
+        let value =
+            serde_json::json!({"targetDeviceId":"host","payload":{"attemptKey":AttemptKey::new()}});
+        assert!(serde_json::from_value::<Envelope<Cancel>>(value.clone()).is_ok());
+        assert!(serde_json::from_value::<Cancel>(value).is_err());
+    }
+}
diff --git a/crates/proto/src/workspace.rs b/crates/proto/src/workspace.rs
index 6453abb741..c407888d1d 100644
--- a/crates/proto/src/workspace.rs
+++ b/crates/proto/src/workspace.rs
@@ -24,6 +24,7 @@ pub mod capabilities {
         MESSAGE_QUEUE_CLEAN_ATTACHMENT_TEXT_V1,
         MESSAGE_QUEUE_EDIT_LEASE_V1,
         HARNESS_UPDATES_V1,
+        crate::voice::remote::CAPABILITY,
     ];
 
     pub fn current() -> Vec<String> {
@@ -103,7 +104,8 @@ mod tests {
                     "message-queue-attachments-v1",
                     "message-queue-clean-attachment-text-v1",
                     "message-queue-edit-lease-v1",
-                    "harness-updates-v1"
+                    "harness-updates-v1",
+                    "voice-client-media-v1"
                 ],
             })
         );
diff --git a/crates/rpc/src/lib.rs b/crates/rpc/src/lib.rs
index c5d6d0e327..ec3bacfa63 100644
--- a/crates/rpc/src/lib.rs
+++ b/crates/rpc/src/lib.rs
@@ -33,6 +33,14 @@ pub use server::{serve_connection, serve_ws_listener};
 /// RPC method names — single source of truth for both ends.
 /// Full surface: docs/research/feature-inventory.md §2.
 pub mod methods {
+    pub const VOICE_CAPABILITIES_V2: &str = "VoiceCapabilitiesV2";
+    pub const PREPARE_VOICE_V2: &str = "PrepareVoiceV2";
+    pub const OWN_VOICE_V2: &str = "OwnVoiceV2";
+    pub const NEGOTIATE_VOICE_V2: &str = "NegotiateVoiceV2";
+    pub const CONFIRM_VOICE_MEDIA_V2: &str = "ConfirmVoiceMediaV2";
+    pub const REPORT_VOICE_MEDIA_V2: &str = "ReportVoiceMediaV2";
+    pub const STOP_VOICE_V2: &str = "StopVoiceV2";
+    pub const CANCEL_VOICE_ATTEMPT_V2: &str = "CancelVoiceAttemptV2";
     pub const WATCH_PREVIEWS: &str = "WatchPreviews";
     pub const LIST_HARNESSES: &str = "ListHarnesses";
     pub const CANCEL_INSTALL: &str = "CancelInstall";
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index d03039263a..2f6d6abc86 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -6,6 +6,7 @@ license.workspace = true
 publish.workspace = true
 
 [features]
+voice-experimental = [] # Compatibility flag; native subscription voice uses Codex's packaged helper.
 project-palette-fixture = []
 compact-picker-fixture = ["gpui_platform/test-support"]
 
@@ -47,6 +48,10 @@ name = "compact-picker-fixture"
 required-features = ["compact-picker-fixture"]
 
 [dependencies]
+zeron-voice-media.workspace = true
+zeron-voice-session.workspace = true
+zeron-orb.workspace = true
+zeron-veil.workspace = true
 zeron-voice = { path = "../voice" }
 url = "2"
 zeron-proto.workspace = true
@@ -61,6 +66,7 @@ zeron-theme.workspace = true
 gpui.workspace = true
 gpui_platform.workspace = true
 gpui_tokio.workspace = true
+tokio-util.workspace = true
 gpui-base.workspace = true
 tokio.workspace = true
 futures.workspace = true
diff --git a/crates/ui/assets/icons/microphone-off.svg b/crates/ui/assets/icons/microphone-off.svg
new file mode 100644
index 0000000000..d3ed06752f
--- /dev/null
+++ b/crates/ui/assets/icons/microphone-off.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><path d="M15.5 10.5V5.75a3.5 3.5 0 0 0-6.66-1.5M8.5 9v2.25a3.5 3.5 0 0 0 5.6 2.8"/><path d="M5 11a7 7 0 0 0 11.3 5.52M19 11a6.97 6.97 0 0 1-.6 2.84M12 18v3.75M9 21.75h6M3 3l18 18"/></g></svg>
diff --git a/crates/ui/assets/icons/microphone.svg b/crates/ui/assets/icons/microphone.svg
index fb6b33de20..85068dfdf1 100644
--- a/crates/ui/assets/icons/microphone.svg
+++ b/crates/ui/assets/icons/microphone.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="8" y="2" width="8" height="13" rx="4"/><path d="M5 10v2a7 7 0 0 0 14 0v-2M12 19v3m-4 0h8"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="1.5"><rect width="7" height="12.5" x="8.5" y="2.25" rx="3.5"/><path stroke-linecap="round" d="M5 11a7 7 0 0 0 14 0M12 18v3.75M9 21.75h6"/></g></svg>
diff --git a/crates/ui/assets/icons/phone-hang-up.svg b/crates/ui/assets/icons/phone-hang-up.svg
new file mode 100644
index 0000000000..de2cf1aafe
--- /dev/null
+++ b/crates/ui/assets/icons/phone-hang-up.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linejoin="round" stroke-width="1.5" d="M2.6 13.8c5.2-5 13.6-5 18.8 0 .5.5.6 1.3.2 1.9l-1.3 1.9c-.4.6-1.2.8-1.9.6l-2.6-1c-.6-.2-1-.8-1-1.4v-1.9c-1.8-.6-3.8-.6-5.6 0v1.9c0 .6-.4 1.2-1 1.4l-2.6 1c-.7.2-1.5 0-1.9-.6l-1.3-1.9c-.4-.6-.3-1.4.2-1.9Z"/></svg>
diff --git a/crates/ui/assets/sounds/voice-end.wav b/crates/ui/assets/sounds/voice-end.wav
new file mode 100644
index 0000000000000000000000000000000000000000..d2be6c2b86eae843c72a099bda261dcee692eeff
GIT binary patch
literal 165164
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%0AbpTe%#epqIg2mJ#V6&UA+pi->FIm<u3h@#d`)j`
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
Nqx}D0^S|>5{2xr)hxh;h

literal 0
HcmV?d00001

diff --git a/crates/ui/assets/sounds/voice-start.wav b/crates/ui/assets/sounds/voice-start.wav
new file mode 100644
index 0000000000000000000000000000000000000000..866e5957be9429222b676fe499420dae33f987ae
GIT binary patch
literal 172844
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
WZ}lhozuV5Uzv2Hs<NwV&@V@|N;+NI{

literal 0
HcmV?d00001

diff --git a/crates/ui/src/dictation/model.rs b/crates/ui/src/dictation/model.rs
index 88a635116b..56f6e631f6 100644
--- a/crates/ui/src/dictation/model.rs
+++ b/crates/ui/src/dictation/model.rs
@@ -30,6 +30,14 @@ pub(crate) fn init(root: PathBuf, cx: &mut App) {
         error: None,
         inputs: Inputs::default(),
         input_select: widgets::SelectState::default(),
+        voice_select: widgets::SelectState::default(),
+        host_select: widgets::SelectState::default(),
+        hosts: Vec::new(),
+        call_live: false,
+        voices: zeron_proto::voice::DEFAULT_VOICES
+            .iter()
+            .map(|voice| (*voice).to_owned())
+            .collect(),
         shortcut: None,
     });
     cx.set_global(VoiceGlobal { card, directory });
@@ -60,6 +68,12 @@ pub(crate) struct VoiceCard {
     error: Option<String>,
     inputs: Inputs,
     input_select: widgets::SelectState,
+    voice_select: widgets::SelectState,
+    host_select: widgets::SelectState,
+    hosts: Vec<(Option<String>, String, bool, String)>,
+    call_live: bool,
+    /// Native voice styles, refreshed with the live session's reported catalog.
+    voices: Vec<String>,
     /// Created on first render (it needs this card's context).
     shortcut: Option<Entity<settings::shortcuts::ShortcutField>>,
 }
@@ -74,6 +88,26 @@ struct Inputs {
 }
 const INPUT_REFRESH: Duration = Duration::from_secs(3);
 impl VoiceCard {
+    pub(crate) fn set_hosts(
+        &mut self,
+        hosts: Vec<(Option<String>, String, bool, String)>,
+        live: bool,
+        cx: &mut Context<Self>,
+    ) {
+        if self.hosts != hosts || self.call_live != live {
+            self.hosts = hosts;
+            self.call_live = live;
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn set_voices(&mut self, voices: &[String], cx: &mut Context<Self>) {
+        if !voices.is_empty() && self.voices != voices {
+            self.voices = voices.to_vec();
+            cx.notify();
+        }
+    }
+
     fn set_enabled(&mut self, enabled: bool, cx: &mut Context<Self>) {
         settings::update(settings::SavePolicy::Immediate, cx, |s| {
             s.dictation_enabled = enabled
@@ -270,6 +304,125 @@ impl VoiceCard {
 impl Render for VoiceCard {
     fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let theme = Theme::of(cx).for_settings_surface();
+        let saved_voice = settings::current(cx).codex_voice;
+        let mut voice_ids: Vec<Option<String>> = std::iter::once(None)
+            .chain(self.voices.iter().cloned().map(Some))
+            .collect();
+        if saved_voice.is_some() && !voice_ids.contains(&saved_voice) {
+            voice_ids.push(saved_voice.clone());
+        }
+        let selected_voice = voice_ids
+            .iter()
+            .position(|v| *v == saved_voice)
+            .unwrap_or(0);
+        let voice_options: Vec<_> = voice_ids
+            .iter()
+            .map(|voice| {
+                let label = voice.as_deref().map_or_else(
+                    || "Codex default".to_owned(),
+                    |voice| {
+                        let mut chars = voice.chars();
+                        chars
+                            .next()
+                            .map(|first| first.to_uppercase().chain(chars).collect::<String>())
+                            .unwrap_or_default()
+                    },
+                );
+                widgets::SelectOption::new(label)
+            })
+            .collect();
+        let voice_control = widgets::select(
+            "voice-style",
+            "Codex voice style",
+            &theme,
+            |card: &mut Self| &mut card.voice_select,
+        )
+        .options(voice_options, selected_voice)
+        .width(200.0)
+        .on_select(move |_, ix, _, cx| {
+            let voice = voice_ids.get(ix).cloned().flatten();
+            settings::update(settings::SavePolicy::Immediate, cx, |s| {
+                s.codex_voice = voice
+            });
+            cx.refresh_windows();
+            cx.notify();
+        })
+        .render(&self.voice_select, cx);
+        let host_row = {
+            let selected = settings::current(cx).codex_voice_device;
+            let mut hosts = self.hosts.clone();
+            if selected.is_some() && !hosts.iter().any(|h| h.0 == selected) {
+                hosts.push((
+                    selected.clone(),
+                    "Unavailable device".into(),
+                    false,
+                    "Choose another device".into(),
+                ));
+            }
+            let index = hosts.iter().position(|h| h.0 == selected).unwrap_or(0);
+            let options = hosts
+                .iter()
+                .map(|h| widgets::SelectOption::new(h.1.clone()).detail(h.3.clone()))
+                .collect::<Vec<_>>();
+            let control = widgets::select(
+                "codex-voice-device",
+                "Codex voice device",
+                &theme,
+                |card: &mut Self| &mut card.host_select,
+            )
+            .options(options, index)
+            .width(200.0)
+            .on_select(move |card, ix, _, cx| {
+                if card.call_live {
+                    return;
+                }
+                if let Some((id, _, true, _)) = hosts.get(ix) {
+                    let id = id.clone();
+                    settings::update(settings::SavePolicy::Immediate, cx, |s| {
+                        s.codex_voice_device = id
+                    });
+                    cx.refresh_windows();
+                    cx.notify();
+                }
+            })
+            .render(&self.host_select, cx);
+            widgets::card_row(&theme, true)
+                .child(
+                    div()
+                        .flex_1()
+                        .flex()
+                        .flex_col()
+                        .child(widgets::row_title(&theme, "Codex voice device"))
+                        .child(widgets::meta_line(
+                            &theme,
+                            vec![
+                                if self.call_live {
+                                    "End the call to change devices"
+                                } else {
+                                    "Runs Codex; audio stays on this device"
+                                }
+                                .into_any_element(),
+                            ],
+                        )),
+                )
+                .child(control)
+        };
+        let conversation_card = widgets::section_card(&theme).child(host_row).child(
+            widgets::card_row(&theme, true)
+                .child(
+                    div()
+                        .flex_1()
+                        .min_w(px(160.0))
+                        .flex()
+                        .flex_col()
+                        .child(widgets::row_title(&theme, "Codex voice style"))
+                        .child(widgets::meta_line(
+                            &theme,
+                            vec!["Applies to your next voice session".into_any_element()],
+                        )),
+                )
+                .child(voice_control),
+        );
         let enabled = settings::current(cx).dictation_enabled;
         let downloading = self.cancel.is_some();
         let on = downloading || (enabled && self.ready);
@@ -475,10 +628,7 @@ impl Render for VoiceCard {
                         .child(
                             widgets::page_column()
                                 .child(widgets::page_header(&theme, "Voice", None))
-                                .child(widgets::page_subtitle(
-                                    &theme,
-                                    "Transcribed on this device. Audio is never saved.",
-                                ))
+                                .child(conversation_card)
                                 .child(
                                     widgets::section_card(&theme)
                                         .child(dictation_row)
diff --git a/crates/ui/src/icons.rs b/crates/ui/src/icons.rs
index 3cd5d51d6e..7a6bf92c5b 100644
--- a/crates/ui/src/icons.rs
+++ b/crates/ui/src/icons.rs
@@ -51,7 +51,6 @@ macro_rules! icon_assets {
 }
 
 icon_assets![
-    (MICROPHONE, "microphone"),
     (PROJECT_DEFAULT, "project-default"),
     (REMOTE_SERVER, "remote-server"),
     // Service-tier bolt, drawn in the toolbar family's linear weight; the
@@ -181,6 +180,10 @@ icon_assets![
     // plus/return ports) — the embedded set has neither.
     (BELL, "bell"),
     (VOLUME_LOUD, "volume-loud"),
+    // Hand-drawn microphone pair in the Solar Linear style — voice controls.
+    (MICROPHONE, "microphone"),
+    (MICROPHONE_OFF, "microphone-off"),
+    (PHONE_HANG_UP, "phone-hang-up"),
     // Hand-drawn zeron glyphs (terminal-panel.tsx / composer-actions.tsx /
     // menu-check.tsx / logo.tsx).
     (TERMINAL, "terminal"),
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index 1f12719451..a5d06796b3 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -48,6 +48,7 @@ mod new_thread_background_image;
 mod new_thread_background_mask;
 mod notice;
 pub mod notify;
+pub mod orb;
 pub mod pickers;
 pub mod popover;
 pub mod project_actions;
@@ -66,6 +67,7 @@ pub mod theme;
 pub mod theme_library;
 pub mod transcript;
 pub mod typography;
+pub mod voice;
 mod workspace_links;
 
 use std::path::PathBuf;
diff --git a/crates/ui/src/markdown/veil.rs b/crates/ui/src/markdown/veil.rs
index 7d5f5e7969..a8a45e4d87 100644
--- a/crates/ui/src/markdown/veil.rs
+++ b/crates/ui/src/markdown/veil.rs
@@ -1,237 +1,16 @@
-//! Streaming fade veil — per-appended-chunk opacity over already-committed text.
+//! Streaming fade veil for GPUI text: the chunk tracking lives in
+//! `zeron-veil` (shared with the voice captions on desktop and mobile); this
+//! module recolors GPUI text runs with its spans.
 //!
-//! The desktop app (docs/research/mugen-pretext.md §2e) commits streamed text to
-//! layout instantly and dissolves a purely cosmetic veil over the newly arrived
-//! characters. This module is the gpui port of that idea:
-//!
-//! - [`ElemVeil`] tracks, per rendered text element, the previously rendered
-//!   flat text. Each append registers the new byte range as a [`Chunk`] with its
-//!   arrival time; a fast stream keeps several chunks fading concurrently (a
-//!   rolling veil). A chunk fades exactly once — already-faded text never
-//!   re-animates, and a fully settled element returns no spans at all.
-//! - [`apply_veil`] multiplies the fading alpha into the `TextRun` colors
-//!   covering each chunk. This is paint-only by construction: a color-only run
-//!   split cannot change layout — gpui shapes text through cosmic-text, whose
-//!   `Attrs::compatible` ignores color/metadata, so adjacent same-font runs are
-//!   shaped as one contiguous word even across the split (kerning and ligatures
-//!   survive; wrapping is byte-identical to the unsplit render).
-//!
-//! Constants and curve match mugen-markdown's web `FadePainter` (the engine the
-//! desktop app ships): per-chunk duration adapts to the stream's cadence — an
-//! EMA of inter-append gaps, `duration = clamp(ema × 3, 120ms, 400ms)` — the
-//! dissolve eases with `veil = (1 − p)^1.6` (text alpha `1 − veil`), and a
-//! backed-up stream (3+ concurrent chunks) gets a small speed boost. **Zero
-//! translate** — opacity only, per the "no positional offset on streamed
-//! content" rule.
-
-use std::collections::HashMap;
-use std::ops::Range;
-use std::time::Instant;
+//! [`apply_veil`] multiplies the fading alpha into the `TextRun` colors
+//! covering each chunk. This is paint-only by construction: a color-only run
+//! split cannot change layout — gpui shapes text through cosmic-text, whose
+//! `Attrs::compatible` ignores color/metadata, so adjacent same-font runs are
+//! shaped as one contiguous word even across the split (kerning and ligatures
+//! survive; wrapping is byte-identical to the unsplit render).
 
 use gpui::TextRun;
-
-/// EMA seed for the inter-append gap (mugen `EMA_SEED_MS`).
-pub const VEIL_EMA_SEED_MS: f32 = 160.0;
-/// Duration clamp (mugen `MIN_FADE_MS` / `MAX_FADE_MS`).
-pub const VEIL_MIN_FADE_MS: f32 = 120.0;
-pub const VEIL_MAX_FADE_MS: f32 = 400.0;
-/// Dissolve exponent (mugen: `alpha = (1 - p) ** 1.6`).
-pub const VEIL_CURVE_POW: f32 = 1.6;
-/// Gap clamp feeding the EMA (mugen: `min(gap, 1000)`).
-const VEIL_GAP_CLAMP_MS: f32 = 1000.0;
-
-/// One appended chunk of text mid-fade.
-#[derive(Debug, Clone)]
-struct Chunk {
-    /// Byte range in the element's flat text.
-    range: Range<usize>,
-    started: Instant,
-    /// Fade duration fixed at arrival from the cadence EMA.
-    duration_ms: f32,
-}
-
-/// A veiled byte range and its current opacity (0..1).
-pub type VeilSpan = (Range<usize>, f32);
-
-/// Text alpha for a fade progress `p` (0..1): the veil dissolves as
-/// `(1 − p)^1.6`, so the text shows through at `1 − veil`. Pure.
-pub fn veil_opacity(p: f32) -> f32 {
-    1.0 - (1.0 - p.clamp(0.0, 1.0)).powf(VEIL_CURVE_POW)
-}
-
-/// Chunk fade duration for the current inter-append EMA (mugen:
-/// `min(MAX, max(MIN, ema * 3))`).
-pub fn veil_duration_ms(ema_ms: f32) -> f32 {
-    (ema_ms * 3.0).clamp(VEIL_MIN_FADE_MS, VEIL_MAX_FADE_MS)
-}
-
-/// Fast-stream boost: 3+ chunks fading concurrently speed up by 30% each
-/// (mugen: `1 + 0.3 * max(0, veils.length - 2)`).
-pub fn veil_boost(active_chunks: usize) -> f32 {
-    1.0 + 0.3 * active_chunks.saturating_sub(2) as f32
-}
-
-/// EMA update on a new append gap (mugen: `ema*0.7 + min(gap,1000)*0.3`).
-pub fn veil_ema_next(ema_ms: f32, gap_ms: f32) -> f32 {
-    ema_ms * 0.7 + gap_ms.min(VEIL_GAP_CLAMP_MS) * 0.3
-}
-
-/// Per-element chunk tracker: remembers the last rendered flat text and fades
-/// every newly appended suffix exactly once.
-#[derive(Debug)]
-pub struct ElemVeil {
-    prev: String,
-    chunks: Vec<Chunk>,
-    /// EMA of inter-append gaps (drives per-chunk durations).
-    ema_ms: f32,
-    last_append: Option<Instant>,
-}
-
-impl Default for ElemVeil {
-    fn default() -> Self {
-        Self {
-            prev: String::new(),
-            chunks: Vec::new(),
-            ema_ms: VEIL_EMA_SEED_MS,
-            last_append: None,
-        }
-    }
-}
-
-/// Longest common prefix length, snapped back to a char boundary.
-fn common_prefix(a: &str, b: &str) -> usize {
-    let mut p = a
-        .as_bytes()
-        .iter()
-        .zip(b.as_bytes())
-        .take_while(|(x, y)| x == y)
-        .count();
-    while p > 0 && !b.is_char_boundary(p) {
-        p -= 1;
-    }
-    p
-}
-
-impl ElemVeil {
-    /// Adopt `text` as the committed baseline without fading it — the attach
-    /// semantics of mugen's `FadePainter.attach` (`length =
-    /// chromeFreeLength(content)`): content already on screen when the painter
-    /// attaches never animates; only later appends do.
-    fn seed(&mut self, text: &str) {
-        self.prev.clear();
-        self.prev.push_str(text);
-    }
-
-    /// Advance to `text` at `now`: registers a fading chunk for newly appended
-    /// bytes, prunes settled chunks, and returns the active spans. Idempotent
-    /// for unchanged text — safe to call once per frame (or twice, when a row
-    /// is both measured and painted).
-    pub fn advance(&mut self, text: &str, now: Instant) -> Vec<VeilSpan> {
-        if text != self.prev {
-            // Non-append rewrites (the incremental parser re-deriving a block's
-            // flat text — e.g. `**bold` collapsing into a bold run) keep the
-            // common prefix's committed fades and re-veil only the changed tail.
-            let p = common_prefix(&self.prev, text);
-            self.chunks.retain_mut(|c| {
-                c.range.end = c.range.end.min(p);
-                c.range.start < c.range.end
-            });
-            if text.len() > p {
-                // Cadence-adaptive duration (mugen FadePainter): update the
-                // EMA with the gap since the previous append.
-                if let Some(last) = self.last_append {
-                    let gap = now.saturating_duration_since(last).as_secs_f32() * 1000.0;
-                    self.ema_ms = veil_ema_next(self.ema_ms, gap);
-                }
-                self.last_append = Some(now);
-                self.chunks.push(Chunk {
-                    range: p..text.len(),
-                    started: now,
-                    duration_ms: veil_duration_ms(self.ema_ms),
-                });
-            }
-            self.prev.clear();
-            self.prev.push_str(text);
-        }
-        let boost = veil_boost(self.chunks.len());
-        self.chunks.retain(|c| {
-            let elapsed = now.saturating_duration_since(c.started).as_secs_f32() * 1000.0;
-            elapsed * boost < c.duration_ms
-        });
-        let boost = veil_boost(self.chunks.len());
-        self.chunks
-            .iter()
-            .map(|c| {
-                let elapsed = now.saturating_duration_since(c.started).as_secs_f32() * 1000.0;
-                let progress = (elapsed * boost / c.duration_ms).clamp(0.0, 1.0);
-                (c.range.clone(), veil_opacity(progress))
-            })
-            .collect()
-    }
-
-    /// Any chunk still fading (as of the last [`advance`](Self::advance))?
-    pub fn is_fading(&self) -> bool {
-        !self.chunks.is_empty()
-    }
-}
-
-/// Veil state for one live streaming row, keyed by the render tree's stable
-/// per-element discriminator (top-level block ix / nested ix scheme — stable
-/// across appends because the incremental parser only reparses the tail).
-#[derive(Debug, Default)]
-pub struct RowVeil {
-    elems: HashMap<usize, ElemVeil>,
-    /// Attach pass in progress: elements first seen while seeding adopt their
-    /// current text as the committed baseline instead of fading it in. Set for
-    /// rows that already carried text when the transcript (re)attached to the
-    /// chat — switching back to a streaming session must not dissolve the
-    /// whole existing reply (user report; mugen's `FadePainter.attach` baseline).
-    seeding: bool,
-}
-
-impl RowVeil {
-    /// A veil whose first render pass seeds baselines instead of fading.
-    pub fn seeded() -> Self {
-        Self {
-            elems: HashMap::new(),
-            seeding: true,
-        }
-    }
-
-    /// The attach pass is over — elements that appear from here on are newly
-    /// streamed content and fade normally.
-    pub fn finish_seeding(&mut self) {
-        self.seeding = false;
-    }
-
-    pub fn advance(&mut self, elem: usize, text: &str, now: Instant) -> Vec<VeilSpan> {
-        if self.seeding && !self.elems.contains_key(&elem) {
-            let mut baseline = ElemVeil::default();
-            baseline.seed(text);
-            self.elems.insert(elem, baseline);
-            return Vec::new();
-        }
-        self.elems.entry(elem).or_default().advance(text, now)
-    }
-
-    /// Any element still fading? Drives the once-per-frame repaint request.
-    pub fn is_fading(&self) -> bool {
-        self.elems.values().any(ElemVeil::is_fading)
-    }
-}
-
-/// Intersect spans with `[start, end)` and shift them to local offsets — used
-/// by per-line code rendering where chunks are tracked on the whole code text.
-pub fn slice_spans(spans: &[VeilSpan], start: usize, end: usize) -> Vec<VeilSpan> {
-    spans
-        .iter()
-        .filter_map(|(r, a)| {
-            let s = r.start.max(start);
-            let e = r.end.min(end);
-            (s < e).then(|| (s - start..e - start, *a))
-        })
-        .collect()
-}
+pub use zeron_veil::{RowVeil, VeilSpan, slice_spans};
 
 /// Multiply veil opacities into the runs' paint colors, splitting runs at span
 /// boundaries. Fonts, lengths, and text are untouched — the total run length is
@@ -285,146 +64,6 @@ pub fn apply_veil(runs: Vec<TextRun>, spans: &[VeilSpan]) -> Vec<TextRun> {
 mod tests {
     use super::*;
     use gpui::{font, px};
-    use std::time::Duration;
-
-    fn at(base: Instant, ms: u64) -> Instant {
-        base + Duration::from_millis(ms)
-    }
-
-    #[test]
-    fn first_text_fades_and_settles_once() {
-        let t0 = Instant::now();
-        let mut v = ElemVeil::default();
-        let spans = v.advance("hello", t0);
-        assert_eq!(spans, vec![(0..5, 0.0)]);
-        // Mid-fade: opacity strictly between 0 and 1, range unchanged.
-        let spans = v.advance("hello", at(t0, 250));
-        assert_eq!(spans.len(), 1);
-        assert!(spans[0].1 > 0.0 && spans[0].1 < 1.0);
-        // Settled: pruned, never re-animates.
-        assert!(v.advance("hello", at(t0, 600)).is_empty());
-        assert!(!v.is_fading());
-        assert!(v.advance("hello", at(t0, 700)).is_empty());
-    }
-
-    #[test]
-    fn appended_chunks_fade_concurrently_and_independently() {
-        let t0 = Instant::now();
-        let mut v = ElemVeil::default();
-        v.advance("one ", t0);
-        let spans = v.advance("one two ", at(t0, 100));
-        assert_eq!(spans.len(), 2);
-        assert_eq!(spans[0].0, 0..4);
-        assert_eq!(spans[1].0, 4..8);
-        // The older chunk is further along its fade than the newer one.
-        assert!(spans[0].1 > spans[1].1);
-        // After the first settles (past its adaptive duration), only the
-        // newer chunk remains.
-        let spans = v.advance("one two ", at(t0, 410));
-        assert_eq!(spans.len(), 1);
-        assert_eq!(spans[0].0, 4..8);
-    }
-
-    #[test]
-    fn fade_constants_match_mugen_fade_painter() {
-        // @wingleeio/mugen-markdown dist/index.mjs: EMA_SEED_MS=160,
-        // MIN_FADE_MS=120, MAX_FADE_MS=400, alpha=(1-p)**1.6,
-        // ema = ema*0.7 + min(gap,1000)*0.3, boost = 1 + 0.3*max(0,n-2).
-        assert_eq!(VEIL_EMA_SEED_MS, 160.0);
-        assert_eq!(VEIL_MIN_FADE_MS, 120.0);
-        assert_eq!(VEIL_MAX_FADE_MS, 400.0);
-        assert_eq!(VEIL_CURVE_POW, 1.6);
-        // duration = clamp(ema*3, 120, 400).
-        assert_eq!(veil_duration_ms(160.0), 400.0); // seed → clamped at max
-        assert_eq!(veil_duration_ms(30.0), 120.0); // fast stream → floor
-        assert_eq!(veil_duration_ms(60.0), 180.0);
-        // EMA update.
-        assert_eq!(veil_ema_next(160.0, 100.0), 160.0 * 0.7 + 100.0 * 0.3);
-        assert_eq!(veil_ema_next(160.0, 5000.0), 160.0 * 0.7 + 1000.0 * 0.3);
-        // Fast-stream boost kicks in at the 3rd concurrent chunk.
-        assert_eq!(veil_boost(0), 1.0);
-        assert_eq!(veil_boost(2), 1.0);
-        assert!((veil_boost(3) - 1.3).abs() < 1e-6);
-        assert!((veil_boost(5) - 1.9).abs() < 1e-6);
-    }
-
-    #[test]
-    fn seeded_row_adopts_existing_text_without_fading() {
-        // Switching back to a streaming session: the text already on screen is
-        // the attach BASELINE (mugen FadePainter.attach) — no full-reply fade.
-        let t0 = Instant::now();
-        let mut row = RowVeil::seeded();
-        assert!(row.advance(0, "already streamed text", t0).is_empty());
-        assert!(row.advance(1, "second block", t0).is_empty());
-        assert!(!row.is_fading());
-        // Appends AFTER the attach fade normally — only the new suffix.
-        let spans = row.advance(0, "already streamed text plus", at(t0, 100));
-        assert_eq!(spans, vec![(21..26, 0.0)]);
-        // The attach pass ends after the first render: elements first seen
-        // later are newly streamed content and fade from empty.
-        row.finish_seeding();
-        let spans = row.advance(2, "new block", at(t0, 200));
-        assert_eq!(spans, vec![(0..9, 0.0)]);
-    }
-
-    #[test]
-    fn default_row_veil_fades_first_text() {
-        // Mid-stream new rows keep the old behavior: their first chunk fades.
-        let t0 = Instant::now();
-        let mut row = RowVeil::default();
-        let spans = row.advance(0, "fresh", t0);
-        assert_eq!(spans, vec![(0..5, 0.0)]);
-    }
-
-    #[test]
-    fn faded_text_never_reanimates_on_append() {
-        let t0 = Instant::now();
-        let mut v = ElemVeil::default();
-        v.advance("stable", t0);
-        // Fully settled...
-        assert!(v.advance("stable", at(t0, 600)).is_empty());
-        // ...then an append veils ONLY the new suffix.
-        let spans = v.advance("stable more", at(t0, 700));
-        assert_eq!(spans, vec![(6..11, 0.0)]);
-    }
-
-    #[test]
-    fn non_append_rewrite_keeps_prefix_and_reveils_tail() {
-        let t0 = Instant::now();
-        let mut v = ElemVeil::default();
-        v.advance("intro **bol", t0);
-        // Markdown resolves: flat text loses the `**` marker.
-        let spans = v.advance("intro bold", at(t0, 100));
-        // The shared prefix's chunk is clamped, the changed tail is one chunk.
-        assert_eq!(spans.len(), 2);
-        assert_eq!(spans[0].0, 0..6);
-        assert_eq!(spans[1].0, 6..10);
-        assert!(spans[0].1 > spans[1].1);
-    }
-
-    #[test]
-    fn common_prefix_respects_char_boundaries() {
-        // "é" = 0xC3 0xA9, "è" = 0xC3 0xA8 — byte prefix would split the char.
-        assert_eq!(common_prefix("é", "è"), 0);
-        assert_eq!(common_prefix("abé", "abè"), 2);
-        assert_eq!(common_prefix("same", "same"), 4);
-    }
-
-    #[test]
-    fn veil_opacity_curve_endpoints() {
-        // Text alpha = 1 - (1-p)^1.6: 0 at arrival, 1 when the veil is gone.
-        assert_eq!(veil_opacity(0.0), 0.0);
-        assert_eq!(veil_opacity(1.0), 1.0);
-        let mid = veil_opacity(0.5);
-        assert!(mid > 0.0 && mid < 1.0);
-        // The pow-1.6 ease-out reveals faster than linear early on.
-        assert!(mid > 0.5);
-        assert!((mid - (1.0 - 0.5f32.powf(1.6))).abs() < 1e-6);
-        // Monotonic + clamped.
-        assert!(veil_opacity(0.2) <= veil_opacity(0.4));
-        assert_eq!(veil_opacity(-1.0), 0.0);
-        assert_eq!(veil_opacity(2.0), 1.0);
-    }
 
     fn run(len: usize, color: gpui::Hsla) -> TextRun {
         TextRun {
@@ -482,27 +121,4 @@ mod tests {
         assert_eq!(out[0].background_color.unwrap().a, 0.25);
         assert_eq!(out[0].underline.as_ref().unwrap().color.unwrap().a, 0.25);
     }
-
-    #[test]
-    fn slice_spans_shifts_to_local_offsets() {
-        let spans = vec![(3..10, 0.4), (12..20, 0.1)];
-        // A "line" covering bytes 5..15.
-        let local = slice_spans(&spans, 5, 15);
-        assert_eq!(local, vec![(0..5, 0.4), (7..10, 0.1)]);
-        // Disjoint window → empty.
-        assert!(slice_spans(&spans, 25, 30).is_empty());
-    }
-
-    #[test]
-    fn row_veil_tracks_elements_independently() {
-        let t0 = Instant::now();
-        let mut row = RowVeil::default();
-        row.advance(0, "para", t0);
-        row.advance(2, "code", t0);
-        assert!(row.is_fading());
-        row.advance(0, "para", at(t0, 600));
-        assert!(row.is_fading(), "elem 2 hasn't been advanced past its fade");
-        row.advance(2, "code", at(t0, 600));
-        assert!(!row.is_fading());
-    }
 }
diff --git a/crates/ui/src/orb/mod.rs b/crates/ui/src/orb/mod.rs
new file mode 100644
index 0000000000..baa22ac3e8
--- /dev/null
+++ b/crates/ui/src/orb/mod.rs
@@ -0,0 +1,19 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Thinking orbs — dotted loading indicators for AI & agent UIs, ported from
+//! gpui-thinking-orbs (MIT), itself a port of Jakub Antalik's thinking-orbs.
+//!
+//! The animation engine and playback live in `zeron-orb`, shared with the
+//! mobile apps; this module is its GPUI widget and paint path.
+//!
+//! ```ignore
+//! cx.new(|_| Orb::new().state(OrbState::Searching).size(OrbSize::Avatar))
+//! ```
+//!
+//! Style flows through the environment like the rest of bezel: [`OrbTheme::Auto`]
+//! resolves ink against the installed [`theme::Appearance`] at paint time.
+
+mod orb;
+mod paint;
+
+pub use orb::{DEFAULT_TARGET_FPS, Orb, orb_element};
+pub use zeron_orb::{ModeKey, OrbSize, OrbState, OrbTheme, Resolved, engine, resolve_preset};
diff --git a/crates/ui/src/orb/orb.rs b/crates/ui/src/orb/orb.rs
new file mode 100644
index 0000000000..33820d2a30
--- /dev/null
+++ b/crates/ui/src/orb/orb.rs
@@ -0,0 +1,451 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! The [`Orb`] component: a Rust builder over the animation engine.
+//!
+//! The engine takes continuous, unbounded time — its modes mix incommensurate
+//! frequencies, so there is no seamless wrap point and gpui's folded
+//! `with_animation` clock would jump at every loop. An entity owns the real
+//! clock; [`orb_element`] is the same paint one layer down for hosts that
+//! already tick.
+
+use std::{cell::RefCell, rc::Rc, time::Duration};
+
+use gpui::{
+    Bounds, Context, IntoElement, ParentElement, Pixels, Render, Styled, Task, Window, canvas, div,
+    px,
+};
+use std::time::Instant;
+use zeron_orb::{
+    OrbAnimator, OrbSize, OrbState, OrbTheme,
+    engine::{Frame, draw_mode_into},
+    resolve_preset,
+};
+
+use crate::orb::paint::paint_frame;
+
+/// Frames per second the orb redraws at when no explicit rate is set.
+///
+/// The orb is a status indicator, not a game: its motion is slow and organic,
+/// and at 30 fps it is indistinguishable from 60 while costing half as much.
+/// Every redraw walks the whole element tree, so the tick rate — not the
+/// geometry — is what dominates CPU.
+pub const DEFAULT_TARGET_FPS: f32 = 30.0;
+
+/// Animated thinking-orb status indicator for AI / agent UIs.
+///
+/// ```ignore
+/// cx.new(|_| Orb::new().state(OrbState::Searching).size(OrbSize::Avatar))
+/// ```
+pub struct Orb {
+    /// State, size, speed, clock, audio and crossfades — shared with mobile.
+    animator: OrbAnimator,
+    /// Uniform magnification of the size preset's painted geometry.
+    scale: f32,
+    theme: OrbTheme,
+    paused: bool,
+    /// When true, freeze on a static representative frame (`t = 0.6`). The
+    /// system `reduce_motion` setting forces the same, so hosts only set this
+    /// for their own per-surface motion preferences.
+    reduced_motion: bool,
+    /// Redraw rate ceiling.
+    target_fps: f32,
+    /// Stop animating while the host window is not the active one.
+    pause_when_inactive: bool,
+    /// Host-controlled visibility. When false the timer is cancelled and the
+    /// orb freezes — use this when the entity is still mounted but scrolled
+    /// off-screen (gpui has no intersection observer).
+    visible: bool,
+
+    /// Geometry buffer reused across frames. Behind `Rc<RefCell<_>>` because
+    /// the canvas paint callback must be `'static` and so cannot borrow `self`.
+    frame: Rc<RefCell<Frame>>,
+    /// Explicit invalidation for animation ticks and semantic changes. Parent
+    /// renders between ticks reuse the retained geometry.
+    geometry_dirty: bool,
+
+    /// Pending redraw timer. At most one stays in flight; dropping it cancels
+    /// animation immediately when the orb becomes paused or invisible.
+    tick: Option<Task<()>>,
+    /// Window-activation subscription, registered lazily on first render since
+    /// it needs a `Window`. Dropping it unsubscribes.
+    activation: Option<gpui::Subscription>,
+}
+
+impl Default for Orb {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Orb {
+    pub fn new() -> Self {
+        Self {
+            animator: OrbAnimator::new(OrbState::Working, OrbSize::Avatar),
+            scale: 1.0,
+            theme: OrbTheme::Auto,
+            paused: false,
+            reduced_motion: false,
+            target_fps: DEFAULT_TARGET_FPS,
+            pause_when_inactive: true,
+            visible: true,
+            frame: Rc::new(RefCell::new(Frame::new())),
+            geometry_dirty: true,
+            tick: None,
+            activation: None,
+        }
+    }
+
+    pub fn state(mut self, state: OrbState) -> Self {
+        // Nothing is on screen yet, so there is no frame to fade from.
+        self.animator.set_state(state, &Frame::new());
+        self
+    }
+
+    pub fn size(mut self, size: OrbSize) -> Self {
+        self.animator.set_size(size);
+        self
+    }
+
+    /// Paint the size preset magnified, e.g. a hero orb filling a stage.
+    pub fn scale(mut self, scale: f32) -> Self {
+        self.scale = sanitize_scale(scale);
+        self
+    }
+
+    pub fn theme(mut self, theme: OrbTheme) -> Self {
+        self.theme = theme;
+        self
+    }
+
+    pub fn speed(mut self, speed: f32) -> Self {
+        self.animator.set_speed(speed);
+        self
+    }
+
+    /// Freeze the accumulated animation time while paused.
+    pub fn paused(mut self, paused: bool) -> Self {
+        self.paused = paused;
+        self
+    }
+
+    /// Crossfade state geometry without remounting or restarting the clock.
+    pub fn state_transition(mut self, duration: Duration) -> Self {
+        self.animator.set_transition(duration);
+        self
+    }
+
+    pub fn reduced_motion(mut self, reduced: bool) -> Self {
+        self.reduced_motion = reduced;
+        self
+    }
+
+    /// Cap the redraw rate. Values are clamped to `1.0..=240.0`.
+    ///
+    /// Lower is cheaper: cost scales linearly with this number.
+    pub fn target_fps(mut self, fps: f32) -> Self {
+        self.target_fps = sanitize_fps(fps);
+        self
+    }
+
+    /// Whether to freeze while the host window is inactive. Defaults to `true`.
+    ///
+    /// A background window's animation is not visible to anyone, so this is
+    /// usually free. Set it to `false` if the orb must keep moving in a window
+    /// that is visible but unfocused — a side panel, or a floating HUD.
+    pub fn pause_when_inactive(mut self, pause: bool) -> Self {
+        self.pause_when_inactive = pause;
+        self
+    }
+
+    /// Whether the host considers this orb on-screen. Defaults to `true`.
+    ///
+    /// gpui has no intersection observer. When you keep the entity mounted in
+    /// a scrollable list but it has scrolled away, call
+    /// [`Self::set_visible`]`(false)` (or build with `.visible(false)`) so the
+    /// timer stops. Prefer unmounting when you can.
+    pub fn visible(mut self, visible: bool) -> Self {
+        self.visible = visible;
+        self
+    }
+
+    /// Mutable setters for interactive playgrounds.
+    pub fn set_state(&mut self, state: OrbState, cx: &mut Context<Self>) {
+        // A hidden, paused or reduced orb has a stopped clock, so it switches
+        // without a fade.
+        if self.animator.set_state(state, &self.frame.borrow()) {
+            self.geometry_dirty = true;
+            cx.notify();
+        }
+    }
+
+    pub fn set_size(&mut self, size: OrbSize, cx: &mut Context<Self>) {
+        if self.animator.set_size(size) {
+            self.geometry_dirty = true;
+            cx.notify();
+        }
+    }
+
+    pub fn set_scale(&mut self, scale: f32, cx: &mut Context<Self>) {
+        let scale = sanitize_scale(scale);
+        if (self.scale - scale).abs() > f32::EPSILON {
+            self.scale = scale;
+            cx.notify();
+        }
+    }
+
+    pub fn set_theme(&mut self, theme: OrbTheme, cx: &mut Context<Self>) {
+        if self.theme != theme {
+            self.theme = theme;
+            cx.notify();
+        }
+    }
+
+    pub fn set_speed(&mut self, speed: f32, cx: &mut Context<Self>) {
+        if self.animator.set_speed(speed) {
+            self.geometry_dirty = true;
+            cx.notify();
+        }
+    }
+
+    /// Audio affects only visual motion, with independent microphone and
+    /// speaker envelopes evaluated at the orb's frame rate.
+    pub fn set_audio_levels(&mut self, microphone: f32, speaker: f32, cx: &mut Context<Self>) {
+        if self
+            .animator
+            .set_audio_levels(microphone, speaker, Instant::now())
+        {
+            self.geometry_dirty = true;
+            cx.notify();
+        }
+    }
+
+    pub fn set_paused(&mut self, paused: bool, cx: &mut Context<Self>) {
+        if self.paused == paused {
+            return;
+        }
+        self.paused = paused;
+        if paused {
+            self.animator.stop(Instant::now());
+        }
+        self.geometry_dirty = true;
+        cx.notify();
+    }
+
+    pub fn set_reduced_motion(&mut self, reduced: bool, cx: &mut Context<Self>) {
+        if self.reduced_motion != reduced {
+            self.reduced_motion = reduced;
+            if reduced {
+                self.animator.stop(Instant::now());
+                self.animator.cancel_transition();
+            }
+            self.geometry_dirty = true;
+            cx.notify();
+        }
+    }
+
+    pub fn set_target_fps(&mut self, fps: f32, cx: &mut Context<Self>) {
+        self.target_fps = sanitize_fps(fps);
+        cx.notify();
+    }
+
+    pub fn set_pause_when_inactive(&mut self, pause: bool, cx: &mut Context<Self>) {
+        if self.pause_when_inactive != pause {
+            self.pause_when_inactive = pause;
+            cx.notify();
+        }
+    }
+
+    /// Host visibility gate — see [`Self::visible`].
+    pub fn set_visible(&mut self, visible: bool, cx: &mut Context<Self>) {
+        if self.visible != visible {
+            self.visible = visible;
+            if !visible {
+                self.animator.stop(Instant::now());
+                self.animator.cancel_transition();
+            }
+            self.geometry_dirty = true;
+            cx.notify();
+        }
+    }
+
+    pub fn state_value(&self) -> OrbState {
+        self.animator.state()
+    }
+
+    pub fn size_value(&self) -> OrbSize {
+        self.animator.size()
+    }
+
+    pub fn theme_value(&self) -> OrbTheme {
+        self.theme
+    }
+
+    pub fn speed_value(&self) -> f32 {
+        self.animator.speed()
+    }
+
+    pub fn is_paused(&self) -> bool {
+        self.paused
+    }
+
+    pub fn reduced_motion_value(&self) -> bool {
+        self.reduced_motion
+    }
+
+    pub fn target_fps_value(&self) -> f32 {
+        self.target_fps
+    }
+
+    pub fn pause_when_inactive_value(&self) -> bool {
+        self.pause_when_inactive
+    }
+
+    pub fn is_visible(&self) -> bool {
+        self.visible
+    }
+
+    /// Ink direction, resolved against the installed bezel appearance —
+    /// `Auto` follows it, no window subscription needed (the appearance is
+    /// process-wide and its switch repaints the window anyway).
+    fn dark(&self, cx: &gpui::App) -> bool {
+        match self.theme {
+            OrbTheme::Dark => true,
+            OrbTheme::Light => false,
+            OrbTheme::Auto => crate::theme::Theme::of(cx).appearance.is_dark(),
+        }
+    }
+
+    /// Queue the next redraw, honouring [`Self::target_fps`].
+    fn schedule_tick(&mut self, cx: &mut Context<Self>) {
+        // Parent renders may happen between animation frames. Keep the timer
+        // already in flight rather than cancel/reallocate it and push the next
+        // frame farther into the future.
+        if self.tick.is_some() {
+            return;
+        }
+        let period = Duration::from_secs_f32(1.0 / self.target_fps);
+        self.tick = Some(cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(period).await;
+            let _ = this.update(cx, |orb, cx| {
+                orb.tick = None;
+                orb.geometry_dirty = true;
+                cx.notify();
+            });
+        }));
+    }
+}
+
+impl Render for Orb {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        // An orb in a background window stops ticking entirely, so it needs a
+        // nudge to start again when the window comes back. Registered once,
+        // here, because it needs a `Window`.
+        if self.activation.is_none() {
+            self.activation = Some(cx.observe_window_activation(window, |orb, window, cx| {
+                if orb.pause_when_inactive && !window.is_window_active() {
+                    orb.animator.stop(Instant::now());
+                }
+                orb.geometry_dirty = true;
+                cx.notify();
+            }));
+        }
+
+        let size_px = self.animator.pixels();
+        let scale = self.scale;
+        let dark = self.dark(cx);
+        let reduced = self.reduced_motion || cx.reduce_motion();
+        let animating = self.visible
+            && !self.paused
+            && !reduced
+            && (!self.pause_when_inactive || window.is_window_active());
+        self.animator.tick(Instant::now(), animating, reduced);
+        let r_min = self.animator.r_min();
+
+        // Only ticks and semantic changes invalidate geometry. A parent can
+        // re-render much faster than this orb's target FPS; those extra renders
+        // reuse the retained frame rather than running animation math again.
+        if self.geometry_dirty {
+            self.animator.draw(&mut self.frame.borrow_mut());
+            self.geometry_dirty = false;
+        }
+
+        if animating {
+            self.schedule_tick(cx);
+        } else {
+            // Drop any in-flight tick so a paused, hidden, or backgrounded orb
+            // costs nothing at all.
+            self.tick = None;
+        }
+
+        let frame = self.frame.clone();
+        div()
+            .size(px(size_px * scale))
+            .flex_shrink_0()
+            .overflow_hidden()
+            .child(
+                canvas(
+                    move |_bounds: Bounds<Pixels>, _window, _cx| (),
+                    move |bounds, (), window, _cx| {
+                        paint_frame(window, bounds, &frame.borrow(), dark, r_min, scale);
+                    },
+                )
+                .size_full(),
+            )
+    }
+}
+
+/// Paint one frame of an orb at animation time `t` (seconds, unbounded) — the
+/// pure, host-ticked form of [`Orb`]. Build it inside any render that runs on
+/// a clock of its own; the reduced-motion convention is `t = 0.6`.
+///
+/// `frame` is the caller's geometry buffer, overwritten here and handed to the
+/// paint closure. Geometry is a function of `t`, so there is nothing to cache
+/// between frames — but a host that keeps one buffer per orb reuses its two
+/// `Vec`s forever instead of growing a pair from empty on every tick.
+pub fn orb_element(
+    state: OrbState,
+    size: OrbSize,
+    t: f32,
+    frame: &Rc<RefCell<Frame>>,
+) -> impl IntoElement {
+    let resolved = resolve_preset(state, size);
+    let size_px = size.pixels();
+    let frame = frame.clone();
+    draw_mode_into(
+        resolved.mode,
+        size_px,
+        t,
+        &resolved.opts,
+        &mut frame.borrow_mut(),
+    );
+    let r_min = resolved.opts.r_min.unwrap_or(0.3);
+    div()
+        .size(px(size_px))
+        .flex_shrink_0()
+        .overflow_hidden()
+        .child(
+            canvas(
+                move |_bounds: Bounds<Pixels>, _window, _cx| (),
+                move |bounds, (), window, cx| {
+                    let dark = crate::theme::Theme::of(cx).appearance.is_dark();
+                    paint_frame(window, bounds, &frame.borrow(), dark, r_min, 1.0);
+                },
+            )
+            .size_full(),
+        )
+}
+
+fn sanitize_scale(scale: f32) -> f32 {
+    if scale.is_finite() {
+        scale.clamp(0.25, 8.0)
+    } else {
+        1.0
+    }
+}
+
+fn sanitize_fps(fps: f32) -> f32 {
+    if fps.is_finite() {
+        fps.clamp(1.0, 30.0)
+    } else {
+        DEFAULT_TARGET_FPS
+    }
+}
diff --git a/crates/ui/src/orb/paint.rs b/crates/ui/src/orb/paint.rs
new file mode 100644
index 0000000000..01a7487449
--- /dev/null
+++ b/crates/ui/src/orb/paint.rs
@@ -0,0 +1,133 @@
+// Extracted from Bezel 6141af9c16f7353cdf36003f7404e0a94566a163; MIT. See THIRD_PARTY_NOTICES.md.
+//! Paint a backend-agnostic [`Frame`] into a GPUI window.
+
+use gpui::{
+    BorderStyle, Bounds, PathBuilder, Pixels, Point, Window, opaque_grey, point, px, quad, size,
+    transparent_black,
+};
+use zeron_orb::engine::{Frame, Line};
+
+/// Map ink `white` + substrate into a grayscale with alpha.
+fn ink_color(white: f32, alpha: f32, dark: bool) -> gpui::Hsla {
+    let w = white.clamp(0.0, 1.0);
+    let lightness = if dark { 1.0 - w } else { w };
+    opaque_grey(lightness, alpha.clamp(0.0, 1.0))
+}
+
+/// Paint every stroke as its own `Path`, at its exact colour.
+///
+/// Merging segments into shared `PathBuilder`s was tried and reverted. It is
+/// tempting — a single builder accepts any number of disjoint subpaths, and
+/// each `Path` primitive costs GPUI a full two-pass render — but it visibly
+/// brightens the connecting state's web.
+///
+/// The cause is that GPUI composites paths in two stages with different blend
+/// modes: subpaths of one path are rasterised together into a cleared
+/// intermediate texture with premultiplied-alpha blending, and that texture is
+/// then blitted with `color: OVER, alpha: ADDITIVE`. So where strokes overlap,
+/// merging changes which stage accumulates them, and the result does not match
+/// painting each segment separately. Merging also forces a shared colour per
+/// path, which costs another approximation on top.
+///
+/// Measured: batching saves nothing at one orb (2.0 % either way) and about one
+/// point of a core at twelve. Not worth a visible change to the artwork.
+fn paint_lines(window: &mut Window, origin: Point<Pixels>, lines: &[Line], dark: bool, scale: f32) {
+    for l in lines {
+        if l.a < 0.02 {
+            continue;
+        }
+        let mut b = PathBuilder::stroke(px(l.w * scale));
+        b.move_to(point(
+            origin.x + px(l.x1 * scale),
+            origin.y + px(l.y1 * scale),
+        ));
+        b.line_to(point(
+            origin.x + px(l.x2 * scale),
+            origin.y + px(l.y2 * scale),
+        ));
+        if let Ok(path) = b.build() {
+            window.paint_path(path, ink_color(l.white, l.a, dark));
+        }
+    }
+}
+
+/// Paint dots as rounded quads (true circles at GPU level via corner radii).
+fn paint_dots(
+    window: &mut Window,
+    origin: Point<Pixels>,
+    frame: &Frame,
+    dark: bool,
+    r_min: f32,
+    scale: f32,
+) {
+    for d in &frame.dots {
+        if d.a < 0.02 {
+            continue;
+        }
+        let r = d.r.max(r_min) * scale;
+        let diameter = r * 2.0;
+        let bounds = Bounds {
+            origin: point(
+                origin.x + px(d.x * scale - r),
+                origin.y + px(d.y * scale - r),
+            ),
+            size: size(px(diameter), px(diameter)),
+        };
+        // Fully rounded corners → disk.
+        window.paint_quad(quad(
+            bounds,
+            px(r),
+            ink_color(d.white, d.a, dark),
+            px(0.),
+            transparent_black(),
+            BorderStyle::default(),
+        ));
+    }
+}
+
+/// Verification scaffold: `ORB_NO_LAYER=1` paints without the `paint_layer`
+/// wrap, i.e. the pre-optimization path. `scripts/golden-diff.sh` uses it to
+/// render both paths from one binary and diff the results pixel-for-pixel.
+/// Read once; costs a single relaxed atomic load per frame.
+fn no_layer() -> bool {
+    static N: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *N.get_or_init(|| std::env::var("ORB_NO_LAYER").as_deref() == Ok("1"))
+}
+
+/// Paint a complete frame into `bounds` (top-left of the orb).
+///
+/// Background is fully transparent — the host supplies the substrate.
+/// `scale` magnifies the preset's geometry uniformly (dots, strokes and
+/// spacing), so a preset tuned at one edge length stays crisp at another.
+pub fn paint_frame(
+    window: &mut Window,
+    bounds: Bounds<Pixels>,
+    frame: &Frame,
+    dark: bool,
+    r_min: f32,
+    scale: f32,
+) {
+    if no_layer() {
+        paint_lines(window, bounds.origin, &frame.lines, dark, scale);
+        paint_dots(window, bounds.origin, frame, dark, r_min, scale);
+        return;
+    }
+
+    // Everything is painted inside one layer, which is the single biggest win
+    // in the paint path. Outside a layer, `Scene::insert_primitive` calls
+    // `BoundsTree::insert` for *every* primitive to compute its draw order —
+    // a bounding-volume-hierarchy insertion whose `find_max_ordering` walk
+    // degenerates when primitives overlap heavily, which is exactly the case
+    // here (hundreds of discs stacked inside a 64px box). Inside a layer the
+    // tree is touched once and every primitive inherits the layer's order.
+    //
+    // Ordering is preserved: `Scene::finish` sorts with `sort_by_key`, which is
+    // stable, so quads sharing the layer's order keep their insertion order —
+    // and the engine already emits dots back-to-front. The painter's algorithm
+    // still holds. Confirmed by pixel-diffing the golden grid against a build
+    // with this call removed: every dot-only orb came out byte-identical.
+    window.paint_layer(bounds, |window| {
+        paint_lines(window, bounds.origin, &frame.lines, dark, scale);
+        paint_dots(window, bounds.origin, frame, dark, r_min, scale);
+    });
+}
diff --git a/crates/ui/src/settings.rs b/crates/ui/src/settings.rs
index 51f27089e6..5bdd350768 100644
--- a/crates/ui/src/settings.rs
+++ b/crates/ui/src/settings.rs
@@ -965,6 +965,12 @@ pub struct UiSettings {
     pub reduce_motion: crate::motion::ReduceMotion,
     /// Also snap animations while the main window is not focused.
     pub pause_animations_in_background: bool,
+    /// Stable native Codex voice id only; devices and microphone state are never persisted.
+    #[serde(default)]
+    pub codex_voice: Option<String>,
+    /// Local preference: never transfers an active call or credentials.
+    #[serde(default)]
+    pub codex_voice_device: Option<String>,
     /// Pre-theme settings used `accentColor`. Read it once, migrate to
     /// [`Self::accent`], and never write it again.
     #[serde(default, rename = "accentColor", skip_serializing)]
@@ -1052,6 +1058,8 @@ impl Default for UiSettings {
             new_thread_background_effect: NewThreadBackgroundEffect::None,
             reduce_motion: crate::motion::ReduceMotion::System,
             pause_animations_in_background: false,
+            codex_voice: None,
+            codex_voice_device: None,
             legacy_accent_color: None,
         }
     }
@@ -1691,6 +1699,8 @@ impl UiSettings {
             new_thread_background_effect,
             reduce_motion,
             pause_animations_in_background,
+            codex_voice,
+            codex_voice_device,
             legacy_accent_color,
         );
         current
@@ -2618,6 +2628,8 @@ mod tests {
             dictation_enabled: false,
             dictation_input: Some("coreaudio:usb-mic".into()),
             window_geometry: None,
+            codex_voice: Some("ember".into()),
+            codex_voice_device: Some("fedora".into()),
             sidebar_width: 300.0,
             sidebar_collapsed: true,
             sidebar_grouped: true,
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index a30ddf15de..9c0162a8fc 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -24,7 +24,7 @@ use gpui::{
 
 use gpui_tokio::Tokio;
 use zeron_engine::InstanceLock;
-use zeron_proto::{AuthState, WorkspaceScope};
+use zeron_proto::{AuthState, ChatConfig, HarnessId, WorkspaceScope};
 use zeron_rpc::methods;
 
 use crate::changes::{Changes, ChangesEvent, DiscardWorkingTreeRequest};
@@ -78,6 +78,8 @@ mod sidebar_sections;
 pub(crate) mod spaces;
 use side_chats::SideChatTab;
 mod tabs;
+mod voice_stage;
+use voice_stage::VOICE_STAGE_ORB_SCALE;
 
 use spaces::{AddSpaceFlow, RenameSpaceDialog};
 
@@ -1819,6 +1821,24 @@ pub struct Shell {
     sidebar_pane: Entity<SidebarPane>,
     transcript: Entity<Transcript>,
     composer: Entity<Composer>,
+    /// The window's voice orchestrator: independent of the selected chat.
+    voice: Entity<crate::voice::VoiceController>,
+    /// Sidebar footer orb (session live) and the full-window stage's orb.
+    voice_footer_orb: Entity<crate::orb::Orb>,
+    voice_stage_orb: Entity<crate::orb::Orb>,
+    /// Above the composer, only while the orchestrator's own chat is open.
+    voice_composer_orb: Entity<crate::orb::Orb>,
+    /// The stage caption's streaming veil (shared with mobile).
+    voice_caption: zeron_veil::CaptionVeil,
+    voice_stage_focus: FocusHandle,
+    voice_stage_was_open: bool,
+    /// Last rendered route, used to distinguish navigation from staying in Settings.
+    voice_stage_route: Route,
+    voice_stage_changed_at: Option<std::time::Instant>,
+    /// The chat selected when the stage opened; picking another closes it.
+    voice_stage_selection: Option<String>,
+    _voice_observation: gpui::Subscription,
+    _voice_catalog: gpui::Subscription,
     /// Measured height of the bottom chrome stack (status strip + composer +
     /// terminal dock) the full-height transcript scrolls under. Paint-time
     /// measurement schedules another frame whenever this value changes.
@@ -2155,6 +2175,32 @@ impl Shell {
         let transcript = cx.new(|cx| Transcript::new(state.clone(), cx));
         transcript.update(cx, |transcript, _| transcript.retain_for_route_exit());
         let composer = cx.new(|cx| Composer::new(state.clone(), cx));
+        let voice = cx.new(|_| crate::voice::VoiceController::default());
+        let voice_footer_orb = cx.new(|_| {
+            crate::orb::Orb::new()
+                .size(crate::orb::OrbSize::Inline)
+                .state_transition(Duration::from_millis(300))
+                .visible(false)
+        });
+        let voice_stage_orb = cx.new(|_| {
+            crate::orb::Orb::new()
+                .size(crate::orb::OrbSize::Hero)
+                .state_transition(Duration::from_millis(300))
+                .scale(VOICE_STAGE_ORB_SCALE)
+                .visible(false)
+        });
+        let voice_composer_orb = cx.new(|_| {
+            crate::orb::Orb::new()
+                .size(crate::orb::OrbSize::Avatar)
+                .state_transition(Duration::from_millis(300))
+                .visible(false)
+        });
+        let voice_observation = cx.observe(&voice, |_: &mut Shell, _, cx| cx.notify());
+        // Settings → Agents installed or toggled Codex: voice follows.
+        let voice_catalog =
+            cx.observe_global::<crate::pickers::HarnessCatalogChanged>(|this: &mut Shell, cx| {
+                this.check_voice_codex(true, cx)
+            });
         let links = Self::session_links(None, cx);
         transcript.update(cx, |transcript, _| {
             transcript.set_workspace_link_handler(links)
@@ -2312,6 +2358,18 @@ impl Shell {
             sidebar_pane,
             transcript,
             composer,
+            voice,
+            voice_footer_orb,
+            voice_stage_orb,
+            voice_composer_orb,
+            voice_caption: zeron_veil::CaptionVeil::new(voice_stage::STAGE_CAPTION_CHARS),
+            voice_stage_focus: cx.focus_handle(),
+            voice_stage_was_open: false,
+            voice_stage_route: Route::Chat,
+            voice_stage_changed_at: None,
+            voice_stage_selection: None,
+            _voice_observation: voice_observation,
+            _voice_catalog: voice_catalog,
             // Seed with the compact composer stack's rough height so the
             // first frame's clearance isn't zero (the measure corrects it).
             bottom_stack: std::rc::Rc::new(std::cell::Cell::new(120.0)),
@@ -2548,6 +2606,16 @@ impl Shell {
     // ---- splash ----
 
     fn on_state_changed(&mut self, state: &Entity<AppState>, cx: &mut Context<Self>) {
+        // Voice is an orchestrator over every thread: navigation keeps it,
+        // only losing the engine that hosts it ends the session.
+        if self.voice.read(cx).chat_id.is_some()
+            && state
+                .read(cx)
+                .engine()
+                .is_none_or(|engine| !self.voice.read(cx).belongs_to(engine))
+        {
+            self.voice.update(cx, |voice, cx| voice.cancel(cx));
+        }
         self.prune_file_explorers(cx);
         self.refresh_harness_update_watch(cx);
         if state.read(cx).engine().is_none() {
@@ -2679,7 +2747,7 @@ impl Shell {
                         let send_pending = state.send_pending(&s.chat_id, now);
                         let chat = state.chats.iter().find(|c| c.id == s.chat_id);
                         let title = chat.and_then(|c| c.title.clone());
-                        let notify = chat.is_some_and(|c| c.parent_chat_id.is_none());
+                        let notify = chat.is_some_and(|c| c.is_top_level());
                         (s.chat_id.clone(), status, send_pending, title, notify)
                     })
                     .collect();
@@ -4104,7 +4172,8 @@ impl Shell {
     ) {
         let was_active = self.resolved_right_active(cx) == surface;
         let restore_focus = was_active && self.navigation_focus.in_right(window, cx);
-        self.navigation_focus.remember(&self.shortcut_focus, window, cx);
+        self.navigation_focus
+            .remember(&self.shortcut_focus, window, cx);
         let key = self.panel_key(cx);
         let files = match surface {
             RightSurface::File(id) => self.file_surfaces.get(&id).cloned(),
@@ -4952,7 +5021,38 @@ impl Shell {
                     None => Empty.into_any_element(),
                 }
             }
-            SettingsSection::Voice => crate::dictation::card(cx).into_any_element(),
+            SettingsSection::Voice => {
+                let card = crate::dictation::card(cx);
+                let state = self.state.read(cx);
+                let mut hosts = vec![(None, "This device".to_owned(), true, "Local".to_owned())];
+                for device in &state.devices {
+                    if state.local_device_id.as_deref() == Some(&device.id) {
+                        continue;
+                    }
+                    let online = state.device_online(&device.id, chrono::Utc::now());
+                    let compatible = device.supports(zeron_proto::voice::remote::CAPABILITY);
+                    let detail = if !online {
+                        "Offline"
+                    } else if !compatible {
+                        "Update Zeron to use remote voice"
+                    } else {
+                        "Available"
+                    };
+                    hosts.push((
+                        Some(device.id.clone()),
+                        device.name.clone(),
+                        online && compatible,
+                        detail.into(),
+                    ));
+                }
+                let live = self.voice.read(cx).is_live();
+                card.update(cx, |card, cx| card.set_hosts(hosts, live, cx));
+                if let Some(snapshot) = &self.voice.read(cx).snapshot {
+                    let voices = snapshot.voices.clone();
+                    card.update(cx, |card, cx| card.set_voices(&voices, cx));
+                }
+                card.into_any_element()
+            }
             SettingsSection::Shortcuts | SettingsSection::General | SettingsSection::Appshots => {
                 if self.shortcuts_page.is_none() {
                     let state = self.state.clone();
@@ -5489,6 +5589,7 @@ impl Shell {
     /// the keys it records before they can dispatch.
     pub(super) fn overlay_owns_keyboard(&self, cx: &App) -> bool {
         self.command_palette.is_some()
+            || self.voice.read(cx).stage_open
             || self.section_dialog.is_some()
             || self.section_menu.is_some()
             || self.add_space.is_some()
@@ -6406,13 +6507,14 @@ impl Shell {
         // leave two competing + placements across the responsive variants.
         let plus_alpha = self.titlebar_plus_alpha(cx);
         let show_plus = plus_alpha > 0.01;
+        let over_artwork = settings::current(cx)
+            .new_thread_composer_background
+            .as_ref()
+            .is_some_and(|background| std::path::Path::new(&background.path).is_file());
         let island_target = if matches!(self.route, Route::Chat)
-            && self.state.read(cx).selected_chat.is_none()
+            && (self.state.read(cx).selected_chat.is_none() || self.voice.read(cx).stage_open)
             && self.settings.sidebar_collapsed
-            && settings::current(cx)
-                .new_thread_composer_background
-                .as_ref()
-                .is_some_and(|background| std::path::Path::new(&background.path).is_file())
+            && over_artwork
         {
             1.0
         } else {
@@ -7021,6 +7123,7 @@ impl Shell {
                     // carries the titlebar clearance inside the scroll.
                     .flex()
                     .flex_col()
+                    .opacity(self.voice_stage_underlay_opacity(cx))
                     .child(div().flex_1().min_h_0().child(outlet)),
             )
             .child(
@@ -7996,13 +8099,19 @@ impl Shell {
         use zeron_proto::ConnectivityState as S;
         let conn = self.state.read(cx).connectivity.clone();
         let selected = self.state.read(cx).selected_chat.as_deref();
-        let chat = conn.chats.iter()
+        let chat = conn
+            .chats
+            .iter()
             .find(|c| Some(c.chat_id.as_str()) == selected);
         let chat_state = chat.map(|c| c.sync_state);
         let (label, glyph): (SharedString, AnyElement) = match conn.state {
             _ if chat_state == Some(zeron_proto::ChatSyncState::StorageError) => (
                 "Changes could not be saved".into(),
-                div().size(px(5.0)).rounded_full().bg(theme.warning).into_any_element(),
+                div()
+                    .size(px(5.0))
+                    .rounded_full()
+                    .bg(theme.warning)
+                    .into_any_element(),
             ),
             S::Disabled => return None,
             S::Connected => {
@@ -8010,9 +8119,13 @@ impl Shell {
                 (
                     caption.into(),
                     loaders::mini_mono_spinner(
-                        "chat-sync-spinner", 2.0, theme.text_muted,
-                        self.sidebar_pane.entity_id(), cx,
-                    ).into_any_element(),
+                        "chat-sync-spinner",
+                        2.0,
+                        theme.text_muted,
+                        self.sidebar_pane.entity_id(),
+                        cx,
+                    )
+                    .into_any_element(),
                 )
             }
             S::Offline => (
@@ -8265,7 +8378,6 @@ impl Shell {
         // t3code's archived accordion, below the active list.
         let archived_section = self.render_archived_section(theme, cx);
 
-
         // The space filter lives ABOVE the scroll region (fixed) so its
         // dropdown can float without being clipped by the list's overflow.
         let filter_row = self.render_spaces_filter(theme, cx);
@@ -9040,6 +9152,7 @@ impl Shell {
             (true, true) => "Close settings · ⌘,".into(),
             (true, false) => "Close settings · Ctrl+,".into(),
         };
+        let voice_trigger = self.render_voice_trigger(theme, cx);
         div()
             .w_full()
             .flex()
@@ -9049,55 +9162,61 @@ impl Shell {
             .child(trigger)
             .child(
                 div()
-                    .id("settings-trigger")
-                    .debug_selector(|| "settings-trigger".into())
-                    .role(gpui::Role::Button)
-                    .aria_label(if settings_open {
-                        "Close settings"
-                    } else {
-                        "Settings"
-                    })
-                    .aria_toggled(if settings_open {
-                        gpui::Toggled::True
-                    } else {
-                        gpui::Toggled::False
-                    })
-                    .tooltip(move |_, cx| {
-                        let text = settings_tooltip.clone();
-                        cx.new(|_| SurfaceTabTooltip { text }).into()
-                    })
-                    .tab_index(0)
-                    .size(px(SIDEBAR_FOOTER_BUTTON_SIZE))
-                    .flex_none()
-                    .rounded(px(8.0))
                     .flex()
+                    .flex_none()
                     .items_center()
-                    .justify_center()
-                    .cursor_pointer()
-                    .bg(if settings_open {
-                        theme.glass_hover()
-                    } else {
-                        motion::hover_blend(
-                            "settings-trigger",
-                            theme.glass_hover().opacity(0.0),
-                            theme.glass_hover(),
-                        )
-                    })
-                    .on_hover(motion::hover_listener("settings-trigger"))
-                    .focus_visible(|s| s.border_2().border_color(theme.accent))
-                    .on_click(cx.listener(|this, _, _, cx| this.toggle_settings(cx)))
+                    .gap(px(2.0))
+                    .children(voice_trigger)
                     .child(
-                        icon(icons::SETTINGS)
-                            .size(px(15.0))
-                            .text_color(if settings_open {
-                                theme.text
+                        div()
+                            .id("settings-trigger")
+                            .debug_selector(|| "settings-trigger".into())
+                            .role(gpui::Role::Button)
+                            .aria_label(if settings_open {
+                                "Close settings"
+                            } else {
+                                "Settings"
+                            })
+                            .aria_toggled(if settings_open {
+                                gpui::Toggled::True
+                            } else {
+                                gpui::Toggled::False
+                            })
+                            .tooltip(move |_, cx| {
+                                let text = settings_tooltip.clone();
+                                cx.new(|_| SurfaceTabTooltip { text }).into()
+                            })
+                            .tab_index(0)
+                            .size(px(SIDEBAR_FOOTER_BUTTON_SIZE))
+                            .flex_none()
+                            .rounded(px(8.0))
+                            .flex()
+                            .items_center()
+                            .justify_center()
+                            .cursor_pointer()
+                            .bg(if settings_open {
+                                theme.glass_hover()
                             } else {
                                 motion::hover_blend(
                                     "settings-trigger",
-                                    theme.text_muted,
-                                    theme.text,
+                                    theme.glass_hover().opacity(0.0),
+                                    theme.glass_hover(),
                                 )
-                            }),
+                            })
+                            .on_hover(motion::hover_listener("settings-trigger"))
+                            .focus_visible(|s| s.border_2().border_color(theme.accent))
+                            .on_click(cx.listener(|this, _, _, cx| this.toggle_settings(cx)))
+                            .child(icon(icons::SETTINGS).size(px(15.0)).text_color(
+                                if settings_open {
+                                    theme.text
+                                } else {
+                                    motion::hover_blend(
+                                        "settings-trigger",
+                                        theme.text_muted,
+                                        theme.text,
+                                    )
+                                },
+                            )),
                     ),
             )
             .into_any_element()
@@ -9565,6 +9684,11 @@ impl Shell {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
+        if event.keystroke.key == "escape" && self.voice.read(cx).stage_open {
+            self.set_voice_stage_open(false, cx);
+            cx.stop_propagation();
+            return;
+        }
         if event.keystroke.key == "escape" && self.sidebar_session_transfer.is_some() {
             cx.stop_active_drag(window);
             self.cancel_sidebar_session_transfer(cx);
@@ -10476,6 +10600,7 @@ impl Shell {
                         .absolute()
                         .inset_0(),
                     )
+                    .children(self.render_voice_composer_orb(composer_width, cx))
                     .child(status)
                     .when(has_spaces || no_project || has_appshots, |el| {
                         let composer_opacity = self.composer_dock.borrow().opacity();
@@ -11382,22 +11507,20 @@ impl Shell {
                 // up the carve-out. The bubble dispatch reaches the chip
                 // before the strip, and the handler consumes the drag, so
                 // the two never double-apply.
-                .on_drop::<RightTabDrag>(cx.listener(
-                    move |this, payload: &RightTabDrag, _, cx| {
-                        if payload.panel_key != this.panel_key(cx) {
-                            this.right_tab_drag = None;
-                            cx.notify();
-                            return;
-                        }
-                        let to = this
-                            .right_tab_drag
-                            .as_ref()
-                            .map(|d| d.over)
-                            .unwrap_or(payload.from);
+                .on_drop::<RightTabDrag>(cx.listener(move |this, payload: &RightTabDrag, _, cx| {
+                    if payload.panel_key != this.panel_key(cx) {
                         this.right_tab_drag = None;
-                        this.reorder_right_tabs(payload.from, to, cx);
-                    },
-                ))
+                        cx.notify();
+                        return;
+                    }
+                    let to = this
+                        .right_tab_drag
+                        .as_ref()
+                        .map(|d| d.over)
+                        .unwrap_or(payload.from);
+                    this.right_tab_drag = None;
+                    this.reorder_right_tabs(payload.from, to, cx);
+                }))
                 .child(
                     // Leading slot: the surface's icon.
                     div()
@@ -12450,6 +12573,7 @@ impl Render for Shell {
             files.update(cx, |files, cx| files.suspend_tree_interactions(cx));
         }
         settings::wallpaper::preload(cx);
+        self.sync_voice_stage(window, cx);
         self.navigation_focus
             .remember(&self.shortcut_focus, window, cx);
         if let Some(command) = self.pending_workspace_command.take() {
@@ -12634,6 +12758,9 @@ impl Render for Shell {
                         // at once when a check is due by the wall clock.
                         update.read(cx).poke();
                     }
+                    if window.is_window_active() && !this.voice.read(cx).offered() {
+                        this.check_voice_codex(true, cx);
+                    }
                     if !window.is_window_active() {
                         this.reset_command_palette_key_state();
                         this.set_jump_hints(false, cx);
@@ -12886,6 +13013,8 @@ impl Render for Shell {
                 // for the return trip.
                 if let Route::Settings(section) = self.route {
                     let settings_page = self.render_settings_page(section, window, cx);
+                    // A call started from Settings opens its stage here too.
+                    let voice_stage = self.render_voice_stage(window, cx);
                     let overlays = self.render_overlays(window.viewport_size(), window, cx);
                     let border_color = Theme::of(cx).border;
                     let sidebar_tone =
@@ -12904,6 +13033,7 @@ impl Render for Shell {
                         .size_full()
                         .relative()
                         .child(settings_page)
+                        .children(voice_stage)
                         .child(drag)
                         .children(overlays);
                     break 'ready root
@@ -13004,6 +13134,9 @@ impl Render for Shell {
                 };
                 let files_panel = self.render_files_panel(window, cx);
                 let overlays = self.render_overlays(window.viewport_size(), window, cx);
+                // Full-window voice stage: above the page chrome, below dialogs.
+                let voice_stage = self.render_voice_stage(window, cx);
+                let under_stage = self.voice_stage_underlay_opacity(cx);
                 // Copied out (not held) — `render_title_bar` needs `cx` mutable.
                 let border_color = Theme::of(cx).border;
                 // No inset cards (user request): the conversation column sits
@@ -13027,6 +13160,7 @@ impl Render for Shell {
                     .flex()
                     .flex_row()
                     .overflow_hidden()
+                    .opacity(under_stage)
                     .child(main)
                     .into_any_element();
                 // The whole app page is one keyed `animate-in` entrance (zeron
@@ -13092,6 +13226,7 @@ impl Render for Shell {
                                     .h_full()
                                     .flex_none()
                                     .relative()
+                                    .opacity(under_stage)
                                     .child(
                                         div()
                                             .h_full()
@@ -13103,7 +13238,18 @@ impl Render for Shell {
                                     .child(right_seam),
                             ),
                     )
-                    .child(div().absolute().top_0().left_0().right_0().child(title_bar))
+                    .child(
+                        div()
+                            .absolute()
+                            .top_0()
+                            .left_0()
+                            .right_0()
+                            .opacity(under_stage)
+                            .child(title_bar),
+                    )
+                    // The stage covers the conversation's titlebar but never
+                    // the cluster: the sidebar toggle and navigation stay live.
+                    .children(voice_stage)
                     .child(self.render_titlebar_cluster(cx))
                     .children(overlays);
                 root.child(sidebar_tone)
@@ -13288,17 +13434,26 @@ mod tests {
 
         chat.sync_state = S::Waiting;
         chat.connected = false;
-        assert_eq!(chat_sync_pill_caption(&chat), Some("Sync queued — changes are saved"));
+        assert_eq!(
+            chat_sync_pill_caption(&chat),
+            Some("Sync queued — changes are saved")
+        );
         chat.sync_state = S::Connecting;
         assert_eq!(chat_sync_pill_caption(&chat), Some("Syncing…"));
         chat.sync_state = S::Offline;
-        assert_eq!(chat_sync_pill_caption(&chat), Some("Offline — changes are saved"));
+        assert_eq!(
+            chat_sync_pill_caption(&chat),
+            Some("Offline — changes are saved")
+        );
 
         // Real pending pushes remain visible even with a live room.
         chat.connected = true;
         chat.pending_pushes = 1;
         chat.sync_state = S::Waiting;
-        assert_eq!(chat_sync_pill_caption(&chat), Some("Sync queued — changes are saved"));
+        assert_eq!(
+            chat_sync_pill_caption(&chat),
+            Some("Sync queued — changes are saved")
+        );
         chat.sync_state = S::Connecting;
         assert_eq!(chat_sync_pill_caption(&chat), Some("Syncing…"));
     }
@@ -14796,7 +14951,8 @@ mod exit_regressions {
                     settings::update(settings::SavePolicy::Immediate, cx, |settings| {
                         settings.wallpaper_folder = Some(dir.path().join("wallpapers"));
                         settings.wallpaper_source = Some(dir.path().join("wallpapers/current.png"));
-                        settings.wallpaper_history = vec![dir.path().join("wallpapers/current.png")];
+                        settings.wallpaper_history =
+                            vec![dir.path().join("wallpapers/current.png")];
                         settings.window_geometry = geometry;
                         settings.open_web_links_in_zeron = open_links_in_zeron;
                         settings.terminal_font_family = terminal_family.clone();
@@ -14818,8 +14974,14 @@ mod exit_regressions {
                         shell.settings.terminal_height = 300.0 + step as f32;
                         shell.schedule_save(cx);
                         let current = settings::current(cx);
-                        assert_eq!(current.wallpaper_history, vec![dir.path().join("wallpapers/current.png")]);
-                        assert_eq!(current.wallpaper_folder, Some(dir.path().join("wallpapers")));
+                        assert_eq!(
+                            current.wallpaper_history,
+                            vec![dir.path().join("wallpapers/current.png")]
+                        );
+                        assert_eq!(
+                            current.wallpaper_folder,
+                            Some(dir.path().join("wallpapers"))
+                        );
                         assert_eq!(
                             current.wallpaper_source,
                             Some(dir.path().join("wallpapers/current.png"))
@@ -14847,7 +15009,10 @@ mod exit_regressions {
                     settings::flush(cx);
                     let loaded = settings::UiSettings::load(dir.path());
                     assert_eq!(loaded.window_geometry, geometry);
-                    assert_eq!(loaded.wallpaper_history, vec![dir.path().join("wallpapers/current.png")]);
+                    assert_eq!(
+                        loaded.wallpaper_history,
+                        vec![dir.path().join("wallpapers/current.png")]
+                    );
                     assert_eq!(loaded.wallpaper_folder, Some(dir.path().join("wallpapers")));
                     assert_eq!(
                         loaded.wallpaper_source,
@@ -15100,6 +15265,7 @@ mod exit_regressions {
                 settings::update(SavePolicy::Immediate, cx, |settings| {
                     settings.dictation_enabled = true;
                     settings.dictation_input = Some("coreaudio:usb".into());
+                    settings.codex_voice = Some("ember".into());
                     settings.transcript_compact_mode = true;
                     settings.code_fences_fit_content = true;
                     settings.diff_split = true;
@@ -15112,6 +15278,7 @@ mod exit_regressions {
                 let saved = settings::current(cx);
                 assert!(saved.dictation_enabled);
                 assert_eq!(saved.dictation_input.as_deref(), Some("coreaudio:usb"));
+                assert_eq!(saved.codex_voice.as_deref(), Some("ember"));
                 assert!(saved.transcript_compact_mode);
                 assert!(saved.code_fences_fit_content);
                 assert!(saved.diff_split);
@@ -15122,11 +15289,13 @@ mod exit_regressions {
                 // once the Shell has nothing newer of its own.
                 settings::update(SavePolicy::Immediate, cx, |settings| {
                     settings.dictation_enabled = false;
+                    settings.codex_voice = None;
                     settings.sidebar_width = 320.0;
                 });
                 shell.schedule_save(cx);
                 let saved = settings::current(cx);
                 assert!(!saved.dictation_enabled);
+                assert_eq!(saved.codex_voice, None);
                 assert_eq!(saved.sidebar_width, 320.0);
                 assert_eq!(shell.settings.sidebar_width, 320.0);
             })
@@ -17086,6 +17255,38 @@ mod settings_modal_regressions {
             .unwrap();
     }
 
+    #[gpui::test]
+    fn voice_stage_opens_over_settings(cx: &mut TestAppContext) {
+        let dir = tempfile::tempdir().unwrap();
+        init_settings_test(settings::UiSettings::default(), dir.path(), cx);
+        let (shell, cx) = cx.add_window_view(|_, cx| test_shell(dir.path(), cx));
+        shell.update(cx, |shell, cx| {
+            shell.debug_gate = Some(GatePhase::Ready);
+            shell.reduced_motion = true;
+            shell.open_settings(SettingsSection::Voice, cx);
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear());
+        assert!(cx.debug_bounds("voice-stage").is_none());
+
+        shell.update(cx, |shell, cx| {
+            shell.voice.update(cx, |voice, _| {
+                voice.phase = zeron_proto::voice::VoicePhase::Active
+            });
+            shell.set_voice_stage_open(true, cx);
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        let stage = cx
+            .debug_bounds("voice-stage")
+            .expect("stage renders in Settings");
+        shell.read_with(cx, |shell, cx| {
+            assert!(matches!(shell.route, Route::Settings(_)));
+            assert!(shell.voice.read(cx).stage_open);
+            // The settings sidebar stays usable beside the stage.
+            assert_eq!(f32::from(stage.origin.x), shell.settings.sidebar_width);
+        });
+    }
+
     #[gpui::test]
     fn escape_closes_what_is_open_inside_settings_before_settings(cx: &mut TestAppContext) {
         let dir = tempfile::tempdir().unwrap();
diff --git a/crates/ui/src/shell/command_palette.rs b/crates/ui/src/shell/command_palette.rs
index 25b79e41a2..6798adfe2e 100644
--- a/crates/ui/src/shell/command_palette.rs
+++ b/crates/ui/src/shell/command_palette.rs
@@ -146,7 +146,7 @@ impl Shell {
         let mut chats: Vec<_> = state
             .chats
             .iter()
-            .filter(|chat| chat.parent_chat_id.is_none())
+            .filter(|chat| chat.is_top_level())
             .filter(|chat| {
                 let project = state
                     .space_for_chat(chat)
diff --git a/crates/ui/src/shell/navigation_focus.rs b/crates/ui/src/shell/navigation_focus.rs
index a20ce5b0d5..5c80ab3fa2 100644
--- a/crates/ui/src/shell/navigation_focus.rs
+++ b/crates/ui/src/shell/navigation_focus.rs
@@ -95,6 +95,8 @@ impl Shell {
                 self.navigation_focus.right.clone(),
                 self.navigation_focus.right.clone(),
             )
+        } else if self.voice.read(cx).stage_open {
+            (self.voice_stage_focus.clone(), self.unfocused.clone())
         } else {
             (self.composer.focus_handle(cx), self.unfocused.clone())
         }
diff --git a/crates/ui/src/shell/spaces.rs b/crates/ui/src/shell/spaces.rs
index de9b56ad0e..9f52147dad 100644
--- a/crates/ui/src/shell/spaces.rs
+++ b/crates/ui/src/shell/spaces.rs
@@ -5326,7 +5326,7 @@ impl Shell {
             .iter()
             // Spawned children stay out of the Archived section too — the
             // same top-level rule as `visible_chats`.
-            .filter(|c| c.archived && c.parent_chat_id.is_none())
+            .filter(|c| c.archived && c.is_top_level())
             .filter(|chat| in_filter(chat))
             .cloned()
             .collect();
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index 47ad1874b1..4b788a3376 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -205,6 +205,9 @@ impl Shell {
     /// Open a session from the sidebar: select it, the main area follows.
     pub(crate) fn open_chat(&mut self, chat_id: String, cx: &mut Context<Self>) {
         self.command_palette = None;
+        // Opening any session steps the voice stage aside — including the one
+        // already selected under it. The call keeps running in the background.
+        self.set_voice_stage_open(false, cx);
         self.route = Route::Chat;
         self.focus_composer(cx);
         self.state
@@ -224,6 +227,7 @@ impl Shell {
     /// canvas on that project and wins over the sidebar filter.
     pub(super) fn open_new_session(&mut self, project: Option<String>, cx: &mut Context<Self>) {
         self.command_palette = None;
+        self.set_voice_stage_open(false, cx);
         self.route = Route::Chat;
         self.focus_composer(cx);
         // Pre-hide before the selection flips so the state change can't
diff --git a/crates/ui/src/shell/voice_stage.rs b/crates/ui/src/shell/voice_stage.rs
new file mode 100644
index 0000000000..5e1ed96de9
--- /dev/null
+++ b/crates/ui/src/shell/voice_stage.rs
@@ -0,0 +1,1120 @@
+//! The voice orchestrator's chrome: the sidebar footer trigger and the
+//! full-window stage. A voice session follows no chat selection, so neither
+//! surface lives inside the conversation column — the user moves between
+//! threads freely while the orchestrator keeps listening.
+
+use super::*;
+use zeron_proto::voice::{VoicePhase, VoiceWork};
+
+/// The stage paints the hero preset magnified to fill the canvas.
+pub(super) const VOICE_STAGE_ORB_SCALE: f32 = 2.25;
+/// Stage orb footprint, including breathing room around the artwork.
+const STAGE_ORB_BOX: f32 = 128.0 * VOICE_STAGE_ORB_SCALE + 112.0;
+const STAGE_ENTER_MS: f32 = 460.0;
+const STAGE_EXIT_MS: f32 = 220.0;
+/// Captions show the tail of a long utterance rather than wrapping off-stage.
+pub(super) const STAGE_CAPTION_CHARS: usize = 160;
+const FOOTER_HOVER: &str = "voice-footer-orb";
+/// Call-bar geometry: round controls inside a floating pill.
+const BAR_CONTROL: f32 = 44.0;
+const BAR_PAD: f32 = 8.0;
+
+/// Stage visibility for a transition that flipped `elapsed_ms` ago.
+pub(super) fn stage_reveal(open: bool, elapsed_ms: f32, reduced: bool) -> f32 {
+    match (open, reduced) {
+        (true, true) => 1.0,
+        (false, true) => 0.0,
+        (true, false) => motion::EASE_OUT_EXPO.eval(elapsed_ms / STAGE_ENTER_MS),
+        (false, false) => 1.0 - motion::EASE.eval(elapsed_ms / STAGE_EXIT_MS),
+    }
+}
+
+impl Shell {
+    /// The footer microphone: a new orchestrator in a projectless Codex chat
+    /// on this device. The chat's model follows the composer when it already
+    /// targets Codex; otherwise Codex's own default model runs the delegations.
+    pub(super) fn start_voice(&mut self, cx: &mut Context<Self>) {
+        let state = self.state.read(cx);
+        let (Some(engine), Some(device)) = (state.engine().cloned(), state.local_device_id.clone())
+        else {
+            return;
+        };
+        let config = self
+            .composer
+            .read(cx)
+            .pickers()
+            .read(cx)
+            .resolved(cx)
+            .chat_config()
+            .filter(|config| config.harness == HarnessId::Codex)
+            .unwrap_or_else(|| ChatConfig {
+                harness: HarnessId::Codex,
+                model: None,
+                reasoning: None,
+                model_options: Default::default(),
+                sandbox: zeron_proto::SandboxLevel::WorkspaceWrite,
+            });
+        let saved = settings::current(cx);
+        let device = saved.codex_voice_device.unwrap_or(device);
+        let voice = saved.codex_voice;
+        let host_name = state
+            .device_name(&device)
+            .unwrap_or("This device")
+            .to_owned();
+        self.voice.update(cx, |controller, cx| {
+            controller.start(engine, device, config, voice, cx);
+            controller.host_name = Some(host_name);
+            controller.set_stage_open(true, cx);
+        });
+    }
+
+    /// Read whether this device's Codex can take a call; `force` re-reads it
+    /// after Settings → Agents changes or on coming back to a window that
+    /// hides voice (Codex may have been installed meanwhile).
+    pub(super) fn check_voice_codex(&mut self, force: bool, cx: &mut Context<Self>) {
+        let Some(engine) = self.state.read(cx).engine().cloned() else {
+            return;
+        };
+        self.voice
+            .update(cx, |voice, cx| voice.check_codex(&engine, force, cx));
+    }
+
+    pub(super) fn end_voice(&mut self, cx: &mut Context<Self>) {
+        self.voice.update(cx, |voice, cx| voice.cancel(cx));
+    }
+
+    pub(super) fn set_voice_stage_open(&mut self, open: bool, cx: &mut Context<Self>) {
+        self.voice
+            .update(cx, |voice, cx| voice.set_stage_open(open, cx));
+    }
+
+    /// Track stage open/close flips for the transition clock and hand focus
+    /// over: the stage owns the keyboard while it is up. Navigating to
+    /// another thread or to Settings steps the stage aside; voice continues.
+    pub(super) fn sync_voice_stage(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let selected = self.state.read(cx).selected_chat.clone();
+        let navigating_to_settings =
+            self.route != self.voice_stage_route && matches!(self.route, Route::Settings(_));
+        // Record every render, even with no visibility change: leaving and
+        // reentering the same settings page must count as navigation too.
+        self.voice_stage_route = self.route;
+        if self.voice.read(cx).stage_open
+            && self.voice_stage_was_open
+            && (navigating_to_settings || selected != self.voice_stage_selection)
+        {
+            self.set_voice_stage_open(false, cx);
+        }
+        let open = self.voice.read(cx).stage_open;
+        if open == self.voice_stage_was_open {
+            return;
+        }
+        self.voice_stage_was_open = open;
+        self.voice_stage_selection = selected;
+        self.voice_stage_changed_at = Some(std::time::Instant::now());
+        let focus = if open {
+            self.voice_stage_focus.clone()
+        } else {
+            self.composer.focus_handle(cx)
+        };
+        if window.is_window_active() {
+            window.focus(&focus, cx);
+        }
+    }
+
+    pub(super) fn render_voice_trigger(
+        &mut self,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        self.check_voice_codex(false, cx);
+        let voice = self.voice.read(cx);
+        // Without Codex on this device a call could only fail.
+        if !voice.offered() {
+            return None;
+        }
+        let live = voice.is_live();
+        let stage_open = voice.stage_open;
+        let failure = (voice.phase == VoicePhase::Failed)
+            .then(|| voice.reason_text())
+            .filter(|text| !text.is_empty());
+        let (orb_state, microphone, speaker) = (
+            voice.orb_state(),
+            voice.microphone_level(),
+            voice.speaker_level(),
+        );
+        let reduced = self.reduced_motion;
+        self.voice_footer_orb.update(cx, |orb, cx| {
+            orb.set_visible(live, cx);
+            orb.set_state(orb_state, cx);
+            orb.set_audio_levels(microphone, speaker, cx);
+            orb.set_reduced_motion(reduced, cx);
+        });
+
+        let button = div()
+            .id("voice-trigger")
+            .debug_selector(|| "voice-trigger".into())
+            .role(gpui::Role::Button)
+            .tab_index(0)
+            .relative()
+            .size(px(SIDEBAR_FOOTER_BUTTON_SIZE))
+            .flex_none()
+            .rounded(px(8.0))
+            .flex()
+            .items_center()
+            .justify_center()
+            .cursor_pointer()
+            .bg(motion::hover_blend(
+                FOOTER_HOVER,
+                theme.glass_hover().opacity(0.0),
+                theme.glass_hover(),
+            ))
+            .on_hover(motion::hover_listener(FOOTER_HOVER))
+            .focus_visible(|s| s.border_2().border_color(theme.accent));
+
+        if live {
+            return button
+                .aria_label(if stage_open {
+                    "Hide voice"
+                } else {
+                    "Open voice"
+                })
+                .tooltip(stage_tooltip(if stage_open {
+                    "Hide voice · Esc"
+                } else {
+                    "Voice is live · open"
+                }))
+                .on_click(
+                    cx.listener(move |this, _, _, cx| this.set_voice_stage_open(!stage_open, cx)),
+                )
+                .child(self.voice_footer_orb.clone())
+                .into_any_element()
+                .into();
+        }
+
+        let tooltip: SharedString = failure
+            .map(SharedString::from)
+            .unwrap_or_else(|| "Start voice · Codex orchestrator".into());
+        let button = button
+            .aria_label("Start voice")
+            .tooltip(move |_, cx| {
+                let text = tooltip.clone();
+                cx.new(|_| SurfaceTabTooltip { text }).into()
+            })
+            .on_click(cx.listener(|this, _, _, cx| this.start_voice(cx)))
+            .child(
+                icon(icons::MICROPHONE)
+                    .size(px(15.0))
+                    .text_color(motion::hover_blend(
+                        FOOTER_HOVER,
+                        theme.text_muted,
+                        theme.text,
+                    )),
+            );
+        let Some(failure) = failure else {
+            return Some(button.into_any_element());
+        };
+        // A failed start explains itself once, anchored to the microphone;
+        // the next press retries.
+        let popup_theme = theme.for_popup();
+        let card = popover::popover_card(&popup_theme)
+            .w(px(232.0))
+            .flex()
+            .flex_row()
+            .items_start()
+            .gap(px(8.0))
+            .child(
+                icon(icons::DANGER_TRIANGLE)
+                    .mt(px(1.0))
+                    .size(px(14.0))
+                    .text_color(popup_theme.warning),
+            )
+            .child(
+                div()
+                    .flex_1()
+                    .min_w_0()
+                    .text_size(crate::typography::ui_rems(12.0))
+                    .text_color(popup_theme.text_muted)
+                    .child(SharedString::from(failure)),
+            )
+            .child(
+                div()
+                    .id("voice-failure-dismiss")
+                    .flex_none()
+                    .cursor_pointer()
+                    .rounded(px(4.0))
+                    .on_click(cx.listener(|this, _, _, cx| {
+                        cx.stop_propagation();
+                        this.voice.update(cx, |voice, cx| voice.dismiss_reason(cx));
+                    }))
+                    .child(
+                        icon(icons::CLOSE)
+                            .size(px(14.0))
+                            .text_color(popup_theme.text_faint),
+                    ),
+            )
+            .into_any_element();
+        button
+            .child(
+                div()
+                    .absolute()
+                    .top(px(4.0))
+                    .right(px(4.0))
+                    .size(px(5.0))
+                    .rounded_full()
+                    .bg(theme.warning),
+            )
+            .child(popover::anchored_menu_above_end(
+                "voice-failure",
+                card,
+                None,
+            ))
+            .into_any_element()
+            .into()
+    }
+
+    /// The live orb above the orchestrator chat's composer. Every other chat
+    /// keeps its plain composer; pressing the orb returns to the stage.
+    pub(super) fn render_voice_composer_orb(
+        &mut self,
+        composer_width: f32,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        let voice = self.voice.read(cx);
+        let shown = matches!(self.route, Route::Chat)
+            && voice.is_live()
+            && voice.chat_id.is_some()
+            && voice.chat_id == self.state.read(cx).selected_chat;
+        let (orb_state, microphone, speaker) = (
+            voice.orb_state(),
+            voice.microphone_level(),
+            voice.speaker_level(),
+        );
+        let reduced = self.reduced_motion;
+        self.voice_composer_orb.update(cx, |orb, cx| {
+            orb.set_visible(shown, cx);
+            orb.set_state(orb_state, cx);
+            orb.set_audio_levels(microphone, speaker, cx);
+            orb.set_reduced_motion(reduced, cx);
+        });
+        if !shown {
+            return None;
+        }
+        let orb = div()
+            .id("voice-composer-orb")
+            .debug_selector(|| "voice-composer-orb".into())
+            .role(gpui::Role::Button)
+            .aria_label("Open voice")
+            .tab_index(0)
+            .rounded_full()
+            .cursor_pointer()
+            .tooltip(stage_tooltip("Open voice"))
+            .on_click(cx.listener(|this, _, _, cx| this.set_voice_stage_open(true, cx)))
+            .child(self.voice_composer_orb.clone());
+        Some(
+            motion::fade_in(
+                "voice-composer-orb-in",
+                div()
+                    .w_full()
+                    .max_w(px(composer_width))
+                    .mx_auto()
+                    .pb(px(4.0))
+                    .flex()
+                    .justify_center()
+                    .child(orb),
+            )
+            .into_any_element(),
+        )
+    }
+
+    /// How far the stage has arrived: 0 hidden, 1 fully covering the page.
+    pub(super) fn voice_stage_reveal(&self, cx: &App) -> f32 {
+        let elapsed = self
+            .voice_stage_changed_at
+            .map_or(f32::INFINITY, |at| at.elapsed().as_secs_f32() * 1000.0);
+        stage_reveal(self.voice.read(cx).stage_open, elapsed, self.reduced_motion)
+    }
+
+    /// Opacity for the page the stage covers. A glass stage has no fill, so
+    /// what it covers fades out and only the window frost shows through.
+    pub(super) fn voice_stage_underlay_opacity(&self, cx: &App) -> f32 {
+        if Theme::of(cx).is_glass() {
+            1.0 - self.voice_stage_reveal(cx)
+        } else {
+            1.0
+        }
+    }
+
+    /// Full-window stage: the session's orb over the new-thread hero artwork,
+    /// live caption, and the session controls. Escape returns to the chats
+    /// without ending voice.
+    pub(super) fn render_voice_stage(
+        &mut self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<AnyElement> {
+        let open = self.voice.read(cx).stage_open;
+        let reveal = self.voice_stage_reveal(cx);
+        if reveal > 0.0 && reveal < 1.0 {
+            self.motion_active.set(true);
+        }
+        let voice = self.voice.read(cx);
+        let (orb_state, microphone, speaker) = (
+            voice.orb_state(),
+            voice.microphone_level(),
+            voice.speaker_level(),
+        );
+        let (caption_item, partial) = (
+            voice.caption_item().map(str::to_owned),
+            voice.caption.text().to_owned(),
+        );
+        let snapshot = voice.snapshot.clone();
+        let chat_id = voice.chat_id.clone();
+        let awaiting = snapshot
+            .as_ref()
+            .is_some_and(|s| s.work == VoiceWork::AwaitingInput);
+        let reduced = self.reduced_motion;
+        self.voice_stage_orb.update(cx, |orb, cx| {
+            orb.set_visible(open, cx);
+            orb.set_state(orb_state, cx);
+            orb.set_audio_levels(microphone, speaker, cx);
+            orb.set_reduced_motion(reduced, cx);
+            // The orb blooms out of the footer as the stage arrives.
+            orb.set_scale(VOICE_STAGE_ORB_SCALE * (0.82 + 0.18 * reveal), cx);
+        });
+        if reveal <= 0.001 {
+            return None;
+        }
+
+        // Streamed words veil in like transcript text; a new speaker turn
+        // fades the previous caption out (zeron-veil, shared with mobile).
+        let caption = self.voice_caption.advance(
+            caption_item.as_deref(),
+            &partial,
+            std::time::Instant::now(),
+            self.reduced_motion,
+        );
+        if self.voice_caption.is_animating() {
+            self.motion_active.set(true);
+        }
+
+        let theme = Theme::of(cx).clone();
+        let viewport = window.viewport_size();
+        // The sidebar stays usable beside the stage; collapsed, the stage
+        // spans the whole window. Settings always shows its own sidebar.
+        let left = if matches!(self.route, Route::Settings(_)) {
+            self.settings.sidebar_width
+        } else {
+            self.sidebar_now()
+        };
+        let width = (f32::from(viewport.width) - left).max(0.0);
+        let ui_settings = settings::current(cx);
+        let artwork = ui_settings
+            .new_thread_composer_background
+            .as_ref()
+            .and_then(|background| {
+                crate::new_thread_background_effects::prepare(
+                    ui_settings.new_thread_background_effect,
+                    &theme,
+                    std::path::Path::new(&background.path),
+                    cx,
+                )
+            });
+        let adjustment = ui_settings
+            .new_thread_composer_background
+            .as_ref()
+            .map(|background| background.adjustment)
+            .unwrap_or_default();
+        // The new-thread hero's artwork with only its soft bottom fade: no
+        // cutout around the orb, so no light channel splits the picture.
+        let hero = artwork.map(|artwork| {
+            div()
+                .absolute()
+                .top_0()
+                .left_0()
+                .w(px(width))
+                .h(px(new_thread_background_height(f32::from(viewport.height))))
+                .opacity(new_thread_background_opacity(theme.is_frost()))
+                .child(
+                    gpui::canvas(
+                        |_, _, _| {},
+                        move |bounds, _, window, _| {
+                            crate::new_thread_background_mask::paint(
+                                artwork.clone(),
+                                bounds,
+                                bounds,
+                                adjustment,
+                                false,
+                                window,
+                            );
+                        },
+                    )
+                    .absolute()
+                    .inset_0(),
+                )
+        });
+
+        let orb_block = div()
+            .relative()
+            .size(px(STAGE_ORB_BOX))
+            .flex()
+            .items_center()
+            .justify_center()
+            .child(self.voice_stage_orb.clone());
+
+        let center = div()
+            .relative()
+            .top(px(18.0 * (1.0 - reveal)))
+            .flex()
+            .flex_col()
+            .items_center()
+            .child(orb_block)
+            .child(
+                div()
+                    .relative()
+                    .mt(px(10.0))
+                    .w(px(560.0))
+                    .max_w(px((width - 48.0).max(200.0)))
+                    .h(px(48.0))
+                    .overflow_hidden()
+                    .text_center()
+                    .text_size(crate::typography::ui_rems(14.0))
+                    .line_height(px(22.0))
+                    .text_color(theme.text_muted)
+                    .child(veiled_caption(caption.text, &caption.spans, &theme, window))
+                    .children(caption.previous.map(|(previous, opacity)| {
+                        div()
+                            .absolute()
+                            .top_0()
+                            .left_0()
+                            .right_0()
+                            .opacity(opacity)
+                            .child(previous)
+                    })),
+            );
+
+        let controls = self.render_voice_call_bar(&theme, awaiting, chat_id, cx);
+        // The stage occludes the conversation titlebar. Restore its native
+        // drag and double-click behavior above the stage artwork and controls.
+        let titlebar = self.titlebar_drag_region(
+            "voice-stage-titlebar",
+            div()
+                .absolute()
+                .top_0()
+                .left_0()
+                .right_0()
+                .h(px(Theme::TITLEBAR_HEIGHT)),
+            cx,
+        );
+
+        Some(
+            div()
+                .id("voice-stage")
+                .debug_selector(|| "voice-stage".into())
+                .track_focus(&self.voice_stage_focus)
+                .absolute()
+                .top_0()
+                .bottom_0()
+                .right_0()
+                .left(px(left))
+                .occlude()
+                .opacity(reveal)
+                // On glass the stage shows the window frost like the new-thread
+                // page; the page beneath fades out instead (see `render`).
+                .when(!theme.is_glass(), |stage| stage.bg(theme.bg))
+                .on_key_down(cx.listener(|this, event: &gpui::KeyDownEvent, _, cx| {
+                    let key = event.keystroke.key.as_str();
+                    let plain = !event.keystroke.modifiers.modified();
+                    if key == "escape" {
+                        this.set_voice_stage_open(false, cx);
+                        cx.stop_propagation();
+                    } else if key == "m" && plain {
+                        this.voice.update(cx, |voice, cx| voice.toggle_mute(cx));
+                        cx.stop_propagation();
+                    }
+                }))
+                .child(div().absolute().inset_0().children(hero))
+                .child(
+                    div()
+                        .absolute()
+                        .inset_0()
+                        .flex()
+                        .flex_col()
+                        .items_center()
+                        .justify_center()
+                        .pb(px(64.0))
+                        .child(center),
+                )
+                .child(
+                    div()
+                        .absolute()
+                        .left_0()
+                        .right_0()
+                        .bottom(px(32.0 - 16.0 * (1.0 - reveal)))
+                        .flex()
+                        .justify_center()
+                        .child(controls),
+                )
+                .child(titlebar)
+                .into_any_element(),
+        )
+    }
+
+    /// Video-call style bar: session time, the call controls grouped around
+    /// a red hang-up, and the way back to the chats.
+    fn render_voice_call_bar(
+        &mut self,
+        theme: &Theme,
+        awaiting: bool,
+        chat_id: Option<String>,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let popup = theme.for_popup();
+        let voice = self.voice.read(cx);
+        let muted = voice.muted();
+        let elapsed = voice
+            .active_since
+            .map(|since| crate::voice::format_elapsed(since.elapsed().as_secs()));
+        let live_tone = if awaiting {
+            popup.warning
+        } else if muted {
+            popup.text_faint
+        } else {
+            popup.success
+        };
+
+        // Session clock, like a meeting's running time.
+        let clock = div()
+            .flex()
+            .items_center()
+            .gap(px(8.0))
+            .pl(px(10.0))
+            .pr(px(6.0))
+            .child(div().size(px(7.0)).rounded_full().bg(live_tone))
+            .child(
+                div()
+                    .min_w(px(40.0))
+                    .font_family(popup.font_mono.clone())
+                    .text_size(crate::typography::ui_rems(13.0))
+                    .text_color(popup.text_muted)
+                    .child(SharedString::from(elapsed.unwrap_or_else(|| "–:––".into()))),
+            );
+
+        let clock = clock.children(voice.host_name.clone().map(|name| {
+            div()
+                .text_size(crate::typography::ui_rems(12.0))
+                .text_color(popup.text_faint)
+                .child(name)
+        }));
+
+        // Microphone: inverted plate while muted.
+        let mic = round_control("voice-bar-mic", &popup, muted)
+            .aria_label(if muted {
+                "Unmute microphone"
+            } else {
+                "Mute microphone"
+            })
+            .tooltip(stage_tooltip(if muted {
+                "Unmute · M"
+            } else {
+                "Mute · M"
+            }))
+            .on_click(cx.listener(|this, _, _, cx| {
+                this.voice.update(cx, |voice, cx| voice.toggle_mute(cx))
+            }))
+            .child(
+                icon(if muted {
+                    icons::MICROPHONE_OFF
+                } else {
+                    icons::MICROPHONE
+                })
+                .size(px(19.0))
+                .text_color(if muted { popup.on_solid } else { popup.text }),
+            );
+
+        let transcript = chat_id.map(|chat_id| {
+            round_control("voice-bar-transcript", &popup, false)
+                .aria_label(if awaiting {
+                    "Answer Codex in the transcript"
+                } else {
+                    "Open the voice transcript"
+                })
+                .tooltip(stage_tooltip(if awaiting {
+                    "Codex is asking you something"
+                } else {
+                    "Transcript"
+                }))
+                .on_click(cx.listener(move |this, _, _, cx| this.open_chat(chat_id.clone(), cx)))
+                .child(
+                    icon(icons::CHAT_ROUND_LINE)
+                        .size(px(19.0))
+                        .text_color(if awaiting { popup.warning } else { popup.text }),
+                )
+                .when(awaiting, |el| {
+                    el.child(
+                        div()
+                            .absolute()
+                            .top(px(9.0))
+                            .right(px(9.0))
+                            .size(px(8.0))
+                            .rounded_full()
+                            .border_2()
+                            .border_color(popover::surface_bg(&popup))
+                            .bg(popup.warning),
+                    )
+                })
+        });
+
+        // The hang-up: the one saturated control, wide enough to never be
+        // mistaken for its neighbours.
+        let end = div()
+            .id("voice-bar-end")
+            .role(gpui::Role::Button)
+            .aria_label("End voice")
+            .tab_index(0)
+            .h(px(BAR_CONTROL))
+            .px(px(20.0))
+            .rounded_full()
+            .flex()
+            .items_center()
+            .gap(px(8.0))
+            .cursor_pointer()
+            .bg(motion::hover_blend(
+                "voice-bar-end",
+                popup.danger,
+                popup.danger.blend(gpui::black().opacity(0.14)),
+            ))
+            .on_hover(motion::hover_listener("voice-bar-end"))
+            .focus_visible(|s| s.border_2().border_color(popup.accent))
+            .tooltip(stage_tooltip("End voice"))
+            .on_click(cx.listener(|this, _, _, cx| this.end_voice(cx)))
+            .child(
+                icon(icons::PHONE_HANG_UP)
+                    .size(px(19.0))
+                    .text_color(gpui::white()),
+            )
+            .child(
+                div()
+                    .text_size(crate::typography::ui_rems(13.0))
+                    .font_weight(gpui::FontWeight::SEMIBOLD)
+                    .text_color(gpui::white())
+                    .child(SharedString::from("End")),
+            );
+
+        let back = round_control("voice-bar-back", &popup, false)
+            .aria_label("Back to chats")
+            .tooltip(stage_tooltip("Back to chats · Esc"))
+            .on_click(cx.listener(|this, _, _, cx| this.set_voice_stage_open(false, cx)))
+            .child(
+                icon(icons::ALT_ARROW_DOWN)
+                    .size(px(19.0))
+                    .text_color(popup.text_muted),
+            );
+
+        let divider = || div().w(px(1.0)).h(px(24.0)).mx(px(4.0)).bg(popup.border);
+        let radius = BAR_CONTROL / 2.0 + BAR_PAD;
+        let bar = div()
+            .flex()
+            .items_center()
+            .gap(px(6.0))
+            .p(px(BAR_PAD))
+            .rounded(px(radius))
+            .border_1()
+            .border_color(popup.border.opacity(0.7))
+            .bg(popover::surface_bg(&popup))
+            .when(!popup.is_frost(), |el| el.shadow_lg())
+            .text_color(popup.text)
+            .child(clock)
+            .child(divider())
+            .child(mic)
+            .children(transcript)
+            .child(end)
+            .child(divider())
+            .child(back);
+        crate::frost::frosted(radius, 18.0, bar).into_any_element()
+    }
+}
+
+/// The caption with its fading words recolored, paint-only (`apply_veil`).
+fn veiled_caption(
+    text: String,
+    spans: &[zeron_veil::VeilSpan],
+    theme: &Theme,
+    window: &Window,
+) -> gpui::StyledText {
+    let mut run = window.text_style().to_run(text.len());
+    run.color = theme.text_muted;
+    let runs = crate::markdown::veil::apply_veil(vec![run], spans);
+    gpui::StyledText::new(text).with_runs(runs)
+}
+
+fn stage_tooltip(text: &'static str) -> impl Fn(&mut Window, &mut App) -> gpui::AnyView + 'static {
+    move |_, cx| cx.new(|_| SurfaceTabTooltip { text: text.into() }).into()
+}
+
+/// A round call-bar control; `active` inverts it onto the solid plate.
+fn round_control(id: &'static str, theme: &Theme, active: bool) -> gpui::Stateful<gpui::Div> {
+    div()
+        .id(id)
+        .role(gpui::Role::Button)
+        .tab_index(0)
+        .relative()
+        .size(px(BAR_CONTROL))
+        .flex_none()
+        .rounded_full()
+        .flex()
+        .items_center()
+        .justify_center()
+        .cursor_pointer()
+        .text_color(if active { theme.on_solid } else { theme.text })
+        .bg(if active {
+            theme.solid
+        } else {
+            motion::hover_blend(id, theme.glass_hover().opacity(0.5), theme.glass_hover())
+        })
+        .on_hover(motion::hover_listener(id))
+        .focus_visible(|s| s.border_2().border_color(theme.accent))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[gpui::test]
+    fn voice_stage_topbar_accepts_window_drag_presses(cx: &mut gpui::TestAppContext) {
+        struct StageHost(Entity<Shell>);
+        impl Render for StageHost {
+            fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+                self.0.update(cx, |shell, cx| {
+                    div()
+                        .size_full()
+                        .relative()
+                        .children(shell.render_voice_stage(window, cx))
+                })
+            }
+        }
+
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let (host, cx) = cx.add_window_view(|_, cx| {
+            StageHost(cx.new(|cx| {
+                let state = cx.new(|_| AppState::new());
+                let mut shell = Shell::new(
+                    state,
+                    EngineBootConfig {
+                        data_dir: dir.path().into(),
+                        ipc_port: 0,
+                        edge_url: "http://127.0.0.1:1".into(),
+                        edge_token: None,
+                        org_id: None,
+                        workos_client_id: None,
+                        default_harness: HarnessId::Mock,
+                    },
+                    cx,
+                );
+                shell.reduced_motion = true;
+                shell.voice.update(cx, |voice, _| {
+                    voice.phase = VoicePhase::Active;
+                    voice.stage_open = true;
+                });
+                shell
+            }))
+        });
+        let shell = host.read_with(cx, |host, _| host.0.clone());
+        cx.update(|window, cx| window.draw(cx).clear());
+        let bounds = cx.debug_bounds("voice-stage").unwrap();
+        let topbar = gpui::point(
+            bounds.center().x,
+            bounds.top() + px(Theme::TITLEBAR_HEIGHT / 2.0),
+        );
+        cx.simulate_mouse_down(topbar, MouseButton::Left, gpui::Modifiers::default());
+        shell.read_with(cx, |shell, _| assert!(shell.titlebar_should_move));
+        cx.simulate_mouse_up(topbar, MouseButton::Left, gpui::Modifiers::default());
+        shell.read_with(cx, |shell, _| assert!(!shell.titlebar_should_move));
+
+        let body = gpui::point(
+            bounds.center().x,
+            bounds.top() + px(Theme::TITLEBAR_HEIGHT + 32.0),
+        );
+        cx.simulate_mouse_down(body, MouseButton::Left, gpui::Modifiers::default());
+        shell.read_with(cx, |shell, _| assert!(!shell.titlebar_should_move));
+        cx.simulate_mouse_up(body, MouseButton::Left, gpui::Modifiers::default());
+    }
+
+    #[gpui::test]
+    fn voice_stage_can_start_and_reopen_in_settings_until_navigation(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        struct StageHost(Entity<Shell>);
+        impl Render for StageHost {
+            fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+                self.0.update(cx, |shell, cx| {
+                    shell.sync_voice_stage(window, cx);
+                    div()
+                        .size_full()
+                        .children(shell.render_voice_stage(window, cx))
+                })
+            }
+        }
+
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let (host, cx) = cx.add_window_view(|_, cx| {
+            StageHost(cx.new(|cx| {
+                let state = cx.new(|_| AppState::new());
+                let mut shell = Shell::new(
+                    state,
+                    EngineBootConfig {
+                        data_dir: dir.path().into(),
+                        ipc_port: 0,
+                        edge_url: "http://127.0.0.1:1".into(),
+                        edge_token: None,
+                        org_id: None,
+                        workos_client_id: None,
+                        default_harness: HarnessId::Mock,
+                    },
+                    cx,
+                );
+                shell.reduced_motion = true;
+                shell.route = Route::Settings(SettingsSection::Voice);
+                // The initial stage opens while native voice is still preparing.
+                shell.voice.update(cx, |voice, cx| {
+                    voice.phase = VoicePhase::Checking;
+                    voice.set_stage_open(true, cx);
+                });
+                shell
+            }))
+        });
+        let shell = host.read_with(cx, |host, _| host.0.clone());
+        let stays_open = |cx: &mut gpui::VisualTestContext| {
+            for _ in 0..3 {
+                cx.update(|window, cx| window.draw(cx).clear());
+                shell.read_with(cx, |shell, cx| assert!(shell.voice.read(cx).stage_open));
+                assert!(cx.debug_bounds("voice-stage").is_some());
+            }
+        };
+        stays_open(cx);
+
+        shell.update(cx, |shell, cx| {
+            shell
+                .voice
+                .update(cx, |voice, _| voice.phase = VoicePhase::Active);
+            shell.set_voice_stage_open(false, cx);
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        shell.update(cx, |shell, cx| shell.set_voice_stage_open(true, cx));
+        stays_open(cx);
+
+        // Choosing another settings page hides the stage without ending voice.
+        shell.update(cx, |shell, cx| {
+            shell.open_settings(SettingsSection::General, cx)
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        shell.read_with(cx, |shell, cx| {
+            assert!(!shell.voice.read(cx).stage_open);
+            assert!(shell.voice.read(cx).is_live());
+        });
+        shell.update(cx, |shell, cx| shell.set_voice_stage_open(true, cx));
+        stays_open(cx);
+
+        // Leaving and reentering the same settings page is navigation too.
+        shell.update(cx, |shell, _| shell.route = Route::Chat);
+        cx.update(|window, cx| window.draw(cx).clear());
+        shell.update(cx, |shell, cx| {
+            shell.open_settings(SettingsSection::General, cx)
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        shell.read_with(cx, |shell, cx| {
+            assert!(!shell.voice.read(cx).stage_open);
+            assert!(shell.voice.read(cx).is_live());
+        });
+
+        shell.update(cx, |shell, cx| shell.set_voice_stage_open(true, cx));
+        stays_open(cx);
+        shell.update(cx, |shell, cx| {
+            shell.state.update(cx, |state, _| {
+                state.selected_chat = Some("another-chat".into())
+            });
+        });
+        cx.update(|window, cx| window.draw(cx).clear());
+        shell.read_with(cx, |shell, cx| {
+            assert!(!shell.voice.read(cx).stage_open);
+            assert!(shell.voice.read(cx).is_live());
+        });
+    }
+
+    #[gpui::test]
+    fn opening_any_session_steps_the_stage_aside_without_ending_voice(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        struct StageHost(Entity<Shell>);
+        impl Render for StageHost {
+            fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+                self.0.update(cx, |shell, cx| {
+                    shell.sync_voice_stage(window, cx);
+                    div()
+                        .size_full()
+                        .children(shell.render_voice_stage(window, cx))
+                })
+            }
+        }
+
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let (host, cx) = cx.add_window_view(|_, cx| {
+            StageHost(cx.new(|cx| {
+                let state = cx.new(|_| AppState::new());
+                let mut shell = Shell::new(
+                    state,
+                    EngineBootConfig {
+                        data_dir: dir.path().into(),
+                        ipc_port: 0,
+                        edge_url: "http://127.0.0.1:1".into(),
+                        edge_token: None,
+                        org_id: None,
+                        workos_client_id: None,
+                        default_harness: HarnessId::Mock,
+                    },
+                    cx,
+                );
+                shell.reduced_motion = true;
+                shell
+                    .state
+                    .update(cx, |state, _| state.selected_chat = Some("current".into()));
+                shell.voice.update(cx, |voice, cx| {
+                    voice.phase = VoicePhase::Active;
+                    voice.set_stage_open(true, cx);
+                });
+                shell
+            }))
+        });
+        let shell = host.read_with(cx, |host, _| host.0.clone());
+        let open_stage = |cx: &mut gpui::VisualTestContext| {
+            shell.update(cx, |shell, cx| shell.set_voice_stage_open(true, cx));
+            cx.update(|window, cx| window.draw(cx).clear());
+            shell.read_with(cx, |shell, cx| assert!(shell.voice.read(cx).stage_open));
+        };
+        let stepped_aside = |cx: &mut gpui::VisualTestContext, selected: &str| {
+            cx.update(|window, cx| window.draw(cx).clear());
+            shell.read_with(cx, |shell, cx| {
+                assert!(!shell.voice.read(cx).stage_open);
+                assert!(shell.voice.read(cx).is_live(), "the call keeps running");
+                assert_eq!(shell.route, Route::Chat);
+                assert_eq!(
+                    shell.state.read(cx).selected_chat.as_deref(),
+                    Some(selected)
+                );
+            });
+        };
+        cx.update(|window, cx| window.draw(cx).clear());
+
+        // The session already under the stage: the selection doesn't change,
+        // so only an explicit step-aside shows it.
+        shell.update(cx, |shell, cx| shell.open_chat("current".into(), cx));
+        stepped_aside(cx, "current");
+
+        // From Settings back to the session the stage was opened over.
+        shell.update(cx, |shell, _| {
+            shell.route = Route::Settings(SettingsSection::Voice)
+        });
+        open_stage(cx);
+        shell.update(cx, |shell, cx| shell.open_chat("current".into(), cx));
+        stepped_aside(cx, "current");
+
+        // Another session.
+        open_stage(cx);
+        shell.update(cx, |shell, cx| shell.open_chat("other".into(), cx));
+        stepped_aside(cx, "other");
+    }
+
+    #[gpui::test]
+    fn composer_orb_shows_only_on_the_orchestrator_chat_and_returns_to_the_call(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        struct OrbHost(Entity<Shell>);
+        impl Render for OrbHost {
+            fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+                self.0.update(cx, |shell, cx| {
+                    div()
+                        .size_full()
+                        .children(shell.render_voice_composer_orb(600.0, cx))
+                })
+            }
+        }
+
+        let dir = tempfile::tempdir().unwrap();
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::default());
+            crate::app_menus::init(cx);
+            settings::init(settings::UiSettings::default(), dir.path(), cx);
+        });
+        let orchestrator = format!("{}1", zeron_proto::voice::ORCHESTRATOR_CHAT_PREFIX);
+        let (host, cx) = cx.add_window_view(|_, cx| {
+            OrbHost(cx.new(|cx| {
+                let state = cx.new(|_| AppState::new());
+                let shell = Shell::new(
+                    state,
+                    EngineBootConfig {
+                        data_dir: dir.path().into(),
+                        ipc_port: 0,
+                        edge_url: "http://127.0.0.1:1".into(),
+                        edge_token: None,
+                        org_id: None,
+                        workos_client_id: None,
+                        default_harness: HarnessId::Mock,
+                    },
+                    cx,
+                );
+                shell.voice.update(cx, |voice, _| {
+                    voice.phase = VoicePhase::Active;
+                    voice.chat_id = Some(orchestrator.clone());
+                });
+                shell
+            }))
+        });
+        let shell = host.read_with(cx, |host, _| host.0.clone());
+        let select = |chat: &str, cx: &mut gpui::VisualTestContext| {
+            let chat = chat.to_owned();
+            shell.update(cx, |shell, cx| {
+                shell
+                    .state
+                    .update(cx, |state, _| state.selected_chat = Some(chat));
+            });
+            cx.update(|window, cx| window.draw(cx).clear());
+        };
+
+        select("another-chat", cx);
+        assert!(cx.debug_bounds("voice-composer-orb").is_none());
+
+        select(&orchestrator, cx);
+        let orb = cx.debug_bounds("voice-composer-orb").unwrap();
+        cx.simulate_click(orb.center(), gpui::Modifiers::default());
+        shell.read_with(cx, |shell, cx| assert!(shell.voice.read(cx).stage_open));
+    }
+
+    #[test]
+    fn stage_reveal_eases_in_and_out_and_snaps_for_reduced_motion() {
+        assert_eq!(stage_reveal(true, 0.0, false), 0.0);
+        assert_eq!(stage_reveal(true, f32::INFINITY, false), 1.0);
+        assert!(stage_reveal(true, STAGE_ENTER_MS / 4.0, false) > 0.5);
+        assert_eq!(stage_reveal(false, 0.0, false), 1.0);
+        assert_eq!(stage_reveal(false, f32::INFINITY, false), 0.0);
+        assert_eq!(stage_reveal(true, 0.0, true), 1.0);
+        assert_eq!(stage_reveal(false, 0.0, true), 0.0);
+    }
+}
diff --git a/crates/ui/src/sound.rs b/crates/ui/src/sound.rs
index 86002859bd..38b2d2d951 100644
--- a/crates/ui/src/sound.rs
+++ b/crates/ui/src/sound.rs
@@ -1,7 +1,8 @@
 //! Session notification sounds — the herdr approach (state-transition chimes
 //! played through the platform's own audio CLI, zero Rust audio deps):
 //!
-//! - embedded completion, input-request, attention and Appshot chimes;
+//! - embedded completion, input-request, attention and Appshot chimes, and
+//!   the start and end of a voice call;
 //! - macOS Appshots use a preloaded native player; other cues write to a
 //!   temp file and use the system player on a
 //!   background thread: `afplay` (macOS), PowerShell `Media.SoundPlayer`
@@ -25,6 +26,8 @@ static SOUND_APPSHOT: &[u8] = include_bytes!("../assets/sounds/appshot.wav");
 static SOUND_DONE: &[u8] = include_bytes!("../assets/sounds/done.wav");
 static SOUND_REQUEST: &[u8] = include_bytes!("../assets/sounds/request.wav");
 static SOUND_ATTENTION: &[u8] = include_bytes!("../assets/sounds/attention.wav");
+static SOUND_VOICE_START: &[u8] = include_bytes!("../assets/sounds/voice-start.wav");
+static SOUND_VOICE_END: &[u8] = include_bytes!("../assets/sounds/voice-end.wav");
 
 /// Which notification chime to play.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -48,6 +51,16 @@ pub fn play(sound: Sound) {
     play_in_background(data);
 }
 
+/// A voice call starting (`true`) or ending. Only its two ends sound: the
+/// caller plays each once per call, never in between.
+pub fn play_voice(start: bool) {
+    play_in_background(if start {
+        SOUND_VOICE_START
+    } else {
+        SOUND_VOICE_END
+    });
+}
+
 /// Confirm captured pixels with a soft shutter and clear chime.
 /// The caller honors the dedicated capture sound setting.
 pub fn play_appshot() {
diff --git a/crates/ui/src/state.rs b/crates/ui/src/state.rs
index 604c79ff53..c2e141fa96 100644
--- a/crates/ui/src/state.rs
+++ b/crates/ui/src/state.rs
@@ -123,12 +123,16 @@ pub enum EngineMode {
 trait EngineBackend: Send + Sync {
     fn client(&self) -> &RpcClient;
     fn mode(&self) -> EngineMode;
+    async fn media_client(&self) -> Result<RpcClient, RpcError> {
+        Err(RpcError::Failed("voice media unavailable".into()))
+    }
     /// Graceful teardown (drains runs / flushes docs for the in-process engine).
     async fn shutdown(&self);
 }
 
 /// Embedded engine: owns the [`EngineCore`] and an in-memory RPC loop.
 struct InProcessEngine {
+    service: Arc<dyn RpcService>,
     runtime: Arc<tokio::sync::Mutex<Option<EngineRuntime>>>,
     boot_task: tokio::task::JoinHandle<()>,
     refresh_task: tokio::task::JoinHandle<()>,
@@ -140,6 +144,9 @@ struct InProcessEngine {
 
 #[async_trait]
 impl EngineBackend for InProcessEngine {
+    async fn media_client(&self) -> Result<RpcClient, RpcError> {
+        Ok(memory_client(self.service.clone()))
+    }
     fn client(&self) -> &RpcClient {
         &self.client
     }
@@ -244,6 +251,9 @@ struct RemoteEngine {
 
 #[async_trait]
 impl EngineBackend for RemoteEngine {
+    async fn media_client(&self) -> Result<RpcClient, RpcError> {
+        connect_ws(&self.url).await
+    }
     fn client(&self) -> &RpcClient {
         &self.client
     }
@@ -345,7 +355,8 @@ impl EngineHandle {
         //
         // Best-effort — losing the bind race with another engine costs other
         // viewports, not this one.
-        let ipc_task = match zeron_engine::serve_ipc(engine_config.ipc_port, service).await {
+        let ipc_task = match zeron_engine::serve_ipc(engine_config.ipc_port, service.clone()).await
+        {
             Ok(task) => Some(task),
             Err(err) => {
                 tracing::warn!(
@@ -417,6 +428,7 @@ impl EngineHandle {
         });
         let handle = EngineHandle {
             inner: Arc::new(InProcessEngine {
+                service,
                 runtime,
                 boot_task,
                 refresh_task,
@@ -530,6 +542,10 @@ impl EngineHandle {
         self.inner.mode()
     }
 
+    pub async fn media_client(&self) -> Result<RpcClient, RpcError> {
+        self.inner.media_client().await
+    }
+
     pub fn engine_info(&self) -> &EngineInfo {
         &self.engine_info
     }
@@ -1255,8 +1271,7 @@ impl AppState {
         if Some(chat.device_id.as_str()) == self.local_device_id.as_deref() {
             return false;
         }
-        if self.connectivity.state == S::Offline
-            || !self.device_online(&chat.device_id, Utc::now())
+        if self.connectivity.state == S::Offline || !self.device_online(&chat.device_id, Utc::now())
         {
             return true;
         }
@@ -1780,10 +1795,11 @@ impl AppState {
     /// another chat (`parent_chat_id`, the Zeron MCP's orchestration link)
     /// are the parent's workers, not sessions the user started: they stay
     /// reachable by id/deep link but never take a sidebar row or jump slot.
+    /// Voice orchestrator chats are hidden the same way.
     pub fn visible_chats(&self) -> impl Iterator<Item = &Chat> {
         self.chats
             .iter()
-            .filter(|c| !c.archived && c.parent_chat_id.is_none())
+            .filter(|c| !c.archived && c.is_top_level())
     }
 
     pub(crate) fn restore_composer_target(
@@ -2729,7 +2745,10 @@ impl AppState {
         cx.spawn(async move |_, _| {
             if let Err(error) = handle
                 .client()
-                .call(methods::FOCUS_CHAT, serde_json::json!({ "chatId": chat_id }))
+                .call(
+                    methods::FOCUS_CHAT,
+                    serde_json::json!({ "chatId": chat_id }),
+                )
                 .await
             {
                 tracing::debug!(%chat_id, %error, "chat focus sync hint unavailable");
diff --git a/crates/ui/src/voice.rs b/crates/ui/src/voice.rs
new file mode 100644
index 0000000000..b5b62e481c
--- /dev/null
+++ b/crates/ui/src/voice.rs
@@ -0,0 +1,635 @@
+//! Window-owned voice orchestrator. Each session runs in the host's own
+//! projectless Codex chat, resumed across calls, and survives navigation
+//! between threads; only an explicit end, an engine change or a provider
+//! failure closes it. No automatic reconnect or microphone resume.
+use crate::orb::OrbState;
+use crate::state::EngineHandle;
+use gpui::{Context, Task};
+use gpui_tokio::Tokio;
+use zeron_proto::voice::*;
+mod permissions;
+mod remote;
+
+pub enum VoiceControl {
+    Mute(bool),
+}
+
+pub struct VoiceController {
+    pub phase: VoicePhase,
+    pub chat_id: Option<String>,
+    pub reason: Option<VoiceRejection>,
+    pub snapshot: Option<VoiceSnapshot>,
+    /// The newest speaker turn's live text, then its final.
+    pub caption: zeron_voice_session::Caption,
+    pub microphone_level: u16,
+    pub speaker_level: u16,
+    /// The full-window stage is presented over the shell.
+    pub stage_open: bool,
+    pub host_name: Option<String>,
+    speaker_last_loud: Option<std::time::Instant>,
+    /// When the session first became active; drives the stage's call timer.
+    pub active_since: Option<std::time::Instant>,
+    engine: Option<EngineHandle>,
+    controls: Option<tokio::sync::mpsc::Sender<VoiceControl>>,
+    epoch: u64,
+    task: Option<Task<()>>,
+    cancellation: tokio_util::sync::CancellationToken,
+    /// Whether this device's Codex is installed and enabled: no Codex, no
+    /// voice. `None` until the catalog answers.
+    codex_ready: Option<bool>,
+    /// The connection `codex_ready` was read from, and its read in flight.
+    codex_engine: Option<EngineHandle>,
+    codex_check: Option<Task<()>>,
+    /// This call played its start sound and owes its end sound.
+    cued: bool,
+}
+impl Default for VoiceController {
+    fn default() -> Self {
+        Self {
+            phase: VoicePhase::Closed,
+            chat_id: None,
+            reason: None,
+            snapshot: None,
+            caption: Default::default(),
+            microphone_level: 0,
+            speaker_level: 0,
+            stage_open: false,
+            host_name: None,
+            speaker_last_loud: None,
+            active_since: None,
+            engine: None,
+            controls: None,
+            epoch: 0,
+            task: None,
+            cancellation: tokio_util::sync::CancellationToken::new(),
+            codex_ready: None,
+            codex_engine: None,
+            codex_check: None,
+            cued: false,
+        }
+    }
+}
+impl VoiceController {
+    /// Voice can be offered here. An unread catalog counts as yes, so a slow
+    /// or failed read never hides it; a live call or its failure stays.
+    pub fn offered(&self) -> bool {
+        self.codex_ready != Some(false) || self.is_live() || self.reason.is_some()
+    }
+
+    /// Read whether `engine`'s device can take a call: installed and enabled
+    /// in Settings → Agents. `force` re-reads a connection already read.
+    pub fn check_codex(&mut self, engine: &EngineHandle, force: bool, cx: &mut Context<Self>) {
+        let same = self
+            .codex_engine
+            .as_ref()
+            .is_some_and(|e| e.same_connection(engine));
+        if same && !force {
+            return;
+        }
+        if !same {
+            self.codex_ready = None;
+        }
+        self.codex_engine = Some(engine.clone());
+        let engine = engine.clone();
+        self.codex_check = Some(cx.spawn(async move |this, cx| {
+            let ready = engine
+                .client()
+                .call(zeron_rpc::methods::LIST_HARNESSES, serde_json::json!({}))
+                .await
+                .ok()
+                .and_then(|value| {
+                    serde_json::from_value::<Vec<zeron_engine::registry::HarnessDescriptor>>(value)
+                        .ok()
+                })
+                .map(|list| {
+                    list.iter().any(|d| {
+                        d.id == zeron_proto::HarnessId::Codex
+                            && d.installed
+                            && zeron_engine::registry::descriptor_enabled(d)
+                    })
+                });
+            this.update(cx, |voice, cx| {
+                if ready.is_some() && ready != voice.codex_ready {
+                    voice.codex_ready = ready;
+                    cx.notify();
+                }
+            })
+            .ok();
+        }));
+    }
+
+    /// A session is underway (including its preparation and native stop).
+    pub fn is_live(&self) -> bool {
+        matches!(self.phase, VoicePhase::Checking) || self.phase.replaces_composer()
+    }
+
+    /// Start an orchestrator in a new projectless Codex chat on `host_device_id`.
+    /// `config` is the chat's Codex configuration; its harness must be Codex.
+    pub fn start(
+        &mut self,
+        engine: EngineHandle,
+        host_device_id: String,
+        config: zeron_proto::ChatConfig,
+        voice: Option<String>,
+        cx: &mut Context<Self>,
+    ) {
+        self.cancel(cx);
+        // The call sounds as it is placed, well before the microphone opens.
+        crate::sound::play_voice(true);
+        self.cued = true;
+        self.engine = Some(engine.clone());
+        self.phase = VoicePhase::Checking;
+        self.chat_id = None;
+        self.reason = None;
+        let epoch = self.epoch;
+        let cancellation = self.cancellation.clone();
+        let (controls, control_rx) = tokio::sync::mpsc::channel(8);
+        self.controls = Some(controls);
+        let (events, mut event_rx) = tokio::sync::mpsc::channel(32);
+        let query = Tokio::spawn(cx, async move {
+            // Media belongs to this viewport, even when the chosen host is
+            // this device. The execution host never opens audio devices.
+            remote::run(
+                engine,
+                host_device_id,
+                config,
+                voice,
+                cancellation,
+                events,
+                control_rx,
+            )
+            .await
+        });
+        self.task = Some(cx.spawn(async move |this, cx| {
+            let receive = async {
+                while let Some(event) = event_rx.recv().await {
+                    if this
+                        .update(cx, |controller, cx| {
+                            if controller.epoch == epoch {
+                                controller.reduce(event, cx);
+                            }
+                        })
+                        .is_err()
+                    {
+                        break;
+                    }
+                }
+            };
+            receive.await;
+            let result = query.await.unwrap_or(Err(VoiceRejection::Protocol));
+            let _ = this.update(cx, |controller, cx| {
+                if controller.epoch != epoch {
+                    return;
+                }
+                match result {
+                    // A provider failure already reduced to Failed keeps its reason.
+                    Ok(()) if controller.phase == VoicePhase::Failed => {}
+                    Ok(()) => {
+                        controller.phase = VoicePhase::Closed;
+                    }
+                    Err(reason) => {
+                        controller.phase = VoicePhase::Failed;
+                        controller.reason = Some(reason);
+                    }
+                }
+                controller.reset_session();
+                cx.notify();
+            });
+        }));
+        cx.notify();
+    }
+
+    /// Ending now sounds: a hang-up or a connected call ending. A failure to
+    /// connect only explains itself.
+    fn end_sounds(&self) -> bool {
+        self.cued && (self.active_since.is_some() || self.reason.is_none())
+    }
+
+    fn reset_session(&mut self) {
+        if self.end_sounds() {
+            crate::sound::play_voice(false);
+        }
+        self.cued = false;
+        self.snapshot = None;
+        self.caption.clear();
+        self.microphone_level = 0;
+        self.speaker_level = 0;
+        self.controls = None;
+        self.task = None;
+        self.stage_open = false;
+        self.active_since = None;
+    }
+
+    /// End the session (any phase). The provider stop runs in the background.
+    pub fn cancel(&mut self, cx: &mut Context<Self>) {
+        self.epoch = self.epoch.wrapping_add(1);
+        self.cancellation.cancel();
+        self.cancellation = tokio_util::sync::CancellationToken::new();
+        self.reset_session();
+        self.phase = VoicePhase::Closed;
+        self.chat_id = None;
+        self.reason = None;
+        self.engine = None;
+        cx.notify();
+    }
+
+    pub fn set_stage_open(&mut self, open: bool, cx: &mut Context<Self>) {
+        let open = open && self.is_live();
+        if self.stage_open != open {
+            self.stage_open = open;
+            cx.notify();
+        }
+    }
+
+    /// Forget a failure once it has been seen.
+    pub fn dismiss_reason(&mut self, cx: &mut Context<Self>) {
+        if self.reason.take().is_some() {
+            if self.phase == VoicePhase::Failed {
+                self.phase = VoicePhase::Closed;
+            }
+            cx.notify();
+        }
+    }
+
+    pub fn belongs_to(&self, engine: &EngineHandle) -> bool {
+        self.engine
+            .as_ref()
+            .is_some_and(|e| e.same_connection(engine))
+    }
+    pub fn muted(&self) -> bool {
+        self.snapshot.as_ref().is_some_and(|s| s.muted)
+    }
+    pub fn toggle_mute(&mut self, cx: &mut Context<Self>) {
+        let muted = self.muted();
+        if let Some(snapshot) = &mut self.snapshot {
+            snapshot.muted = !muted;
+        }
+        cx.notify();
+        if let Some(controls) = &self.controls {
+            if controls.try_send(VoiceControl::Mute(!muted)).is_err() {
+                self.cancel(cx);
+                self.reason = Some(VoiceRejection::Overflow);
+            }
+        }
+    }
+
+    /// The utterance the caption shows (a speaker turn), if the provider names it.
+    pub fn caption_item(&self) -> Option<&str> {
+        self.caption.item()
+    }
+
+    pub fn orb_state(&self) -> OrbState {
+        orb_state(self.phase, self.snapshot.as_ref())
+    }
+
+    /// Normalized 0…1 microphone loudness; zero while muted.
+    pub fn microphone_level(&self) -> f32 {
+        if self.muted() {
+            return 0.0;
+        }
+        f32::from(self.microphone_level) / f32::from(u16::MAX)
+    }
+
+    /// Normalized 0…1 speaker peak; the orb smooths each channel separately.
+    pub fn speaker_level(&self) -> f32 {
+        f32::from(self.speaker_level) / f32::from(u16::MAX)
+    }
+
+    pub fn reduce(&mut self, event: VoiceEvent, cx: &mut Context<Self>) {
+        match event {
+            VoiceEvent::Snapshot { mut snapshot } => {
+                if let Some(previous) = &self.snapshot {
+                    snapshot.playing = previous.playing;
+                }
+                if self.chat_id.is_none() {
+                    self.chat_id = Some(snapshot.chat_id.clone());
+                }
+
+                if self.chat_id.as_deref() != Some(snapshot.chat_id.as_str()) {
+                    return;
+                }
+                if self.snapshot.as_ref().is_some_and(|old| {
+                    old.generation != snapshot.generation || old.session_id != snapshot.session_id
+                }) {
+                    return;
+                }
+                self.phase = snapshot.phase;
+                if self.phase == VoicePhase::Active && self.active_since.is_none() {
+                    self.active_since = Some(std::time::Instant::now());
+                }
+                self.snapshot = Some(snapshot);
+            }
+            VoiceEvent::Partial {
+                generation,
+                item_id,
+                text,
+            } if self
+                .snapshot
+                .as_ref()
+                .is_some_and(|s| s.generation == generation) =>
+            {
+                if !self.caption.partial(item_id, &text) {
+                    self.cancel(cx);
+                    self.phase = VoicePhase::Failed;
+                    self.reason = Some(VoiceRejection::Overflow);
+                }
+            }
+            VoiceEvent::Levels {
+                generation,
+                microphone,
+                speaker,
+            } if self
+                .snapshot
+                .as_ref()
+                .is_some_and(|s| s.generation == generation) =>
+            {
+                self.microphone_level = microphone;
+                self.speaker_level = speaker;
+                if let Some(snapshot) = &mut self.snapshot {
+                    let threshold = if snapshot.playing { 328 } else { 655 };
+                    if speaker >= threshold {
+                        snapshot.playing = true;
+                        self.speaker_last_loud = Some(std::time::Instant::now());
+                    } else if self
+                        .speaker_last_loud
+                        .is_none_or(|t| t.elapsed() >= std::time::Duration::from_millis(250))
+                    {
+                        snapshot.playing = false;
+                    }
+                }
+            }
+            // The final segment keeps showing as the caption until the next
+            // item starts; the canonical copy is already in the transcript.
+            VoiceEvent::Final { transcript }
+                if self
+                    .snapshot
+                    .as_ref()
+                    .is_some_and(|s| s.session_id == transcript.session_id) =>
+            {
+                self.caption.complete(&transcript);
+            }
+            VoiceEvent::Closed { generation, reason }
+                if self
+                    .snapshot
+                    .as_ref()
+                    .is_some_and(|s| s.generation == generation) =>
+            {
+                self.phase = if reason.is_some() {
+                    VoicePhase::Failed
+                } else {
+                    VoicePhase::Closed
+                };
+                self.reason = reason;
+                self.reset_session();
+            }
+            _ => return,
+        }
+        cx.notify();
+    }
+    pub fn reason_text(&self) -> &'static str {
+        match self.reason {
+            Some(VoiceRejection::CreditExclusionUnverified) => {
+                "Codex controls subscription usage and any enabled additional credits."
+            }
+            Some(VoiceRejection::WrongHarness) => "Voice requires Codex.",
+            Some(VoiceRejection::RemoteHost) => "Voice runs on this device only.",
+            Some(VoiceRejection::IncludedUsageUnavailable) => {
+                "Codex usage is currently unavailable."
+            }
+            Some(VoiceRejection::AudioFormatUnverified) => {
+                "This Codex voice format has not been verified."
+            }
+            Some(VoiceRejection::ChatgptRequired) => "Sign in to Codex with ChatGPT to use voice.",
+            // Remote calls still play audio here, through this device's Codex helper.
+            Some(VoiceRejection::NativeRuntimeUnavailable) => {
+                "Install or update Codex on this device with its official installer to use voice. npm installs lack the voice runtime."
+            }
+            Some(VoiceRejection::DeviceUnavailable) => {
+                "Check microphone permission and your audio devices."
+            }
+            Some(VoiceRejection::MicrophonePermissionDenied) => {
+                "Allow Zeron to use the microphone in System Settings → Privacy & Security → Microphone."
+            }
+            Some(VoiceRejection::MicrophoneMetadataMissing) => {
+                "Microphone setup is missing. Rebuild or reinstall Zeron, then restart it."
+            }
+            Some(VoiceRejection::Busy) => "Another window already owns the voice session.",
+            Some(_) => "Voice could not connect. Try again in a moment.",
+            None => "",
+        }
+    }
+}
+
+/// Call-timer text: `m:ss`, or `h:mm:ss` past the hour.
+pub fn format_elapsed(seconds: u64) -> String {
+    let (hours, minutes, seconds) = (seconds / 3600, seconds / 60 % 60, seconds % 60);
+    if hours > 0 {
+        format!("{hours}:{minutes:02}:{seconds:02}")
+    } else {
+        format!("{minutes}:{seconds:02}")
+    }
+}
+
+/// Shared with the mobile apps so every orb reads the call the same way.
+pub use zeron_voice_session::orb_state;
+
+impl Drop for VoiceController {
+    fn drop(&mut self) {
+        self.cancellation.cancel();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::AppContext;
+
+    fn snapshot() -> VoiceSnapshot {
+        VoiceSnapshot {
+            session_id: "one".into(),
+            chat_id: "chat".into(),
+            generation: 2,
+            phase: VoicePhase::Active,
+            muted: false,
+            playing: false,
+            work: VoiceWork::Idle,
+            reason: None,
+            voice: None,
+            voices: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn voice_is_offered_unless_codex_is_known_missing() {
+        let mut voice = VoiceController::default();
+        assert!(voice.offered(), "an unread catalog never hides voice");
+        voice.codex_ready = Some(true);
+        assert!(voice.offered());
+        voice.codex_ready = Some(false);
+        assert!(!voice.offered());
+        // A failure explains itself before the trigger goes away.
+        voice.reason = Some(VoiceRejection::NativeRuntimeUnavailable);
+        assert!(voice.offered());
+        voice.reason = None;
+        voice.phase = VoicePhase::Checking;
+        assert!(voice.offered(), "a call in progress keeps its trigger");
+    }
+
+    #[test]
+    fn only_a_hang_up_or_a_connected_call_sounds_its_end() {
+        let mut voice = VoiceController::default();
+        assert!(!voice.end_sounds(), "no call was placed");
+        voice.cued = true;
+        assert!(voice.end_sounds(), "hanging up while connecting");
+        voice.reason = Some(VoiceRejection::Busy);
+        assert!(!voice.end_sounds(), "a failure to connect stays quiet");
+        voice.active_since = Some(std::time::Instant::now());
+        assert!(voice.end_sounds(), "a connected call that drops");
+    }
+
+    #[gpui::test]
+    fn voice_reducer_ignores_stale_and_foreign_events(cx: &mut gpui::TestAppContext) {
+        let voice = cx.new(|_| VoiceController::default());
+        voice.update(cx, |voice, cx| {
+            voice.chat_id = Some("chat".into());
+            let snapshot = snapshot();
+            voice.reduce(
+                VoiceEvent::Snapshot {
+                    snapshot: snapshot.clone(),
+                },
+                cx,
+            );
+            voice.reduce(
+                VoiceEvent::Partial {
+                    generation: 1,
+                    item_id: None,
+                    text: "old".into(),
+                },
+                cx,
+            );
+            assert!(voice.caption.text().is_empty());
+            voice.reduce(
+                VoiceEvent::Partial {
+                    generation: 2,
+                    item_id: None,
+                    text: "current".into(),
+                },
+                cx,
+            );
+            let mut foreign = snapshot;
+            foreign.chat_id = "other".into();
+            foreign.generation = 3;
+            voice.reduce(VoiceEvent::Snapshot { snapshot: foreign }, cx);
+            assert_eq!(voice.snapshot.as_ref().unwrap().generation, 2);
+            voice.reduce(
+                VoiceEvent::Closed {
+                    generation: 1,
+                    reason: None,
+                },
+                cx,
+            );
+            assert!(voice.is_live());
+            voice.set_stage_open(true, cx);
+            assert!(voice.stage_open);
+            voice.cancel(cx);
+            assert!(!voice.is_live());
+            assert!(!voice.stage_open);
+            assert!(voice.caption.text().is_empty());
+            // A closed session never reopens the stage.
+            voice.set_stage_open(true, cx);
+            assert!(!voice.stage_open);
+        });
+    }
+
+    /// Codex delivers the user's final after the answer started streaming:
+    /// the caption stays on the answer and keeps every streamed word.
+    #[gpui::test]
+    fn late_user_final_keeps_the_streaming_answer_captioned(cx: &mut gpui::TestAppContext) {
+        let voice = cx.new(|_| VoiceController::default());
+        voice.update(cx, |voice, cx| {
+            voice.chat_id = Some("chat".into());
+            voice.reduce(
+                VoiceEvent::Snapshot {
+                    snapshot: snapshot(),
+                },
+                cx,
+            );
+            let partial = |item: &str, text: &str| VoiceEvent::Partial {
+                generation: 2,
+                item_id: Some(item.into()),
+                text: text.into(),
+            };
+            voice.reduce(partial("user", "Open the test"), cx);
+            voice.reduce(partial("answer", "Sure, "), cx);
+            voice.reduce(
+                VoiceEvent::Final {
+                    transcript: VoiceTranscript {
+                        session_id: "one".into(),
+                        item_id: "user".into(),
+                        role: VoiceRole::User,
+                        text: "Open the test.".into(),
+                        promoted_message_id: None,
+                    },
+                },
+                cx,
+            );
+            voice.reduce(partial("answer", "opening it."), cx);
+            assert_eq!(voice.caption.text(), "Sure, opening it.");
+            assert_eq!(voice.caption_item(), Some("answer"));
+        });
+    }
+
+    #[gpui::test]
+    fn provider_failure_closes_the_stage_and_keeps_its_reason(cx: &mut gpui::TestAppContext) {
+        let voice = cx.new(|_| VoiceController::default());
+        voice.update(cx, |voice, cx| {
+            voice.chat_id = Some("chat".into());
+            voice.reduce(
+                VoiceEvent::Snapshot {
+                    snapshot: snapshot(),
+                },
+                cx,
+            );
+            voice.set_stage_open(true, cx);
+            voice.reduce(
+                VoiceEvent::Closed {
+                    generation: 2,
+                    reason: Some(VoiceRejection::DeviceUnavailable),
+                },
+                cx,
+            );
+            assert_eq!(voice.phase, VoicePhase::Failed);
+            assert!(!voice.stage_open);
+            assert!(!voice.reason_text().is_empty());
+            voice.dismiss_reason(cx);
+            assert_eq!(voice.phase, VoicePhase::Closed);
+        });
+    }
+
+    #[test]
+    fn call_timer_reads_like_a_call() {
+        assert_eq!(format_elapsed(0), "0:00");
+        assert_eq!(format_elapsed(75), "1:15");
+        assert_eq!(format_elapsed(3600 + 62), "1:01:02");
+    }
+
+    #[test]
+    fn visual_state_keeps_muting_and_playback_orthogonal() {
+        let mut s = snapshot();
+        s.muted = true;
+        s.playing = true;
+        assert_eq!(orb_state(s.phase, Some(&s)), OrbState::Composing);
+        s.playing = false;
+        assert_eq!(orb_state(s.phase, Some(&s)), OrbState::Breathing);
+        s.muted = false;
+        assert_eq!(orb_state(s.phase, Some(&s)), OrbState::Listening);
+        s.work = VoiceWork::Working;
+        assert_eq!(orb_state(s.phase, Some(&s)), OrbState::Working);
+        s.work = VoiceWork::AwaitingInput;
+        assert_eq!(orb_state(s.phase, Some(&s)), OrbState::Solving);
+        assert_eq!(
+            orb_state(VoicePhase::Starting, Some(&s)),
+            OrbState::Connecting
+        );
+    }
+}
diff --git a/crates/ui/src/voice/permissions.rs b/crates/ui/src/voice/permissions.rs
new file mode 100644
index 0000000000..df1542a2dd
--- /dev/null
+++ b/crates/ui/src/voice/permissions.rs
@@ -0,0 +1,68 @@
+//! Ask for microphone permission in the viewport's macOS process identity
+//! before its engine opens native devices. CoreAudio can otherwise yield silence
+//! without displaying a privacy prompt.
+use zeron_proto::voice::VoiceRejection;
+
+pub(super) async fn microphone() -> Result<(), VoiceRejection> {
+    #[cfg(target_os = "macos")]
+    if let Some(reply) = macos::request()? {
+        if !reply.await.map_err(|_| VoiceRejection::DeviceUnavailable)? {
+            return Err(VoiceRejection::MicrophonePermissionDenied);
+        }
+    }
+    Ok(())
+}
+
+#[cfg(target_os = "macos")]
+mod macos {
+    use super::*;
+    use block2::RcBlock;
+    use objc2::{
+        msg_send,
+        runtime::{AnyClass, AnyObject, Bool},
+    };
+    use objc2_foundation::{NSBundle, ns_string};
+    use std::sync::Mutex;
+    use tokio::sync::oneshot;
+
+    #[link(name = "AVFoundation", kind = "framework")]
+    unsafe extern "C" {
+        static AVMediaTypeAudio: *const AnyObject;
+    }
+
+    // Keep Objective-C objects and the block out of the async future. AVFoundation
+    // copies the completion block and may invoke it on any queue.
+    pub(super) fn request() -> Result<Option<oneshot::Receiver<bool>>, VoiceRejection> {
+        let device = AnyClass::get(c"AVCaptureDevice").ok_or(VoiceRejection::DeviceUnavailable)?;
+        let status: isize =
+            unsafe { msg_send![device, authorizationStatusForMediaType: AVMediaTypeAudio] };
+        match status {
+            3 => return Ok(None), // authorized
+            1 | 2 => return Err(VoiceRejection::MicrophonePermissionDenied),
+            0 => {} // not determined
+            _ => return Err(VoiceRejection::DeviceUnavailable),
+        }
+        // Requesting capture permission without a purpose string terminates the
+        // process. Both app bundles and direct Cargo builds supply this string.
+        if NSBundle::mainBundle()
+            .objectForInfoDictionaryKey(ns_string!("NSMicrophoneUsageDescription"))
+            .is_none()
+        {
+            return Err(VoiceRejection::MicrophoneMetadataMissing);
+        }
+        let (tx, rx) = oneshot::channel();
+        let reply = Mutex::new(Some(tx));
+        let completion = RcBlock::new(move |granted: Bool| {
+            if let Some(tx) = reply.lock().unwrap().take() {
+                let _ = tx.send(granted.as_bool());
+            }
+        });
+        unsafe {
+            let _: () = msg_send![device,
+                requestAccessForMediaType: AVMediaTypeAudio,
+                completionHandler: &*completion
+            ];
+        }
+        Ok(Some(rx))
+    }
+}
diff --git a/crates/ui/src/voice/remote.rs b/crates/ui/src/voice/remote.rs
new file mode 100644
index 0000000000..dc2f6cfbee
--- /dev/null
+++ b/crates/ui/src/voice/remote.rs
@@ -0,0 +1,70 @@
+use crate::state::EngineHandle;
+use std::sync::Arc;
+use tokio::sync::{mpsc, watch};
+use tokio_util::sync::CancellationToken;
+use zeron_proto::voice::{remote::Sdp, *};
+use zeron_voice_session::VoiceMediaEndpoint;
+
+struct Media(zeron_voice_media::DesktopMedia);
+#[async_trait::async_trait]
+impl VoiceMediaEndpoint for Media {
+    async fn prepare(&self) -> Result<(), VoiceRejection> {
+        super::permissions::microphone().await?;
+        self.0.prepare().await
+    }
+    async fn offer(&self) -> Result<Sdp, VoiceRejection> {
+        self.0.offer().await
+    }
+    async fn apply_answer(&self, answer: Sdp) -> Result<(), VoiceRejection> {
+        self.0.apply_answer(answer).await
+    }
+    async fn set_muted(&self, muted: bool) -> Result<(), VoiceRejection> {
+        self.0.set_muted(muted).await
+    }
+    async fn levels(&self) -> Result<(u16, u16), VoiceRejection> {
+        self.0.levels().await
+    }
+    fn close(&self) {
+        self.0.close();
+    }
+}
+#[allow(clippy::too_many_arguments)]
+pub(super) async fn run(
+    engine: EngineHandle,
+    host: String,
+    config: zeron_proto::ChatConfig,
+    voice: Option<String>,
+    cancel: CancellationToken,
+    events: mpsc::Sender<VoiceEvent>,
+    mut controls: mpsc::Receiver<super::VoiceControl>,
+) -> Result<(), VoiceRejection> {
+    let client = Arc::new(
+        engine
+            .media_client()
+            .await
+            .map_err(|_| VoiceRejection::Protocol)?,
+    );
+    let control = Arc::new(zeron_voice_session::RpcTransport { client, host });
+    // Audio runs here through this device's own standalone Codex helper; the
+    // call's app-server runs on `host`. Resolution may consult the login shell.
+    let codex = tokio::task::spawn_blocking(zeron_harness::codex::resolve_codex_executable)
+        .await
+        .ok()
+        .flatten();
+    let media = Arc::new(Media(zeron_voice_media::DesktopMedia::for_codex(
+        codex.as_deref(),
+    )?));
+    let (mute_tx, muted) = watch::channel(false);
+    let call =
+        zeron_voice_session::run(control, media, config, voice, cancel.clone(), events, muted);
+    tokio::pin!(call);
+    loop {
+        tokio::select! {biased;
+            result=&mut call=>return result,
+            command=controls.recv()=>match command {
+                Some(super::VoiceControl::Mute(value))=>{mute_tx.send_replace(value);},
+                None=>{cancel.cancel();return (&mut call).await;},
+            }
+        }
+    }
+}
diff --git a/crates/ui/tests/voice_orb_geometry.rs b/crates/ui/tests/voice_orb_geometry.rs
new file mode 100644
index 0000000000..843eb0c7ee
--- /dev/null
+++ b/crates/ui/tests/voice_orb_geometry.rs
@@ -0,0 +1,352 @@
+// MIT: extracted with the orb; see THIRD_PARTY_NOTICES.md.
+//! Smoke tests + microbench for mode painters.
+
+use zeron_ui::orb::{
+    ModeKey, OrbSize, OrbState,
+    engine::{MAX_ICON_D, MAX_MORPH_DOTS, MAX_NODE_N, ModeOpts, draw_mode, sanitize_mode_opts},
+    resolve_preset,
+};
+
+#[test]
+fn all_states_emit_geometry() {
+    for &state in OrbState::ALL_STATES {
+        for &size in OrbSize::ALL_SIZES {
+            let resolved = resolve_preset(state, size);
+            let frame = draw_mode(resolved.mode, size.pixels(), 1.25, &resolved.opts);
+            assert!(
+                !frame.dots.is_empty(),
+                "{:?}/{:?} produced zero dots",
+                state,
+                size
+            );
+            for d in &frame.dots {
+                assert!(d.r.is_finite() && d.r >= 0.0);
+                assert!(d.x.is_finite() && d.y.is_finite() && d.z.is_finite());
+                assert!(d.a >= 0.0 && d.a <= 1.0 + 1e-3);
+            }
+        }
+    }
+}
+
+#[test]
+fn connecting_emits_lines() {
+    let resolved = resolve_preset(OrbState::Connecting, OrbSize::Avatar);
+    let frame = draw_mode(resolved.mode, 64.0, 2.0, &resolved.opts);
+    assert!(!frame.lines.is_empty(), "connecting should wire edges");
+    assert!(!frame.dots.is_empty());
+}
+
+#[test]
+fn reduced_motion_frame_is_deterministic() {
+    let resolved = resolve_preset(OrbState::Working, OrbSize::Avatar);
+    let a = draw_mode(resolved.mode, 64.0, 0.6, &resolved.opts);
+    let b = draw_mode(resolved.mode, 64.0, 0.6, &resolved.opts);
+    assert_eq!(a.dots.len(), b.dots.len());
+    for (da, db) in a.dots.iter().zip(b.dots.iter()) {
+        assert!((da.x - db.x).abs() < 1e-4);
+        assert!((da.y - db.y).abs() < 1e-4);
+    }
+}
+
+#[test]
+fn solve_cycle_survives_float_boundary_move_counts() {
+    // `move_count` is a public `ModeOpts` knob. Certain values put the slot
+    // boundary exactly on a float rounding edge, where `tc / slot_dur` reaches
+    // `2 * count` even though the `tc < 2 * count * slot_dur` guard passed —
+    // which used to underflow `2*count-1-slot` to `usize::MAX` and panic.
+    //
+    // Sweep enough move counts and adjacent float values to exercise rounding
+    // at both forward and reverse slot boundaries.
+    const SLOT_DUR: f32 = 0.58;
+    let resolved = resolve_preset(OrbState::Solving, OrbSize::Avatar);
+    for count in 1..40u32 {
+        let mut opts = resolved.opts.clone();
+        opts.move_count = Some(count as f32);
+        for c in 1..=count {
+            // Step onto the largest float strictly below each slot boundary.
+            let boundary = 2.0 * c as f32 * SLOT_DUR;
+            for t in [
+                f32::from_bits(boundary.to_bits() - 1),
+                boundary,
+                f32::from_bits(boundary.to_bits() + 1),
+            ] {
+                let frame = draw_mode(resolved.mode, 64.0, t, &opts);
+                assert!(!frame.dots.is_empty());
+            }
+        }
+    }
+}
+
+#[test]
+fn new_concepts_are_distinct_low_density_modes() {
+    let concepts = [
+        (OrbState::Focusing, ModeKey::Focus, 77, 23),
+        (OrbState::Reasoning, ModeKey::Gyroscope, 90, 32),
+        (OrbState::Recalling, ModeKey::Echo, 75, 21),
+    ];
+
+    for (state, mode, avatar_dots, inline_dots) in concepts {
+        assert_eq!(ModeKey::from_state(state), mode);
+        assert!(OrbState::ALL_STATES.contains(&state));
+        for (size, expected) in [
+            (OrbSize::Avatar, avatar_dots),
+            (OrbSize::Inline, inline_dots),
+        ] {
+            let resolved = resolve_preset(state, size);
+            let frame = draw_mode(resolved.mode, size.pixels(), 0.6, &resolved.opts);
+            assert_eq!(frame.dots.len(), expected, "{state:?}/{size:?}");
+            assert!(
+                frame.lines.is_empty(),
+                "new concepts stay on the dot-only paint path"
+            );
+            assert!(
+                frame.dots.len() < 100,
+                "new concepts must remain low density"
+            );
+        }
+    }
+}
+
+#[test]
+fn new_concepts_animate_and_keep_their_depth_identity() {
+    for &state in &[OrbState::Focusing, OrbState::Reasoning, OrbState::Recalling] {
+        let resolved = resolve_preset(state, OrbSize::Avatar);
+        let a = draw_mode(resolved.mode, 64.0, 0.2, &resolved.opts);
+        let b = draw_mode(resolved.mode, 64.0, 1.2, &resolved.opts);
+        assert!(
+            a.dots
+                .iter()
+                .zip(&b.dots)
+                .any(|(a, b)| (a.x - b.x).abs() > 0.01 || (a.y - b.y).abs() > 0.01),
+            "{state:?} did not animate"
+        );
+
+        let has_depth = a.dots.iter().any(|dot| dot.z.abs() > 0.01);
+        assert_eq!(has_depth, state == OrbState::Reasoning);
+    }
+}
+
+#[test]
+fn larger_sizes_add_detail_without_changing_the_legacy_presets() {
+    assert_eq!(OrbSize::ALL_SIZES.len(), 4);
+    assert_eq!(OrbSize::Large.pixels(), 96.0);
+    assert_eq!(OrbSize::Hero.pixels(), 128.0);
+
+    for &state in OrbState::ALL_STATES {
+        let avatar = resolve_preset(state, OrbSize::Avatar);
+        let large = resolve_preset(state, OrbSize::Large);
+        let hero = resolve_preset(state, OrbSize::Hero);
+        let avatar_frame = draw_mode(avatar.mode, 64.0, 0.6, &avatar.opts);
+        let large_frame = draw_mode(large.mode, 96.0, 0.6, &large.opts);
+        let hero_frame = draw_mode(hero.mode, 128.0, 0.6, &hero.opts);
+
+        assert_eq!(avatar.mode, large.mode);
+        assert_eq!(avatar.mode, hero.mode);
+        assert!(
+            large_frame.dots.len() >= avatar_frame.dots.len(),
+            "{state:?}/large"
+        );
+        assert!(
+            hero_frame.dots.len() >= large_frame.dots.len(),
+            "{state:?}/hero"
+        );
+        assert!(large.speed <= avatar.speed);
+        assert!(hero.speed <= large.speed);
+    }
+}
+
+#[test]
+fn legacy_all_constant_keeps_its_original_array_shape() {
+    #[allow(deprecated)]
+    let original_nine: [OrbState; 9] = OrbState::ALL;
+    assert_eq!(original_nine.len(), 9);
+    assert_eq!(OrbState::ALL_STATES.len(), 12);
+}
+
+#[test]
+fn bench_geometry_cost() {
+    use std::time::Instant;
+    for &state in OrbState::ALL_STATES {
+        for &size in OrbSize::ALL_SIZES {
+            let resolved = resolve_preset(state, size);
+            for i in 0..20 {
+                let _ = draw_mode(
+                    resolved.mode,
+                    size.pixels(),
+                    i as f32 * 0.016,
+                    &resolved.opts,
+                );
+            }
+            let n = 1000usize;
+            let t0 = Instant::now();
+            let mut total_dots = 0usize;
+            let mut total_lines = 0usize;
+            for i in 0..n {
+                let f = draw_mode(
+                    resolved.mode,
+                    size.pixels(),
+                    i as f32 * 0.016,
+                    &resolved.opts,
+                );
+                total_dots += f.dots.len();
+                total_lines += f.lines.len();
+            }
+            let elapsed = t0.elapsed();
+            let per = elapsed / n as u32;
+            let avg_dots = total_dots / n;
+            let avg_lines = total_lines / n;
+            eprintln!(
+                "{:>12}/{:<6}  {:>5} dots  {:>4} lines  {:>8.2?} /frame  (~{:.0}k geom-fps)",
+                state.as_str(),
+                size.pixels() as u32,
+                avg_dots,
+                avg_lines,
+                per,
+                1.0 / per.as_secs_f64() / 1000.0
+            );
+        }
+    }
+}
+
+/// Strokes are painted at their exact colour, one `Path` per segment. Batching
+/// them into shared paths was tried and reverted for visibly brightening the
+/// web (see `paint.rs`), so what matters now is that every alpha the engine
+/// emits is in range and finite — a stroke painter has no clamping to hide
+/// behind.
+#[test]
+fn stroke_colours_are_paintable() {
+    let resolved = resolve_preset(OrbState::Connecting, OrbSize::Avatar);
+    let mut seen = 0usize;
+    for i in 0..400 {
+        let frame = draw_mode(resolved.mode, 64.0, i as f32 * 0.05, &resolved.opts);
+        for l in &frame.lines {
+            assert!(
+                l.a.is_finite() && (0.0..=1.0).contains(&l.a),
+                "alpha {}",
+                l.a
+            );
+            assert!(
+                l.white.is_finite() && (0.0..=1.0).contains(&l.white),
+                "white {}",
+                l.white
+            );
+            assert!(l.w.is_finite() && l.w > 0.0, "stroke width {}", l.w);
+            assert!(l.x1.is_finite() && l.y1.is_finite());
+            assert!(l.x2.is_finite() && l.y2.is_finite());
+            seen += 1;
+        }
+    }
+    assert!(seen > 0, "connecting emitted no strokes across 400 frames");
+}
+
+#[test]
+fn adversarial_mode_opts_stay_bounded_and_finite() {
+    // Power-user knobs used to accept Inf / huge finites and OOM or NaN.
+    // draw_mode_into sanitizes first; geometry must stay finite and small.
+    let cases: &[(ModeKey, ModeOpts)] = &[
+        (
+            ModeKey::Web,
+            ModeOpts::fill(ModeKey::Web, |o| {
+                o.node_n = Some(f32::INFINITY);
+                o.signals = Some(1.0e12);
+            }),
+        ),
+        (
+            ModeKey::Globe,
+            ModeOpts::fill(ModeKey::Globe, |o| {
+                o.lat_rings = Some(0.0);
+                o.lon_density = Some(5_000.0);
+            }),
+        ),
+        (
+            ModeKey::Rubik,
+            ModeOpts::fill(ModeKey::Rubik, |o| {
+                o.lat_rings = Some(0.0);
+                o.move_count = Some(1.0e7);
+            }),
+        ),
+        (
+            ModeKey::Wave,
+            ModeOpts::fill(ModeKey::Wave, |o| {
+                o.rings = Some(0.0);
+                o.lon_density = Some(f32::NAN);
+            }),
+        ),
+        (
+            ModeKey::Orbits,
+            ModeOpts::fill(ModeKey::Orbits, |o| {
+                o.orbit_n = Some(f32::INFINITY);
+                o.ghost_n = Some(1.0e9);
+                o.particles = Some(1.0e6);
+            }),
+        ),
+        (
+            ModeKey::Morph,
+            ModeOpts::fill(ModeKey::Morph, |o| {
+                o.icon_d = Some(1.0e6);
+            }),
+        ),
+        (
+            ModeKey::Ribbon,
+            ModeOpts::fill(ModeKey::Ribbon, |o| {
+                o.lanes = Some(1.0e6);
+                o.segs = Some(1.0e6);
+                o.band_mul = Some(1.0e6);
+                o.ghost_n = Some(1.0e9);
+            }),
+        ),
+        (
+            ModeKey::Braid,
+            ModeOpts::fill(ModeKey::Braid, |o| {
+                o.strand_n = Some(1.0e9);
+                o.ghost_n = Some(1.0e9);
+            }),
+        ),
+    ];
+
+    for (mode, opts) in cases {
+        let frame = draw_mode(*mode, 64.0, 1.25, opts);
+        assert!(
+            frame.dots.len() <= 80_000,
+            "{mode:?} emitted {} dots — sanitize failed",
+            frame.dots.len()
+        );
+        for d in &frame.dots {
+            assert!(d.x.is_finite() && d.y.is_finite() && d.z.is_finite() && d.r.is_finite());
+        }
+        for l in &frame.lines {
+            assert!(l.x1.is_finite() && l.y1.is_finite() && l.x2.is_finite() && l.y2.is_finite());
+        }
+    }
+
+    let morph = draw_mode(
+        ModeKey::Morph,
+        64.0,
+        0.6,
+        &ModeOpts::fill(ModeKey::Morph, |o| {
+            o.icon_d = Some(MAX_ICON_D * 100.0);
+        }),
+    );
+    assert!(morph.dots.len() <= MAX_MORPH_DOTS);
+
+    let web = draw_mode(
+        ModeKey::Web,
+        64.0,
+        1.0,
+        &ModeOpts::fill(ModeKey::Web, |o| {
+            o.node_n = Some(MAX_NODE_N * 10.0);
+        }),
+    );
+    // node_n capped → dots include nodes + a few signal packets
+    assert!(web.dots.len() < MAX_NODE_N as usize + 100);
+
+    // The base mode is irrelevant here: the sanitizer is what is on trial.
+    let clean = sanitize_mode_opts(&ModeOpts::fill(ModeKey::Web, |o| {
+        o.node_n = Some(f32::INFINITY);
+        o.lat_rings = Some(-3.0);
+        o.icon_d = Some(f32::NAN);
+    }));
+    assert_eq!(clean.node_n, None); // non-finite → dropped
+    assert_eq!(clean.lat_rings, Some(1.0)); // clamped up
+    assert_eq!(clean.icon_d, None);
+}
diff --git a/crates/veil/Cargo.toml b/crates/veil/Cargo.toml
new file mode 100644
index 0000000000..2ad0885985
--- /dev/null
+++ b/crates/veil/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "zeron-veil"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+# The streaming fade veil without a renderer: the desktop transcript recolors
+# GPUI runs with it; voice captions use it on desktop and mobile.
+[dependencies]
diff --git a/crates/veil/src/caption.rs b/crates/veil/src/caption.rs
new file mode 100644
index 0000000000..d793cdfa2b
--- /dev/null
+++ b/crates/veil/src/caption.rs
@@ -0,0 +1,204 @@
+//! A live voice caption: the tail of the current utterance, its streamed words
+//! veiled in exactly like transcript text, and the previous utterance fading
+//! out when the speaker turn changes.
+use crate::{ElemVeil, VeilSpan, slice_spans, veil_opacity};
+use std::time::Instant;
+
+/// The previous utterance fades out over this long when the turn changes.
+pub const CAPTION_EXIT_MS: f32 = 180.0;
+
+/// Text tail of `text` holding at most `max` characters, ellipsized in front.
+pub fn caption_tail(text: &str, max: usize) -> String {
+    caption_window(text, max).0
+}
+
+/// The shown tail, the byte offset in `text` where it starts, and the length
+/// of the ellipsis in front of it.
+fn caption_window(text: &str, max: usize) -> (String, usize, usize) {
+    let start = text.len() - text.trim_start().len();
+    let end = text.trim_end().len().max(start);
+    let body = &text[start..end];
+    let count = body.chars().count();
+    if count <= max {
+        return (body.to_owned(), start, 0);
+    }
+    let skip = body
+        .char_indices()
+        .nth(count - max)
+        .map_or(body.len(), |(i, _)| i);
+    let tail = &body[skip..];
+    let shown = tail.trim_start();
+    let ellipsis = '…'.len_utf8();
+    (
+        format!("…{shown}"),
+        start + skip + (tail.len() - shown.len()),
+        ellipsis,
+    )
+}
+
+/// One frame of a caption.
+#[derive(Debug, Clone, PartialEq)]
+pub struct CaptionFrame {
+    pub text: String,
+    /// Veiled byte ranges of `text` and their opacity (0..1).
+    pub spans: Vec<VeilSpan>,
+    /// The previous utterance while it fades out, and its opacity.
+    pub previous: Option<(String, f32)>,
+}
+
+/// Veil state for one call's caption. Advance it with the current utterance
+/// on every frame while [`is_animating`](Self::is_animating).
+pub struct CaptionVeil {
+    max_chars: usize,
+    item: Option<String>,
+    veil: ElemVeil,
+    shown: String,
+    outgoing: Option<(String, Instant)>,
+}
+
+impl CaptionVeil {
+    pub fn new(max_chars: usize) -> Self {
+        Self {
+            max_chars,
+            item: None,
+            veil: ElemVeil::default(),
+            shown: String::new(),
+            outgoing: None,
+        }
+    }
+
+    /// Advance to `text` of utterance `item` at `now`. A new item fades the
+    /// previous caption out and the new one in from empty; a final that
+    /// repeats its partials never re-animates. Reduced motion shows text
+    /// directly but keeps tracking it, so turning motion back on mid-call
+    /// does not re-fade what is already on screen.
+    pub fn advance(
+        &mut self,
+        item: Option<&str>,
+        text: &str,
+        now: Instant,
+        reduced_motion: bool,
+    ) -> CaptionFrame {
+        if item != self.item.as_deref() {
+            let previous = std::mem::take(&mut self.shown);
+            self.outgoing = (!previous.is_empty() && !reduced_motion).then_some((previous, now));
+            self.item = item.map(str::to_owned);
+            self.veil = ElemVeil::default();
+        }
+        let spans = self.veil.advance(text, now);
+        let (shown, from, ellipsis) = caption_window(text, self.max_chars);
+        let spans = if reduced_motion {
+            Vec::new()
+        } else {
+            slice_spans(&spans, from, from + shown.len() - ellipsis)
+                .into_iter()
+                .map(|(range, alpha)| (range.start + ellipsis..range.end + ellipsis, alpha))
+                .collect()
+        };
+        self.shown.clone_from(&shown);
+        let previous = self.outgoing.take().and_then(|(previous, started)| {
+            let elapsed = now.saturating_duration_since(started).as_secs_f32() * 1000.0;
+            let progress = elapsed / CAPTION_EXIT_MS;
+            (progress < 1.0 && !reduced_motion).then(|| {
+                self.outgoing = Some((previous.clone(), started));
+                (previous, 1.0 - veil_opacity(progress))
+            })
+        });
+        CaptionFrame {
+            text: shown,
+            spans,
+            previous,
+        }
+    }
+
+    /// Something is still fading (as of the last advance): keep repainting.
+    pub fn is_animating(&self) -> bool {
+        self.veil.is_fading() || self.outgoing.is_some()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    fn at(base: Instant, ms: u64) -> Instant {
+        base + Duration::from_millis(ms)
+    }
+
+    #[test]
+    fn caption_keeps_the_latest_words_of_a_long_utterance() {
+        assert_eq!(caption_tail("  short  ", 10), "short");
+        assert_eq!(caption_tail("one two three four five", 9), "…four five");
+        // Multibyte text is cut on character boundaries.
+        assert_eq!(caption_tail("ñandú camión", 6), "…camión");
+        assert_eq!(caption_tail("   ", 6), "");
+    }
+
+    #[test]
+    fn streamed_words_fade_in_once_and_settle() {
+        let t0 = Instant::now();
+        let mut caption = CaptionVeil::new(160);
+        let frame = caption.advance(Some("a"), "Hello", t0, false);
+        assert_eq!(frame.text, "Hello");
+        assert_eq!(frame.spans, vec![(0..5, 0.0)]);
+        let frame = caption.advance(Some("a"), "Hello there", at(t0, 100), false);
+        assert_eq!(frame.spans.len(), 2);
+        assert_eq!(frame.spans[1].0, 5..11);
+        assert!(caption.is_animating());
+        // The final repeats the partials: nothing re-animates.
+        let frame = caption.advance(Some("a"), "Hello there", at(t0, 900), false);
+        assert!(frame.spans.is_empty());
+        assert!(!caption.is_animating());
+    }
+
+    #[test]
+    fn veil_follows_the_visible_tail_of_a_long_utterance() {
+        let t0 = Instant::now();
+        let mut caption = CaptionVeil::new(9);
+        caption.advance(Some("a"), "one two three four", t0, false);
+        // Settle, then append: only the new word is veiled, at its position in
+        // the ellipsized tail rather than the full utterance.
+        caption.advance(Some("a"), "one two three four", at(t0, 900), false);
+        let frame = caption.advance(Some("a"), "one two three four five", at(t0, 1000), false);
+        assert_eq!(frame.text, "…four five");
+        let ellipsis = '…'.len_utf8();
+        assert_eq!(frame.spans, vec![(ellipsis + 4..ellipsis + 9, 0.0)]);
+        assert_eq!(&frame.text[frame.spans[0].0.clone()], " five");
+    }
+
+    #[test]
+    fn a_new_turn_fades_the_previous_caption_out() {
+        let t0 = Instant::now();
+        let mut caption = CaptionVeil::new(160);
+        caption.advance(Some("user"), "Open the sync test", t0, false);
+        caption.advance(Some("user"), "Open the sync test", at(t0, 900), false);
+        let frame = caption.advance(Some("assistant"), "On it", at(t0, 1000), false);
+        assert_eq!(
+            frame.spans,
+            vec![(0..5, 0.0)],
+            "the new turn fades in from empty"
+        );
+        let (previous, alpha) = frame.previous.unwrap();
+        assert_eq!(previous, "Open the sync test");
+        assert_eq!(alpha, 1.0);
+        let frame = caption.advance(Some("assistant"), "On it", at(t0, 1090), false);
+        let (_, alpha) = frame.previous.unwrap();
+        assert!(alpha > 0.0 && alpha < 1.0);
+        let frame = caption.advance(Some("assistant"), "On it", at(t0, 1200), false);
+        assert!(frame.previous.is_none());
+    }
+
+    #[test]
+    fn reduced_motion_shows_text_directly_and_never_refades_it() {
+        let t0 = Instant::now();
+        let mut caption = CaptionVeil::new(160);
+        caption.advance(Some("a"), "Hi", t0, false);
+        let frame = caption.advance(Some("b"), "Hello", at(t0, 50), true);
+        assert!(frame.spans.is_empty());
+        assert!(frame.previous.is_none());
+        // Motion back on: the text already shown stays settled.
+        let frame = caption.advance(Some("b"), "Hello", at(t0, 900), false);
+        assert!(frame.spans.is_empty());
+    }
+}
diff --git a/crates/veil/src/lib.rs b/crates/veil/src/lib.rs
new file mode 100644
index 0000000000..53b7b3d9cb
--- /dev/null
+++ b/crates/veil/src/lib.rs
@@ -0,0 +1,402 @@
+//! Streaming fade veil — per-appended-chunk opacity over already-committed text.
+//!
+//! The desktop app (docs/research/mugen-pretext.md §2e) commits streamed text to
+//! layout instantly and dissolves a purely cosmetic veil over the newly arrived
+//! characters. This crate is the renderer-agnostic part, shared by the desktop
+//! transcript (`zeron-ui`, which recolors GPUI text runs) and the voice call
+//! captions on desktop and mobile:
+//!
+//! - [`ElemVeil`] tracks, per rendered text element, the previously rendered
+//!   flat text. Each append registers the new byte range as a chunk with its
+//!   arrival time; a fast stream keeps several chunks fading concurrently (a
+//!   rolling veil). A chunk fades exactly once — already-faded text never
+//!   re-animates, and a fully settled element returns no spans at all.
+//! - [`CaptionVeil`] veils a live caption shown as the tail of a long
+//!   utterance, and fades the previous utterance out when the speaker turn
+//!   changes.
+//!
+//! Constants and curve match mugen-markdown's web `FadePainter` (the engine the
+//! desktop app ships): per-chunk duration adapts to the stream's cadence — an
+//! EMA of inter-append gaps, `duration = clamp(ema × 3, 120ms, 400ms)` — the
+//! dissolve eases with `veil = (1 − p)^1.6` (text alpha `1 − veil`), and a
+//! backed-up stream (3+ concurrent chunks) gets a small speed boost. **Zero
+//! translate** — opacity only, per the "no positional offset on streamed
+//! content" rule.
+
+mod caption;
+pub use caption::{CAPTION_EXIT_MS, CaptionFrame, CaptionVeil, caption_tail};
+
+use std::collections::HashMap;
+use std::ops::Range;
+use std::time::Instant;
+
+/// EMA seed for the inter-append gap (mugen `EMA_SEED_MS`).
+pub const VEIL_EMA_SEED_MS: f32 = 160.0;
+/// Duration clamp (mugen `MIN_FADE_MS` / `MAX_FADE_MS`).
+pub const VEIL_MIN_FADE_MS: f32 = 120.0;
+pub const VEIL_MAX_FADE_MS: f32 = 400.0;
+/// Dissolve exponent (mugen: `alpha = (1 - p) ** 1.6`).
+pub const VEIL_CURVE_POW: f32 = 1.6;
+/// Gap clamp feeding the EMA (mugen: `min(gap, 1000)`).
+const VEIL_GAP_CLAMP_MS: f32 = 1000.0;
+
+/// One appended chunk of text mid-fade.
+#[derive(Debug, Clone)]
+struct Chunk {
+    /// Byte range in the element's flat text.
+    range: Range<usize>,
+    started: Instant,
+    /// Fade duration fixed at arrival from the cadence EMA.
+    duration_ms: f32,
+}
+
+/// A veiled byte range and its current opacity (0..1).
+pub type VeilSpan = (Range<usize>, f32);
+
+/// Text alpha for a fade progress `p` (0..1): the veil dissolves as
+/// `(1 − p)^1.6`, so the text shows through at `1 − veil`. Pure.
+pub fn veil_opacity(p: f32) -> f32 {
+    1.0 - (1.0 - p.clamp(0.0, 1.0)).powf(VEIL_CURVE_POW)
+}
+
+/// Chunk fade duration for the current inter-append EMA (mugen:
+/// `min(MAX, max(MIN, ema * 3))`).
+pub fn veil_duration_ms(ema_ms: f32) -> f32 {
+    (ema_ms * 3.0).clamp(VEIL_MIN_FADE_MS, VEIL_MAX_FADE_MS)
+}
+
+/// Fast-stream boost: 3+ chunks fading concurrently speed up by 30% each
+/// (mugen: `1 + 0.3 * max(0, veils.length - 2)`).
+pub fn veil_boost(active_chunks: usize) -> f32 {
+    1.0 + 0.3 * active_chunks.saturating_sub(2) as f32
+}
+
+/// EMA update on a new append gap (mugen: `ema*0.7 + min(gap,1000)*0.3`).
+pub fn veil_ema_next(ema_ms: f32, gap_ms: f32) -> f32 {
+    ema_ms * 0.7 + gap_ms.min(VEIL_GAP_CLAMP_MS) * 0.3
+}
+
+/// Per-element chunk tracker: remembers the last rendered flat text and fades
+/// every newly appended suffix exactly once.
+#[derive(Debug)]
+pub struct ElemVeil {
+    prev: String,
+    chunks: Vec<Chunk>,
+    /// EMA of inter-append gaps (drives per-chunk durations).
+    ema_ms: f32,
+    last_append: Option<Instant>,
+}
+
+impl Default for ElemVeil {
+    fn default() -> Self {
+        Self {
+            prev: String::new(),
+            chunks: Vec::new(),
+            ema_ms: VEIL_EMA_SEED_MS,
+            last_append: None,
+        }
+    }
+}
+
+/// Longest common prefix length, snapped back to a char boundary.
+fn common_prefix(a: &str, b: &str) -> usize {
+    let mut p = a
+        .as_bytes()
+        .iter()
+        .zip(b.as_bytes())
+        .take_while(|(x, y)| x == y)
+        .count();
+    while p > 0 && !b.is_char_boundary(p) {
+        p -= 1;
+    }
+    p
+}
+
+impl ElemVeil {
+    /// Adopt `text` as the committed baseline without fading it — the attach
+    /// semantics of mugen's `FadePainter.attach` (`length =
+    /// chromeFreeLength(content)`): content already on screen when the painter
+    /// attaches never animates; only later appends do.
+    fn seed(&mut self, text: &str) {
+        self.prev.clear();
+        self.prev.push_str(text);
+    }
+
+    /// Advance to `text` at `now`: registers a fading chunk for newly appended
+    /// bytes, prunes settled chunks, and returns the active spans. Idempotent
+    /// for unchanged text — safe to call once per frame (or twice, when a row
+    /// is both measured and painted).
+    pub fn advance(&mut self, text: &str, now: Instant) -> Vec<VeilSpan> {
+        if text != self.prev {
+            // Non-append rewrites (the incremental parser re-deriving a block's
+            // flat text — e.g. `**bold` collapsing into a bold run) keep the
+            // common prefix's committed fades and re-veil only the changed tail.
+            let p = common_prefix(&self.prev, text);
+            self.chunks.retain_mut(|c| {
+                c.range.end = c.range.end.min(p);
+                c.range.start < c.range.end
+            });
+            if text.len() > p {
+                // Cadence-adaptive duration (mugen FadePainter): update the
+                // EMA with the gap since the previous append.
+                if let Some(last) = self.last_append {
+                    let gap = now.saturating_duration_since(last).as_secs_f32() * 1000.0;
+                    self.ema_ms = veil_ema_next(self.ema_ms, gap);
+                }
+                self.last_append = Some(now);
+                self.chunks.push(Chunk {
+                    range: p..text.len(),
+                    started: now,
+                    duration_ms: veil_duration_ms(self.ema_ms),
+                });
+            }
+            self.prev.clear();
+            self.prev.push_str(text);
+        }
+        let boost = veil_boost(self.chunks.len());
+        self.chunks.retain(|c| {
+            let elapsed = now.saturating_duration_since(c.started).as_secs_f32() * 1000.0;
+            elapsed * boost < c.duration_ms
+        });
+        let boost = veil_boost(self.chunks.len());
+        self.chunks
+            .iter()
+            .map(|c| {
+                let elapsed = now.saturating_duration_since(c.started).as_secs_f32() * 1000.0;
+                let progress = (elapsed * boost / c.duration_ms).clamp(0.0, 1.0);
+                (c.range.clone(), veil_opacity(progress))
+            })
+            .collect()
+    }
+
+    /// Any chunk still fading (as of the last [`advance`](Self::advance))?
+    pub fn is_fading(&self) -> bool {
+        !self.chunks.is_empty()
+    }
+}
+
+/// Veil state for one live streaming row, keyed by the render tree's stable
+/// per-element discriminator (top-level block ix / nested ix scheme — stable
+/// across appends because the incremental parser only reparses the tail).
+#[derive(Debug, Default)]
+pub struct RowVeil {
+    elems: HashMap<usize, ElemVeil>,
+    /// Attach pass in progress: elements first seen while seeding adopt their
+    /// current text as the committed baseline instead of fading it in. Set for
+    /// rows that already carried text when the transcript (re)attached to the
+    /// chat — switching back to a streaming session must not dissolve the
+    /// whole existing reply (user report; mugen's `FadePainter.attach` baseline).
+    seeding: bool,
+}
+
+impl RowVeil {
+    /// A veil whose first render pass seeds baselines instead of fading.
+    pub fn seeded() -> Self {
+        Self {
+            elems: HashMap::new(),
+            seeding: true,
+        }
+    }
+
+    /// The attach pass is over — elements that appear from here on are newly
+    /// streamed content and fade normally.
+    pub fn finish_seeding(&mut self) {
+        self.seeding = false;
+    }
+
+    pub fn advance(&mut self, elem: usize, text: &str, now: Instant) -> Vec<VeilSpan> {
+        if self.seeding && !self.elems.contains_key(&elem) {
+            let mut baseline = ElemVeil::default();
+            baseline.seed(text);
+            self.elems.insert(elem, baseline);
+            return Vec::new();
+        }
+        self.elems.entry(elem).or_default().advance(text, now)
+    }
+
+    /// Any element still fading? Drives the once-per-frame repaint request.
+    pub fn is_fading(&self) -> bool {
+        self.elems.values().any(ElemVeil::is_fading)
+    }
+}
+
+/// Intersect spans with `[start, end)` and shift them to local offsets — used
+/// by per-line code rendering where chunks are tracked on the whole code text.
+pub fn slice_spans(spans: &[VeilSpan], start: usize, end: usize) -> Vec<VeilSpan> {
+    spans
+        .iter()
+        .filter_map(|(r, a)| {
+            let s = r.start.max(start);
+            let e = r.end.min(end);
+            (s < e).then(|| (s - start..e - start, *a))
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    fn at(base: Instant, ms: u64) -> Instant {
+        base + Duration::from_millis(ms)
+    }
+
+    #[test]
+    fn first_text_fades_and_settles_once() {
+        let t0 = Instant::now();
+        let mut v = ElemVeil::default();
+        let spans = v.advance("hello", t0);
+        assert_eq!(spans, vec![(0..5, 0.0)]);
+        // Mid-fade: opacity strictly between 0 and 1, range unchanged.
+        let spans = v.advance("hello", at(t0, 250));
+        assert_eq!(spans.len(), 1);
+        assert!(spans[0].1 > 0.0 && spans[0].1 < 1.0);
+        // Settled: pruned, never re-animates.
+        assert!(v.advance("hello", at(t0, 600)).is_empty());
+        assert!(!v.is_fading());
+        assert!(v.advance("hello", at(t0, 700)).is_empty());
+    }
+
+    #[test]
+    fn appended_chunks_fade_concurrently_and_independently() {
+        let t0 = Instant::now();
+        let mut v = ElemVeil::default();
+        v.advance("one ", t0);
+        let spans = v.advance("one two ", at(t0, 100));
+        assert_eq!(spans.len(), 2);
+        assert_eq!(spans[0].0, 0..4);
+        assert_eq!(spans[1].0, 4..8);
+        // The older chunk is further along its fade than the newer one.
+        assert!(spans[0].1 > spans[1].1);
+        // After the first settles (past its adaptive duration), only the
+        // newer chunk remains.
+        let spans = v.advance("one two ", at(t0, 410));
+        assert_eq!(spans.len(), 1);
+        assert_eq!(spans[0].0, 4..8);
+    }
+
+    #[test]
+    fn fade_constants_match_mugen_fade_painter() {
+        // @wingleeio/mugen-markdown dist/index.mjs: EMA_SEED_MS=160,
+        // MIN_FADE_MS=120, MAX_FADE_MS=400, alpha=(1-p)**1.6,
+        // ema = ema*0.7 + min(gap,1000)*0.3, boost = 1 + 0.3*max(0,n-2).
+        assert_eq!(VEIL_EMA_SEED_MS, 160.0);
+        assert_eq!(VEIL_MIN_FADE_MS, 120.0);
+        assert_eq!(VEIL_MAX_FADE_MS, 400.0);
+        assert_eq!(VEIL_CURVE_POW, 1.6);
+        // duration = clamp(ema*3, 120, 400).
+        assert_eq!(veil_duration_ms(160.0), 400.0); // seed → clamped at max
+        assert_eq!(veil_duration_ms(30.0), 120.0); // fast stream → floor
+        assert_eq!(veil_duration_ms(60.0), 180.0);
+        // EMA update.
+        assert_eq!(veil_ema_next(160.0, 100.0), 160.0 * 0.7 + 100.0 * 0.3);
+        assert_eq!(veil_ema_next(160.0, 5000.0), 160.0 * 0.7 + 1000.0 * 0.3);
+        // Fast-stream boost kicks in at the 3rd concurrent chunk.
+        assert_eq!(veil_boost(0), 1.0);
+        assert_eq!(veil_boost(2), 1.0);
+        assert!((veil_boost(3) - 1.3).abs() < 1e-6);
+        assert!((veil_boost(5) - 1.9).abs() < 1e-6);
+    }
+
+    #[test]
+    fn seeded_row_adopts_existing_text_without_fading() {
+        // Switching back to a streaming session: the text already on screen is
+        // the attach BASELINE (mugen FadePainter.attach) — no full-reply fade.
+        let t0 = Instant::now();
+        let mut row = RowVeil::seeded();
+        assert!(row.advance(0, "already streamed text", t0).is_empty());
+        assert!(row.advance(1, "second block", t0).is_empty());
+        assert!(!row.is_fading());
+        // Appends AFTER the attach fade normally — only the new suffix.
+        let spans = row.advance(0, "already streamed text plus", at(t0, 100));
+        assert_eq!(spans, vec![(21..26, 0.0)]);
+        // The attach pass ends after the first render: elements first seen
+        // later are newly streamed content and fade from empty.
+        row.finish_seeding();
+        let spans = row.advance(2, "new block", at(t0, 200));
+        assert_eq!(spans, vec![(0..9, 0.0)]);
+    }
+
+    #[test]
+    fn default_row_veil_fades_first_text() {
+        // Mid-stream new rows keep the old behavior: their first chunk fades.
+        let t0 = Instant::now();
+        let mut row = RowVeil::default();
+        let spans = row.advance(0, "fresh", t0);
+        assert_eq!(spans, vec![(0..5, 0.0)]);
+    }
+
+    #[test]
+    fn faded_text_never_reanimates_on_append() {
+        let t0 = Instant::now();
+        let mut v = ElemVeil::default();
+        v.advance("stable", t0);
+        // Fully settled...
+        assert!(v.advance("stable", at(t0, 600)).is_empty());
+        // ...then an append veils ONLY the new suffix.
+        let spans = v.advance("stable more", at(t0, 700));
+        assert_eq!(spans, vec![(6..11, 0.0)]);
+    }
+
+    #[test]
+    fn non_append_rewrite_keeps_prefix_and_reveils_tail() {
+        let t0 = Instant::now();
+        let mut v = ElemVeil::default();
+        v.advance("intro **bol", t0);
+        // Markdown resolves: flat text loses the `**` marker.
+        let spans = v.advance("intro bold", at(t0, 100));
+        // The shared prefix's chunk is clamped, the changed tail is one chunk.
+        assert_eq!(spans.len(), 2);
+        assert_eq!(spans[0].0, 0..6);
+        assert_eq!(spans[1].0, 6..10);
+        assert!(spans[0].1 > spans[1].1);
+    }
+
+    #[test]
+    fn common_prefix_respects_char_boundaries() {
+        // "é" = 0xC3 0xA9, "è" = 0xC3 0xA8 — byte prefix would split the char.
+        assert_eq!(common_prefix("é", "è"), 0);
+        assert_eq!(common_prefix("abé", "abè"), 2);
+        assert_eq!(common_prefix("same", "same"), 4);
+    }
+
+    #[test]
+    fn veil_opacity_curve_endpoints() {
+        // Text alpha = 1 - (1-p)^1.6: 0 at arrival, 1 when the veil is gone.
+        assert_eq!(veil_opacity(0.0), 0.0);
+        assert_eq!(veil_opacity(1.0), 1.0);
+        let mid = veil_opacity(0.5);
+        assert!(mid > 0.0 && mid < 1.0);
+        // The pow-1.6 ease-out reveals faster than linear early on.
+        assert!(mid > 0.5);
+        assert!((mid - (1.0 - 0.5f32.powf(1.6))).abs() < 1e-6);
+        // Monotonic + clamped.
+        assert!(veil_opacity(0.2) <= veil_opacity(0.4));
+        assert_eq!(veil_opacity(-1.0), 0.0);
+        assert_eq!(veil_opacity(2.0), 1.0);
+    }
+
+    #[test]
+    fn slice_spans_shifts_to_local_offsets() {
+        let spans = vec![(3..10, 0.4), (12..20, 0.1)];
+        // A "line" covering bytes 5..15.
+        let local = slice_spans(&spans, 5, 15);
+        assert_eq!(local, vec![(0..5, 0.4), (7..10, 0.1)]);
+        // Disjoint window → empty.
+        assert!(slice_spans(&spans, 25, 30).is_empty());
+    }
+
+    #[test]
+    fn row_veil_tracks_elements_independently() {
+        let t0 = Instant::now();
+        let mut row = RowVeil::default();
+        row.advance(0, "para", t0);
+        row.advance(2, "code", t0);
+        assert!(row.is_fading());
+        row.advance(0, "para", at(t0, 600));
+        assert!(row.is_fading(), "elem 2 hasn't been advanced past its fade");
+        row.advance(2, "code", at(t0, 600));
+        assert!(!row.is_fading());
+    }
+}
diff --git a/crates/voice-media/Cargo.toml b/crates/voice-media/Cargo.toml
new file mode 100644
index 0000000000..aabd8c088b
--- /dev/null
+++ b/crates/voice-media/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "zeron-voice-media"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+zeron-voice-session.workspace = true
+async-trait.workspace = true
+zeron-proto.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+serde_json.workspace = true
+sha2.workspace = true
+semver = "1"
+
+[dev-dependencies]
+tempfile.workspace = true
diff --git a/crates/voice-media/src/lib.rs b/crates/voice-media/src/lib.rs
new file mode 100644
index 0000000000..444ef053ef
--- /dev/null
+++ b/crates/voice-media/src/lib.rs
@@ -0,0 +1,570 @@
+//! Codex's packaged WebRTC helper protocol (Apache-2.0, OpenAI rust-v0.159.0).
+//! Audio, AEC, interruption and encrypted media stay inside that native process.
+//! Only bounded SDP signaling, controls and level meters cross this pipe.
+use serde_json::{Value, json};
+use std::{
+    path::{Path, PathBuf},
+    process::Stdio,
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    process::{ChildStdin, ChildStdout, Command},
+};
+use zeron_proto::voice::VoiceRejection;
+const MAX_FRAME: usize = 128 * 1024;
+
+pub struct NativeHost {
+    stop: tokio_util::sync::CancellationToken,
+    input: ChildStdin,
+    output: ChildStdout,
+}
+impl Drop for NativeHost {
+    fn drop(&mut self) {
+        self.stop.cancel();
+    }
+}
+impl NativeHost {
+    fn command(path: &Path) -> Command {
+        let mut cmd = Command::new(path);
+        // Fixed allowlist mirrors Codex. Never inherit API keys or dynamic loader/plugin overrides.
+        cmd.env_clear();
+        for (k, v) in std::env::vars_os() {
+            if matches!(
+                k.to_string_lossy().to_ascii_uppercase().as_str(),
+                "SYSTEMROOT"
+                    | "WINDIR"
+                    | "HOME"
+                    | "USERPROFILE"
+                    | "LOCALAPPDATA"
+                    | "APPDATA"
+                    | "TEMP"
+                    | "TMP"
+                    | "TMPDIR"
+                    | "XDG_RUNTIME_DIR"
+                    | "PULSE_SERVER"
+                    | "PULSE_COOKIE"
+                    | "PIPEWIRE_REMOTE"
+                    | "DBUS_SESSION_BUS_ADDRESS"
+                    | "HTTP_PROXY"
+                    | "HTTPS_PROXY"
+                    | "ALL_PROXY"
+                    | "NO_PROXY"
+                    | "SSL_CERT_FILE"
+                    | "SSL_CERT_DIR"
+                    | "REQUESTS_CA_BUNDLE"
+                    | "CURL_CA_BUNDLE"
+            ) {
+                cmd.env(k, v);
+            }
+        }
+        for k in [
+            "GST_PLUGIN_PATH",
+            "GST_PLUGIN_PATH_1_0",
+            "GST_PLUGIN_SYSTEM_PATH",
+            "GST_PLUGIN_SYSTEM_PATH_1_0",
+        ] {
+            cmd.env(k, "");
+        }
+        cmd.env(
+            "GST_REGISTRY",
+            if cfg!(windows) { "NUL" } else { "/dev/null" },
+        )
+        .env("GST_REGISTRY_UPDATE", "no")
+        .env("GST_REGISTRY_FORK", "no");
+        #[cfg(target_os = "linux")]
+        for directory in [
+            "/usr/lib/x86_64-linux-gnu/alsa-lib",
+            "/usr/lib/aarch64-linux-gnu/alsa-lib",
+            "/usr/lib64/alsa-lib",
+            "/usr/lib/alsa-lib",
+        ] {
+            if Path::new(directory).is_dir() {
+                cmd.env("ALSA_PLUGIN_DIR", directory);
+                break;
+            }
+        }
+        cmd.current_dir(path.parent().unwrap())
+            .stderr(Stdio::null())
+            .kill_on_drop(true);
+        cmd
+    }
+    pub async fn open(
+        path: &Path,
+        stop: tokio_util::sync::CancellationToken,
+    ) -> Result<Self, VoiceRejection> {
+        let result = tokio::time::timeout(
+            Duration::from_secs(5),
+            Self::command(path).arg("--build-commit").output(),
+        )
+        .await
+        .map_err(|_| VoiceRejection::NativeRuntimeUnavailable)?
+        .map_err(|_| VoiceRejection::NativeRuntimeUnavailable)?;
+        let commit = std::str::from_utf8(&result.stdout)
+            .ok()
+            .map(str::trim)
+            .filter(|s| !s.is_empty() && s.len() <= 128)
+            .filter(|_| result.status.success())
+            .ok_or(VoiceRejection::NativeRuntimeUnavailable)?;
+        let mut child = Self::command(path)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .map_err(|_| VoiceRejection::NativeRuntimeUnavailable)?;
+        let input = child.stdin.take().ok_or(VoiceRejection::Protocol)?;
+        let output = child.stdout.take().ok_or(VoiceRejection::Protocol)?;
+        let reaper_stop = stop.clone();
+        tokio::spawn(async move {
+            tokio::select! {biased;
+                _=reaper_stop.cancelled()=>{let _=child.start_kill();let _=child.wait().await;},
+                _=child.wait()=>{},
+            }
+        });
+        let mut host = Self {
+            stop: stop.clone(),
+            input,
+            output,
+        };
+        // A helper that cannot start its runtime (e.g. a library that no longer
+        // matches its runtime.json) exits here; that is the runtime, not the call.
+        let unavailable = |reason| match reason {
+            VoiceRejection::Protocol => VoiceRejection::NativeRuntimeUnavailable,
+            reason => reason,
+        };
+        host.expect(
+            json!({"type":"hello","protocol":1,"buildCommit":commit}),
+            "ready",
+            30,
+        )
+        .await
+        .map_err(unavailable)?;
+        host.expect(json!({"type":"initializeRuntime"}), "runtimeReady", 30)
+            .await
+            .map_err(unavailable)?;
+        Ok(host)
+    }
+    pub async fn exchange(
+        &mut self,
+        message: Value,
+        seconds: u64,
+    ) -> Result<Value, VoiceRejection> {
+        if self.stop.is_cancelled() {
+            return Err(VoiceRejection::Protocol);
+        }
+        struct ExchangeGuard(Option<tokio_util::sync::CancellationToken>);
+        impl Drop for ExchangeGuard {
+            fn drop(&mut self) {
+                if let Some(stop) = &self.0 {
+                    stop.cancel();
+                }
+            }
+        }
+        // A cancelled partial read invalidates the pipe, including when the
+        // caller drops this future without dropping the media endpoint yet.
+        let mut guard = ExchangeGuard(Some(self.stop.clone()));
+        let result = tokio::time::timeout(Duration::from_secs(seconds), async {
+            let payload = serde_json::to_vec(&message).map_err(|_| VoiceRejection::Protocol)?;
+            if payload.len() > MAX_FRAME {
+                return Err(VoiceRejection::Overflow);
+            }
+            self.input
+                .write_u32(payload.len() as u32)
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            self.input
+                .write_all(&payload)
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            self.input
+                .flush()
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            let length = self
+                .output
+                .read_u32()
+                .await
+                .map_err(|_| VoiceRejection::Protocol)? as usize;
+            if length == 0 || length > MAX_FRAME {
+                return Err(VoiceRejection::Overflow);
+            }
+            let mut payload = vec![0; length];
+            self.output
+                .read_exact(&mut payload)
+                .await
+                .map_err(|_| VoiceRejection::Protocol)?;
+            serde_json::from_slice(&payload).map_err(|_| VoiceRejection::Protocol)
+        })
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?;
+        if result.is_ok() {
+            guard.0 = None;
+        }
+        result
+    }
+    pub async fn expect(
+        &mut self,
+        message: Value,
+        expected: &str,
+        seconds: u64,
+    ) -> Result<(), VoiceRejection> {
+        if self.exchange(message, seconds).await?["type"] != expected {
+            self.stop.cancel();
+            return Err(VoiceRejection::Protocol);
+        }
+        Ok(())
+    }
+    pub async fn controls(&mut self, muted: bool) -> Result<(), VoiceRejection> {
+        self.expect(json!({"type":"setAudioControls","controls":{"microphoneMuted":muted,"speakerSuppressed":false}}),"audioControlsApplied",5).await
+    }
+    /// Synchronous local shutdown, independent of pending RPC or helper I/O.
+    pub fn close(&self) {
+        self.stop.cancel();
+    }
+    pub async fn levels(&mut self) -> Result<(u16, u16), VoiceRejection> {
+        let v = self.exchange(json!({"type":"inspectAudio"}), 5).await?;
+        if v["type"] != "audioState" {
+            return Err(VoiceRejection::Protocol);
+        }
+        let mic = v["state"]["microphonePeak"]
+            .as_u64()
+            .and_then(|n| u16::try_from(n).ok())
+            .ok_or(VoiceRejection::Protocol)?;
+        let speaker = v["state"]["speakerPeak"]
+            .as_u64()
+            .and_then(|n| u16::try_from(n).ok())
+            .ok_or(VoiceRejection::Protocol)?;
+        Ok((mic, speaker))
+    }
+}
+
+fn runtime_target() -> Result<&'static str, VoiceRejection> {
+    match (std::env::consts::OS, std::env::consts::ARCH) {
+        ("macos", "aarch64") => Ok("aarch64-apple-darwin"),
+        ("macos", "x86_64") => Ok("x86_64-apple-darwin"),
+        ("linux", "x86_64") => Ok("x86_64-unknown-linux-gnu"),
+        ("linux", "aarch64") => Ok("aarch64-unknown-linux-gnu"),
+        ("windows", "x86_64") => Ok("x86_64-pc-windows-msvc"),
+        ("windows", "aarch64") => Ok("aarch64-pc-windows-msvc"),
+        _ => Err(VoiceRejection::Unsupported),
+    }
+}
+
+const HELPER: &str = if cfg!(windows) {
+    "bin/codex-voice-host.exe"
+} else {
+    "bin/codex-voice-host"
+};
+
+/// The helper shipped inside the device's standalone Codex installation (layout
+/// 1, version 0.159 or later), resolved from its `codex` executable. Zeron never
+/// redistributes this runtime; npm installations do not contain it. The helper
+/// only initializes from a `codex-resources/voice` directory.
+pub fn installed_helper(codex_executable: &Path) -> Result<PathBuf, VoiceRejection> {
+    let binary = codex_executable
+        .canonicalize()
+        .map_err(|_| VoiceRejection::NativeRuntimeUnavailable)?;
+    let root = binary
+        .parent()
+        .and_then(Path::parent)
+        .ok_or(VoiceRejection::NativeRuntimeUnavailable)?;
+    let manifest: Value = std::fs::read(root.join("codex-package.json"))
+        .ok()
+        .and_then(|b| serde_json::from_slice(&b).ok())
+        .ok_or(VoiceRejection::NativeRuntimeUnavailable)?;
+    let version = manifest["version"]
+        .as_str()
+        .and_then(|v| semver::Version::parse(v).ok())
+        .ok_or(VoiceRejection::Unsupported)?;
+    if manifest["layoutVersion"] != 1 || version < semver::Version::new(0, 159, 0) {
+        return Err(VoiceRejection::Unsupported);
+    }
+    let path = root.join("codex-resources/voice").join(HELPER);
+    if path.canonicalize().ok().as_ref() != Some(&path) || !path.is_file() {
+        return Err(VoiceRejection::NativeRuntimeUnavailable);
+    }
+    Ok(path)
+}
+
+/// Client media for a remote call: an explicit development runtime
+/// (`ZERON_VOICE_MEDIA_DIR`, see `scripts/package-voice-runtime.py`), otherwise
+/// this device's standalone Codex installation. Never reads Codex credentials.
+pub fn media_helper(codex_executable: Option<&Path>) -> Result<PathBuf, VoiceRejection> {
+    if let Some(path) = std::env::var_os("ZERON_VOICE_MEDIA_DIR") {
+        return verify_runtime(Path::new(&path));
+    }
+    installed_helper(codex_executable.ok_or(VoiceRejection::NativeRuntimeUnavailable)?)
+}
+
+pub const BUILD_COMMIT: &str = "a956835d020762cb2b570053af06f643a11c0ecc";
+
+pub fn verify_runtime(root: &Path) -> Result<std::path::PathBuf, VoiceRejection> {
+    use sha2::{Digest, Sha256};
+    let reject = || VoiceRejection::NativeRuntimeUnavailable;
+    // Fail here, clearly, rather than when the helper refuses to start.
+    if root.file_name() != Some("voice".as_ref())
+        || root.parent().and_then(Path::file_name) != Some("codex-resources".as_ref())
+    {
+        return Err(reject());
+    }
+    let manifest: Value = serde_json::from_slice(
+        &std::fs::read(root.join("zeron-runtime.json")).map_err(|_| reject())?,
+    )
+    .map_err(|_| reject())?;
+    if manifest["buildCommit"] != BUILD_COMMIT
+        || manifest["protocol"] != 1
+        || manifest["target"] != runtime_target()?
+    {
+        return Err(VoiceRejection::Unsupported);
+    }
+    let files = manifest["sha256"].as_object().ok_or_else(reject)?;
+    if !files.contains_key(HELPER)
+        || !files.contains_key("runtime.json")
+        || !files.contains_key("NOTICE.md")
+    {
+        return Err(reject());
+    }
+    for (name, digest) in files {
+        let path = Path::new(name);
+        if path
+            .components()
+            .any(|c| !matches!(c, std::path::Component::Normal(_)))
+        {
+            return Err(reject());
+        }
+        let bytes = std::fs::read(root.join(path)).map_err(|_| reject())?;
+        if digest.as_str() != Some(format!("{:x}", Sha256::digest(&bytes)).as_str()) {
+            return Err(reject());
+        }
+    }
+    Ok(root.join(HELPER))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use sha2::{Digest, Sha256};
+
+    fn codex_package(root: &Path, version: &str, helper: bool) -> PathBuf {
+        let codex = root.join(if cfg!(windows) {
+            "bin/codex.exe"
+        } else {
+            "bin/codex"
+        });
+        std::fs::create_dir_all(codex.parent().unwrap()).unwrap();
+        std::fs::write(&codex, "").unwrap();
+        std::fs::write(
+            root.join("codex-package.json"),
+            json!({"layoutVersion":1,"version":version}).to_string(),
+        )
+        .unwrap();
+        if helper {
+            let path = root.join("codex-resources/voice").join(HELPER);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(path, "").unwrap();
+        }
+        codex
+    }
+
+    #[test]
+    fn helper_is_resolved_from_the_installed_codex_package() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().canonicalize().unwrap().join("release");
+        let codex = codex_package(&root, "0.160.0", true);
+        assert_eq!(
+            installed_helper(&codex).unwrap(),
+            root.join("codex-resources/voice").join(HELPER)
+        );
+        // Older layouts and npm-style installs without resources are unavailable.
+        codex_package(&root, "0.158.9", true);
+        assert_eq!(
+            installed_helper(&codex).unwrap_err(),
+            VoiceRejection::Unsupported
+        );
+        let npm = temp.path().join("npm");
+        let codex = codex_package(&npm, "0.160.0", false);
+        assert_eq!(
+            installed_helper(&codex).unwrap_err(),
+            VoiceRejection::NativeRuntimeUnavailable
+        );
+        std::fs::remove_file(npm.join("codex-package.json")).unwrap();
+        assert_eq!(
+            installed_helper(&codex).unwrap_err(),
+            VoiceRejection::NativeRuntimeUnavailable
+        );
+    }
+
+    /// An opt-in runtime check: no provider connection or audio devices.
+    #[tokio::test]
+    #[ignore = "requires a projected runtime in ZERON_VOICE_MEDIA_DIR"]
+    async fn packaged_native_runtime_initializes_without_audio_devices() {
+        let path = media_helper(None).unwrap();
+        let host = NativeHost::open(&path, Default::default()).await.unwrap();
+        host.close();
+    }
+
+    #[test]
+    fn runtime_rejects_missing_tampered_misplaced_and_incompatible_resources() {
+        let temp = tempfile::tempdir().unwrap();
+        let dir = temp.path().join("Resources/codex-resources/voice");
+        std::fs::create_dir_all(&dir).unwrap();
+        assert!(verify_runtime(&dir).is_err());
+        let mut hashes = serde_json::Map::new();
+        for name in [HELPER, "runtime.json", "NOTICE.md"] {
+            let path = dir.join(name);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(&path, name).unwrap();
+            hashes.insert(
+                name.into(),
+                json!(format!("{:x}", Sha256::digest(name.as_bytes()))),
+            );
+        }
+        let mut manifest = json!({"protocol":1,"buildCommit":BUILD_COMMIT,"target":runtime_target().unwrap(),"sha256":hashes});
+        let save = |m: &Value| {
+            std::fs::write(
+                dir.join("zeron-runtime.json"),
+                serde_json::to_vec(m).unwrap(),
+            )
+            .unwrap()
+        };
+        save(&manifest);
+        assert_eq!(verify_runtime(&dir).unwrap(), dir.join(HELPER));
+        // The helper refuses to start outside `codex-resources/voice`.
+        let elsewhere = temp.path().join("Resources/voice");
+        std::fs::rename(temp.path().join("Resources/codex-resources"), &elsewhere).unwrap();
+        assert!(verify_runtime(&elsewhere.join("voice")).is_err());
+        std::fs::rename(&elsewhere, temp.path().join("Resources/codex-resources")).unwrap();
+        std::fs::write(dir.join("runtime.json"), "tampered").unwrap();
+        assert!(verify_runtime(&dir).is_err());
+        std::fs::write(dir.join("runtime.json"), "runtime.json").unwrap();
+        manifest["protocol"] = json!(2);
+        save(&manifest);
+        assert_eq!(
+            verify_runtime(&dir).unwrap_err(),
+            VoiceRejection::Unsupported
+        );
+        manifest["protocol"] = json!(1);
+        manifest["target"] = json!("incompatible-platform");
+        save(&manifest);
+        assert_eq!(
+            verify_runtime(&dir).unwrap_err(),
+            VoiceRejection::Unsupported
+        );
+        manifest["target"] = json!(runtime_target().unwrap());
+        manifest["sha256"].as_object_mut().unwrap().remove(HELPER);
+        save(&manifest);
+        assert!(verify_runtime(&dir).is_err());
+        manifest["sha256"][HELPER] = json!(format!("{:x}", Sha256::digest(HELPER.as_bytes())));
+        manifest["sha256"]["../escape"] = json!("digest");
+        save(&manifest);
+        assert!(verify_runtime(&dir).is_err());
+    }
+
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn helper_that_cannot_start_its_runtime_is_a_runtime_failure() {
+        use std::os::unix::fs::PermissionsExt;
+        let dir = tempfile::tempdir().unwrap();
+        let helper = dir.path().join("codex-voice-host");
+        // Answers hello, then exits on initializeRuntime like a helper whose
+        // libraries no longer match its runtime.json (exit 23).
+        std::fs::write(
+            &helper,
+            "#!/usr/bin/env python3\nimport json,struct,sys\n\
+             if sys.argv[1:]==['--build-commit']: print('commit'); sys.exit(0)\n\
+             n=struct.unpack('>I',sys.stdin.buffer.read(4))[0]; sys.stdin.buffer.read(n)\n\
+             b=json.dumps({'type':'ready'}).encode()\n\
+             sys.stdout.buffer.write(struct.pack('>I',len(b))+b); sys.stdout.flush()\n\
+             sys.stdin.buffer.read(4); sys.exit(23)\n",
+        )
+        .unwrap();
+        std::fs::set_permissions(&helper, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let result = NativeHost::open(&helper, Default::default()).await;
+        assert_eq!(result.err(), Some(VoiceRejection::NativeRuntimeUnavailable));
+    }
+}
+
+/// Desktop implementation shared by UIs; permission belongs to the viewport.
+/// Instantiate one per call. Closing cannot wait behind a locked helper pipe.
+pub struct DesktopMedia {
+    path: std::path::PathBuf,
+    host: tokio::sync::Mutex<Option<NativeHost>>,
+    stop: tokio_util::sync::CancellationToken,
+}
+impl DesktopMedia {
+    /// See [`media_helper`]: the local standalone Codex unless a development
+    /// runtime is set explicitly.
+    pub fn for_codex(codex_executable: Option<&Path>) -> Result<Self, VoiceRejection> {
+        Ok(Self {
+            path: media_helper(codex_executable)?,
+            host: Default::default(),
+            stop: Default::default(),
+        })
+    }
+}
+#[async_trait::async_trait]
+impl zeron_voice_session::VoiceMediaEndpoint for DesktopMedia {
+    async fn prepare(&self) -> Result<(), VoiceRejection> {
+        let host = NativeHost::open(&self.path, self.stop.clone()).await?;
+        if self.stop.is_cancelled() {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        *self.host.lock().await = Some(host);
+        Ok(())
+    }
+    async fn offer(&self) -> Result<zeron_proto::voice::remote::Sdp, VoiceRejection> {
+        let mut state = self.host.lock().await;
+        let host = state.as_mut().ok_or(VoiceRejection::InvalidLease)?;
+        let offer = host.exchange(json!({"type":"startTransport"}), 20).await?;
+        if offer["type"] != "offer" {
+            return Err(VoiceRejection::Protocol);
+        }
+        zeron_proto::voice::remote::Sdp::new(
+            offer["sdp"]
+                .as_str()
+                .ok_or(VoiceRejection::Protocol)?
+                .into(),
+        )
+    }
+    async fn apply_answer(
+        &self,
+        answer: zeron_proto::voice::remote::Sdp,
+    ) -> Result<(), VoiceRejection> {
+        let mut state = self.host.lock().await;
+        let host = state.as_mut().ok_or(VoiceRejection::InvalidLease)?;
+        host.expect(
+            json!({"type":"applyAnswer","sdp":answer.expose()}),
+            "transportReady",
+            20,
+        )
+        .await?;
+        host.expect(json!({"type":"openDevices"}), "devicesOpened", 5)
+            .await?;
+        host.expect(json!({"type":"setAudioControls","controls":{"microphoneMuted":true,"speakerSuppressed":true}}),"audioControlsApplied",5).await
+    }
+    async fn set_muted(&self, muted: bool) -> Result<(), VoiceRejection> {
+        self.host
+            .lock()
+            .await
+            .as_mut()
+            .ok_or(VoiceRejection::InvalidLease)?
+            .controls(muted)
+            .await
+    }
+    async fn levels(&self) -> Result<(u16, u16), VoiceRejection> {
+        self.host
+            .lock()
+            .await
+            .as_mut()
+            .ok_or(VoiceRejection::InvalidLease)?
+            .levels()
+            .await
+    }
+    fn close(&self) {
+        self.stop.cancel();
+    }
+}
+impl Drop for DesktopMedia {
+    fn drop(&mut self) {
+        self.stop.cancel();
+    }
+}
diff --git a/crates/voice-session/Cargo.toml b/crates/voice-session/Cargo.toml
new file mode 100644
index 0000000000..f7b712078e
--- /dev/null
+++ b/crates/voice-session/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "zeron-voice-session"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+zeron-proto.workspace = true
+zeron-orb.workspace = true
+zeron-rpc.workspace = true
+async-trait.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+futures.workspace = true
+tracing.workspace = true
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["test-util"] }
diff --git a/crates/voice-session/src/lib.rs b/crates/voice-session/src/lib.rs
new file mode 100644
index 0000000000..5ebe6b3807
--- /dev/null
+++ b/crates/voice-session/src/lib.rs
@@ -0,0 +1,638 @@
+//! Shared call lifecycle. Platforms own media; the execution host owns Codex.
+mod view;
+use async_trait::async_trait;
+use futures::{StreamExt, stream::BoxStream};
+use serde_json::{Value, json};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+use tokio::sync::{mpsc, watch};
+use tokio_util::sync::CancellationToken;
+pub use view::{Caption, SpeakerActivity, VoiceView, orb_state};
+use zeron_proto::voice::{remote as wire, *};
+use zeron_rpc::{RpcClient, methods};
+
+#[async_trait]
+pub trait VoiceMediaEndpoint: Send + Sync {
+    /// Platform permission and media runtime only; capture stays muted.
+    async fn prepare(&self) -> Result<(), VoiceRejection>;
+    async fn offer(&self) -> Result<wire::Sdp, VoiceRejection>;
+    /// Return only when the local transport is ready. Devices remain muted.
+    async fn apply_answer(&self, answer: wire::Sdp) -> Result<(), VoiceRejection>;
+    async fn set_muted(&self, muted: bool) -> Result<(), VoiceRejection>;
+    async fn levels(&self) -> Result<(u16, u16), VoiceRejection>;
+    /// Must stop local capture without awaiting any RPC or pending media call.
+    fn close(&self);
+}
+#[async_trait]
+pub trait VoiceControlTransport: Send + Sync {
+    async fn call(
+        &self,
+        method: &str,
+        payload: Value,
+        seconds: u64,
+    ) -> Result<Value, VoiceRejection>;
+    async fn own(
+        &self,
+        lease: &wire::Lease,
+    ) -> Result<BoxStream<'static, Result<VoiceEvent, VoiceRejection>>, VoiceRejection>;
+}
+/// Uses ephemeral RPC only. No offline ledger, nudge or implicit side-effect retry.
+pub struct RpcTransport {
+    pub client: Arc<RpcClient>,
+    pub host: String,
+}
+#[async_trait]
+impl VoiceControlTransport for RpcTransport {
+    async fn call(
+        &self,
+        method: &str,
+        payload: Value,
+        seconds: u64,
+    ) -> Result<Value, VoiceRejection> {
+        tokio::time::timeout(
+            Duration::from_secs(seconds),
+            self.client.call(
+                method,
+                json!({"targetDeviceId":self.host,"payload":payload}),
+            ),
+        )
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+        .map_err(rejection)
+    }
+    async fn own(
+        &self,
+        lease: &wire::Lease,
+    ) -> Result<BoxStream<'static, Result<VoiceEvent, VoiceRejection>>, VoiceRejection> {
+        let rx = tokio::time::timeout(
+            Duration::from_secs(8),
+            self.client.subscribe_checked(
+                methods::OWN_VOICE_V2,
+                json!({"targetDeviceId":self.host,"payload":lease}),
+            ),
+        )
+        .await
+        .map_err(|_| VoiceRejection::Protocol)?
+        .map_err(rejection)?;
+        let client = self.client.clone();
+        Ok(
+            futures::stream::unfold((rx, client), |(mut rx, client)| async move {
+                rx.recv().await.map(|v| {
+                    (
+                        serde_json::from_value(v).map_err(|_| VoiceRejection::Protocol),
+                        (rx, client),
+                    )
+                })
+            })
+            .boxed(),
+        )
+    }
+}
+pub fn rejection(error: zeron_rpc::RpcError) -> VoiceRejection {
+    let message = error.to_string();
+    for reason in [
+        VoiceRejection::Disabled,
+        VoiceRejection::NativeRuntimeUnavailable,
+        VoiceRejection::ChatgptRequired,
+        VoiceRejection::Busy,
+        VoiceRejection::InvalidLease,
+        VoiceRejection::RemoteHost,
+        VoiceRejection::WrongHarness,
+        VoiceRejection::Unsupported,
+        VoiceRejection::Overflow,
+    ] {
+        if message.contains(&format!("{reason:?}")) {
+            return reason;
+        }
+    }
+    if matches!(error, zeron_rpc::RpcError::UnknownMethod(_)) {
+        VoiceRejection::Unsupported
+    } else {
+        VoiceRejection::Protocol
+    }
+}
+async fn call<T: serde::de::DeserializeOwned>(
+    control: &dyn VoiceControlTransport,
+    method: &str,
+    payload: impl serde::Serialize,
+    seconds: u64,
+) -> Result<T, VoiceRejection> {
+    serde_json::from_value(
+        control
+            .call(
+                method,
+                serde_json::to_value(payload).map_err(|_| VoiceRejection::Protocol)?,
+                seconds,
+            )
+            .await?,
+    )
+    .map_err(|_| VoiceRejection::Protocol)
+}
+struct Scope {
+    media: Arc<dyn VoiceMediaEndpoint>,
+    control: Arc<dyn VoiceControlTransport>,
+    key: wire::AttemptKey,
+    lease: Arc<Mutex<Option<wire::Lease>>>,
+    tasks: Vec<tokio::task::JoinHandle<()>>,
+    cancel: CancellationToken,
+}
+impl Drop for Scope {
+    fn drop(&mut self) {
+        self.media.close();
+        self.cancel.cancel();
+        for task in &self.tasks {
+            task.abort();
+        }
+        let control = self.control.clone();
+        let key = self.key.clone();
+        let lease = self.lease.lock().unwrap().clone();
+        if let Ok(runtime) = tokio::runtime::Handle::try_current() {
+            runtime.spawn(async move {
+                if let Some(lease) = lease {
+                    let _ = control.call(methods::STOP_VOICE_V2, json!(lease), 8).await;
+                }
+                let _ = control
+                    .call(
+                        methods::CANCEL_VOICE_ATTEMPT_V2,
+                        json!(wire::Cancel { attempt_key: key }),
+                        8,
+                    )
+                    .await;
+            });
+        }
+    }
+}
+
+/// Runs once. Reconnection requires a new explicit call and fresh attempt key.
+pub async fn run(
+    control: Arc<dyn VoiceControlTransport>,
+    media: Arc<dyn VoiceMediaEndpoint>,
+    config: zeron_proto::ChatConfig,
+    voice: Option<String>,
+    cancel: CancellationToken,
+    events: mpsc::Sender<VoiceEvent>,
+    muted: watch::Receiver<bool>,
+) -> Result<(), VoiceRejection> {
+    let started = tokio::time::Instant::now();
+    let local_cancel = cancel.child_token();
+    let failure = Arc::new(Mutex::new(None));
+    let mut scope = Scope {
+        media: media.clone(),
+        control: control.clone(),
+        key: wire::AttemptKey::new(),
+        lease: Arc::default(),
+        tasks: vec![],
+        cancel: local_cancel.clone(),
+    };
+    let operation = async {
+        tracing::info!(
+            stage = "capabilities",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        let cap: wire::Capabilities = call(
+            control.as_ref(),
+            methods::VOICE_CAPABILITIES_V2,
+            json!({}),
+            8,
+        )
+        .await?;
+        if !cap.client_webrtc || cap.protocol != wire::CAPABILITY {
+            return Err(VoiceRejection::Unsupported);
+        }
+        tracing::info!(
+            stage = "local_media",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        media.prepare().await?;
+        tracing::info!(
+            stage = "prepare_host",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        let prepared: wire::Prepared = call(
+            control.as_ref(),
+            methods::PREPARE_VOICE_V2,
+            wire::Prepare {
+                attempt_key: scope.key.clone(),
+                config,
+                voice,
+            },
+            65,
+        )
+        .await?;
+        *scope.lease.lock().unwrap() = Some(prepared.lease.clone());
+        tracing::info!(
+            stage = "attach_owner",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        let mut owner = control.own(&prepared.lease).await?;
+        let lease = prepared.lease.clone();
+        let owner_cancel = local_cancel.clone();
+        let owner_events = events.clone();
+        let owner_failure = failure.clone();
+        let owner_media = media.clone();
+        let owner_mute = muted.clone();
+        scope.tasks.push(tokio::spawn(async move {
+            let result = async {
+                while let Some(event) = owner.next().await {
+                    let mut event = event?;
+                    if let VoiceEvent::Snapshot { snapshot } = &mut event {
+                        snapshot.muted = *owner_mute.borrow();
+                    }
+                    let current = match &event {
+                        VoiceEvent::Snapshot { snapshot } => {
+                            snapshot.generation == lease.voice.generation
+                                && snapshot.session_id == lease.voice.session_id
+                        }
+                        VoiceEvent::Final { transcript } => {
+                            transcript.session_id == lease.voice.session_id
+                        }
+                        VoiceEvent::Partial { generation, .. }
+                        | VoiceEvent::Closed { generation, .. }
+                        | VoiceEvent::InvalidatePlayout { generation, .. } => {
+                            *generation == lease.voice.generation
+                        }
+                        _ => return Err(VoiceRejection::Protocol),
+                    };
+                    if !current {
+                        continue;
+                    }
+                    let closed = if let VoiceEvent::Closed { reason, .. } = &event {
+                        Some(*reason)
+                    } else {
+                        None
+                    };
+                    owner_events
+                        .try_send(event)
+                        .map_err(|_| VoiceRejection::Overflow)?;
+                    if let Some(reason) = closed {
+                        return reason.map_or(Ok(()), Err);
+                    }
+                }
+                Err(VoiceRejection::Protocol)
+            }
+            .await;
+            *owner_failure.lock().unwrap() = result.err();
+            owner_media.close();
+            owner_cancel.cancel();
+        }));
+        let heartbeat_control = control.clone();
+        let lease = prepared.lease.clone();
+        let heartbeat_cancel = local_cancel.clone();
+        let heartbeat_failure = failure.clone();
+        let heartbeat_media = media.clone();
+        let heartbeat_mute = muted.clone();
+        scope.tasks.push(tokio::spawn(async move {
+            let mut sequence = 0;
+            let mut interval = tokio::time::interval(Duration::from_secs(wire::HEARTBEAT_SECS));
+            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+            loop {
+                interval.tick().await;
+                sequence += 1;
+                let muted_now = *heartbeat_mute.borrow();
+                let result: Result<wire::Ack, _> = call(
+                    heartbeat_control.as_ref(),
+                    methods::REPORT_VOICE_MEDIA_V2,
+                    wire::Report {
+                        lease: lease.clone(),
+                        sequence,
+                        muted: muted_now,
+                        state: wire::MediaState::Ready,
+                    },
+                    10,
+                )
+                .await;
+                if !matches!(result,Ok(wire::Ack{sequence:s}) if s==sequence) {
+                    *heartbeat_failure.lock().unwrap() = Some(VoiceRejection::Protocol);
+                    heartbeat_media.close();
+                    heartbeat_cancel.cancel();
+                    return;
+                }
+            }
+        }));
+        tracing::info!(
+            stage = "local_offer",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        let offer = media.offer().await?;
+        let negotiation_id = wire::AttemptKey::new();
+        tracing::info!(
+            stage = "negotiate",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        let answer: wire::Negotiated = call(
+            control.as_ref(),
+            methods::NEGOTIATE_VOICE_V2,
+            wire::Negotiate {
+                lease: prepared.lease.clone(),
+                negotiation_id: negotiation_id.clone(),
+                offer,
+            },
+            95,
+        )
+        .await?;
+        if answer.negotiation_id != negotiation_id {
+            return Err(VoiceRejection::Protocol);
+        }
+        tracing::info!(
+            stage = "apply_answer",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        media.apply_answer(answer.answer).await?;
+        let initial_muted = *muted.borrow();
+        tracing::info!(
+            stage = "confirm",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        let snapshot: VoiceSnapshot = call(
+            control.as_ref(),
+            methods::CONFIRM_VOICE_MEDIA_V2,
+            wire::Confirm {
+                lease: prepared.lease.clone(),
+                negotiation_id,
+                muted: initial_muted,
+            },
+            8,
+        )
+        .await?;
+        if snapshot.session_id != prepared.lease.voice.session_id
+            || snapshot.generation != prepared.lease.voice.generation
+        {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        if local_cancel.is_cancelled() {
+            return Err(VoiceRejection::InvalidLease);
+        }
+        let muted_now = *muted.borrow();
+        tracing::info!(
+            stage = "active",
+            elapsed_ms = started.elapsed().as_millis() as u64,
+            "remote voice stage"
+        );
+        media.set_muted(muted_now).await?;
+        let mut muted = muted;
+        let mut tick = tokio::time::interval(Duration::from_millis(100));
+        tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        loop {
+            tokio::select! {biased;
+                changed=muted.changed()=>{changed.map_err(|_|VoiceRejection::Protocol)?;let value=*muted.borrow_and_update();media.set_muted(value).await?;},
+                _=tick.tick()=>{
+                    let (microphone,speaker)=media.levels().await?;
+                    // Visual samples are lossy and leave headroom: a slow consumer
+                    // must drop meters, never overflow on owner finals/controls.
+                    if events.capacity()>events.max_capacity()/4{
+                        let _=events.try_send(VoiceEvent::Levels{generation:prepared.lease.voice.generation,microphone,speaker});
+                    }
+                },
+                _=events.closed()=>return Ok(()),
+            }
+        }
+    };
+    let result = tokio::select! {biased;
+        _=local_cancel.cancelled()=>failure.lock().unwrap().map_or(Ok(()),Err),
+        result=operation=>result,
+    };
+    drop(scope);
+    tracing::info!(elapsed_ms = started.elapsed().as_millis() as u64, reason = ?result.as_ref().err(), "remote voice closed");
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    struct Media {
+        prepared: AtomicBool,
+        closed: AtomicBool,
+        block: bool,
+    }
+    #[async_trait]
+    impl VoiceMediaEndpoint for Media {
+        async fn prepare(&self) -> Result<(), VoiceRejection> {
+            self.prepared.store(true, Ordering::SeqCst);
+            Ok(())
+        }
+        async fn offer(&self) -> Result<wire::Sdp, VoiceRejection> {
+            if self.block {
+                futures::future::pending::<()>().await;
+            }
+            wire::Sdp::new("offer".into())
+        }
+        async fn apply_answer(&self, _: wire::Sdp) -> Result<(), VoiceRejection> {
+            Ok(())
+        }
+        async fn set_muted(&self, _: bool) -> Result<(), VoiceRejection> {
+            assert!(!self.closed.load(Ordering::SeqCst));
+            Ok(())
+        }
+        async fn levels(&self) -> Result<(u16, u16), VoiceRejection> {
+            Ok((100, 200))
+        }
+        fn close(&self) {
+            self.closed.store(true, Ordering::SeqCst);
+        }
+    }
+    struct Control {
+        supported: bool,
+        half_open: bool,
+        calls: Mutex<Vec<String>>,
+        lease: wire::Lease,
+    }
+    #[async_trait]
+    impl VoiceControlTransport for Control {
+        async fn call(&self, method: &str, p: Value, _: u64) -> Result<Value, VoiceRejection> {
+            self.calls.lock().unwrap().push(method.into());
+            if self.half_open && method == methods::REPORT_VOICE_MEDIA_V2 {
+                tokio::time::sleep(Duration::from_secs(10)).await;
+                return Err(VoiceRejection::Protocol);
+            }
+            Ok(match method {
+                methods::VOICE_CAPABILITIES_V2 => json!(wire::Capabilities {
+                    protocol: wire::CAPABILITY.into(),
+                    client_webrtc: self.supported,
+                    voices: vec![]
+                }),
+                methods::PREPARE_VOICE_V2 => json!(wire::Prepared {
+                    lease: self.lease.clone(),
+                    chat_id: "voice-orchestrator-full-id".into(),
+                    voices: vec![],
+                    heartbeat_seconds: 5,
+                    lease_seconds: 15
+                }),
+                methods::NEGOTIATE_VOICE_V2 => json!(wire::Negotiated {
+                    negotiation_id: serde_json::from_value(p["negotiationId"].clone()).unwrap(),
+                    answer: wire::Sdp::new("answer".into()).unwrap()
+                }),
+                methods::REPORT_VOICE_MEDIA_V2 => json!({"sequence":p["sequence"]}),
+                methods::CONFIRM_VOICE_MEDIA_V2 => json!(VoiceSnapshot {
+                    session_id: self.lease.voice.session_id.clone(),
+                    chat_id: "voice-orchestrator-full-id".into(),
+                    generation: 1,
+                    phase: VoicePhase::Active,
+                    muted: false,
+                    playing: false,
+                    work: VoiceWork::Idle,
+                    reason: None,
+                    voice: None,
+                    voices: vec![]
+                }),
+                _ => json!({}),
+            })
+        }
+        async fn own(
+            &self,
+            _: &wire::Lease,
+        ) -> Result<BoxStream<'static, Result<VoiceEvent, VoiceRejection>>, VoiceRejection>
+        {
+            Ok(futures::stream::pending().boxed())
+        }
+    }
+    fn control(supported: bool) -> Arc<Control> {
+        Arc::new(Control {
+            supported,
+            half_open: false,
+            calls: Default::default(),
+            lease: wire::Lease {
+                host_device_id: "host".into(),
+                voice: VoiceLease {
+                    session_id: "session".into(),
+                    generation: 1,
+                    token: "secret".into(),
+                },
+            },
+        })
+    }
+    fn config() -> zeron_proto::ChatConfig {
+        serde_json::from_value(json!({"harness":"codex","sandbox":"danger-full-access"})).unwrap()
+    }
+    #[tokio::test]
+    async fn incompatible_host_never_requests_microphone() {
+        let media = Arc::new(Media {
+            prepared: AtomicBool::new(false),
+            closed: AtomicBool::new(false),
+            block: false,
+        });
+        let (tx, _rx) = mpsc::channel(8);
+        let (_mute, muted) = watch::channel(false);
+        assert_eq!(
+            run(
+                control(false),
+                media.clone(),
+                config(),
+                None,
+                CancellationToken::new(),
+                tx,
+                muted
+            )
+            .await
+            .unwrap_err(),
+            VoiceRejection::Unsupported
+        );
+        assert!(!media.prepared.load(Ordering::SeqCst));
+        assert!(media.closed.load(Ordering::SeqCst));
+    }
+    #[tokio::test]
+    async fn cancelling_a_stalled_offer_closes_media_before_remote_cleanup() {
+        let media = Arc::new(Media {
+            prepared: AtomicBool::new(false),
+            closed: AtomicBool::new(false),
+            block: true,
+        });
+        let control = control(true);
+        let (tx, _rx) = mpsc::channel(8);
+        let (_mute, muted) = watch::channel(false);
+        let cancel = CancellationToken::new();
+        let task = tokio::spawn(run(
+            control.clone(),
+            media.clone(),
+            config(),
+            None,
+            cancel.clone(),
+            tx,
+            muted,
+        ));
+        for _ in 0..100 {
+            if media.prepared.load(Ordering::SeqCst) {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        cancel.cancel();
+        task.await.unwrap().unwrap();
+        assert!(media.closed.load(Ordering::SeqCst));
+        tokio::task::yield_now().await;
+        assert!(
+            control
+                .calls
+                .lock()
+                .unwrap()
+                .iter()
+                .any(|m| m == methods::CANCEL_VOICE_ATTEMPT_V2)
+        );
+    }
+    #[tokio::test]
+    async fn active_call_uses_local_levels_and_drop_closes_media() {
+        let media = Arc::new(Media {
+            prepared: AtomicBool::new(false),
+            closed: AtomicBool::new(false),
+            block: false,
+        });
+        let (tx, mut rx) = mpsc::channel(8);
+        let (_mute, muted) = watch::channel(false);
+        let task = tokio::spawn(run(
+            control(true),
+            media.clone(),
+            config(),
+            None,
+            CancellationToken::new(),
+            tx,
+            muted,
+        ));
+        assert!(matches!(
+            tokio::time::timeout(Duration::from_secs(1), rx.recv())
+                .await
+                .unwrap(),
+            Some(VoiceEvent::Levels {
+                microphone: 100,
+                speaker: 200,
+                ..
+            })
+        ));
+        task.abort();
+        let _ = task.await;
+        assert!(media.closed.load(Ordering::SeqCst));
+    }
+    #[tokio::test(start_paused = true)]
+    async fn half_open_heartbeat_closes_stalled_media_without_user_action() {
+        let media = Arc::new(Media {
+            prepared: AtomicBool::new(false),
+            closed: AtomicBool::new(false),
+            block: true,
+        });
+        let mut control = control(true);
+        Arc::get_mut(&mut control).unwrap().half_open = true;
+        let (tx, _rx) = mpsc::channel(8);
+        let (_mute, muted) = watch::channel(false);
+        let started = tokio::time::Instant::now();
+        let result = run(
+            control,
+            media.clone(),
+            config(),
+            None,
+            CancellationToken::new(),
+            tx,
+            muted,
+        )
+        .await;
+        assert_eq!(result.unwrap_err(), VoiceRejection::Protocol);
+        assert!(media.closed.load(Ordering::SeqCst));
+        assert!(started.elapsed() <= Duration::from_secs(wire::LEASE_SECS));
+    }
+}
diff --git a/crates/voice-session/src/view.rs b/crates/voice-session/src/view.rs
new file mode 100644
index 0000000000..bdc2daea55
--- /dev/null
+++ b/crates/voice-session/src/view.rs
@@ -0,0 +1,541 @@
+//! What a client-media call shows: phase, live caption, levels and the orb's
+//! state, reduced from the owner stream. Renderer-agnostic so every platform
+//! presents the orchestrator the same way.
+use std::time::{Duration, Instant};
+use zeron_orb::OrbState;
+use zeron_proto::voice::*;
+
+/// The orb for a voice phase and host snapshot. Speaking wins over work and
+/// mute, so a muted user still sees the assistant answer.
+pub fn orb_state(phase: VoicePhase, snapshot: Option<&VoiceSnapshot>) -> OrbState {
+    if matches!(
+        phase,
+        VoicePhase::Checking | VoicePhase::Starting | VoicePhase::Stopping
+    ) {
+        return OrbState::Connecting;
+    }
+    match snapshot {
+        Some(s) if s.playing => OrbState::Composing,
+        Some(s) if s.work == VoiceWork::AwaitingInput => OrbState::Solving,
+        Some(s) if s.work == VoiceWork::Working => OrbState::Working,
+        Some(s) if s.muted => OrbState::Breathing,
+        Some(_) => OrbState::Listening,
+        None => OrbState::Breathing,
+    }
+}
+
+/// Visual speaker activity from playout peaks: hysteresis and a short hold
+/// bridge syllable gaps. Client media has no host-side meter, so the client
+/// derives `playing` itself.
+#[derive(Default)]
+pub struct SpeakerActivity {
+    playing: bool,
+    last_loud: Option<Instant>,
+}
+impl SpeakerActivity {
+    pub fn update(&mut self, peak: u16, now: Instant) -> bool {
+        const ENTER: u16 = 655;
+        const EXIT: u16 = 328;
+        const HOLD: Duration = Duration::from_millis(250);
+        if peak >= if self.playing { EXIT } else { ENTER } {
+            self.playing = true;
+            self.last_loud = Some(now);
+        } else if self
+            .last_loud
+            .is_none_or(|last| now.saturating_duration_since(last) >= HOLD)
+        {
+            self.playing = false;
+        }
+        self.playing
+    }
+}
+
+/// Speaker turns the caption remembers; older ones can no longer complete.
+const CAPTION_TURNS: usize = 8;
+
+/// The live caption across speaker turns. Codex interleaves them: a user
+/// turn's final often lands after the assistant has started answering. Each
+/// turn keeps its own text and the caption stays on the newest one, so a late
+/// final never takes the caption back and deltas never restart it.
+#[derive(Default)]
+pub struct Caption {
+    /// Oldest first; the last turn is the one shown.
+    turns: Vec<CaptionTurn>,
+}
+
+struct CaptionTurn {
+    item: Option<String>,
+    text: String,
+    /// Known once the turn's final arrives.
+    role: Option<VoiceRole>,
+}
+
+impl Caption {
+    pub fn text(&self) -> &str {
+        self.turns.last().map_or("", |t| t.text.as_str())
+    }
+
+    /// The shown turn's item: a change is a new speaker turn.
+    pub fn item(&self) -> Option<&str> {
+        self.turns.last().and_then(|t| t.item.as_deref())
+    }
+
+    /// The shown turn's speaker, once its final arrived.
+    pub fn role(&self) -> Option<VoiceRole> {
+        self.turns.last().and_then(|t| t.role)
+    }
+
+    pub fn clear(&mut self) {
+        self.turns.clear();
+    }
+
+    fn position(&self, item: &str) -> Option<usize> {
+        self.turns
+            .iter()
+            .rposition(|t| t.item.as_deref() == Some(item))
+    }
+
+    fn push(&mut self, turn: CaptionTurn) {
+        self.turns.push(turn);
+        let excess = self.turns.len().saturating_sub(CAPTION_TURNS);
+        self.turns.drain(..excess);
+    }
+
+    /// Append a streamed delta to its turn; a new item starts a new turn. A
+    /// delta without an item continues the shown turn while it streams.
+    /// Returns false when the turn outgrew [`MAX_TRANSCRIPT_BYTES`]: it then
+    /// restarts from this delta, showing the tail rather than growing.
+    pub fn partial(&mut self, item: Option<String>, delta: &str) -> bool {
+        let index = match item {
+            Some(ref item) => self.position(item),
+            None => self
+                .turns
+                .len()
+                .checked_sub(1)
+                .filter(|&last| self.turns[last].role.is_none()),
+        };
+        let index = index.unwrap_or_else(|| {
+            self.push(CaptionTurn {
+                item,
+                text: String::new(),
+                role: None,
+            });
+            self.turns.len() - 1
+        });
+        let turn = &mut self.turns[index];
+        if turn.role.is_some() {
+            // The final already settled this turn.
+            return true;
+        }
+        let fits = turn.text.len() + delta.len() <= MAX_TRANSCRIPT_BYTES;
+        if !fits {
+            turn.text.clear();
+        }
+        turn.text.push_str(delta);
+        fits
+    }
+
+    /// A turn's final text and speaker. An unseen turn that completes while
+    /// another one streams is older than it, so it never takes the caption.
+    pub fn complete(&mut self, transcript: &VoiceTranscript) {
+        let found = self.position(&transcript.item_id).or_else(|| {
+            // Deltas without an item belong to the turn this final completes.
+            self.turns
+                .last()
+                .filter(|t| t.item.is_none() && t.role.is_none())
+                .map(|_| self.turns.len() - 1)
+        });
+        if let Some(index) = found {
+            let turn = &mut self.turns[index];
+            turn.item = Some(transcript.item_id.clone());
+            turn.text.clone_from(&transcript.text);
+            turn.role = Some(transcript.role);
+            return;
+        }
+        let turn = CaptionTurn {
+            item: Some(transcript.item_id.clone()),
+            text: transcript.text.clone(),
+            role: Some(transcript.role),
+        };
+        match self.turns.last() {
+            Some(last) if last.role.is_none() => {
+                let streaming = self.turns.len() - 1;
+                self.turns.insert(streaming, turn);
+                let excess = self.turns.len().saturating_sub(CAPTION_TURNS);
+                self.turns.drain(..excess);
+            }
+            _ => self.push(turn),
+        }
+    }
+}
+
+/// Reduced state of one remote call. Events from another generation or
+/// session are ignored; the first snapshot names the orchestrator chat.
+#[derive(Default)]
+pub struct VoiceView {
+    pub phase: VoicePhase,
+    pub snapshot: Option<VoiceSnapshot>,
+    pub microphone: u16,
+    pub speaker: u16,
+    caption: Caption,
+    muted: bool,
+    speaker_activity: SpeakerActivity,
+}
+
+impl VoiceView {
+    pub fn new() -> Self {
+        Self {
+            phase: VoicePhase::Checking,
+            ..Self::default()
+        }
+    }
+
+    pub fn chat_id(&self) -> Option<&str> {
+        self.snapshot.as_ref().map(|s| s.chat_id.as_str())
+    }
+
+    /// The newest speaker turn: live deltas, then its final text.
+    pub fn caption(&self) -> &str {
+        self.caption.text()
+    }
+
+    /// Set once the caption is a final segment; live deltas have none.
+    pub fn caption_role(&self) -> Option<VoiceRole> {
+        self.caption.role()
+    }
+
+    /// The utterance (speaker turn) the caption belongs to, if named.
+    pub fn caption_item(&self) -> Option<&str> {
+        self.caption.item()
+    }
+
+    pub fn work(&self) -> VoiceWork {
+        self.snapshot.as_ref().map_or(VoiceWork::Idle, |s| s.work)
+    }
+
+    pub fn playing(&self) -> bool {
+        self.snapshot.as_ref().is_some_and(|s| s.playing)
+    }
+
+    pub fn muted(&self) -> bool {
+        self.muted
+    }
+
+    /// The local mute is authoritative for presentation: it applies before
+    /// the host acknowledges it.
+    pub fn set_muted(&mut self, muted: bool) -> bool {
+        let changed = self.muted != muted;
+        self.muted = muted;
+        if let Some(snapshot) = &mut self.snapshot {
+            snapshot.muted = muted;
+        }
+        changed
+    }
+
+    pub fn orb_state(&self) -> OrbState {
+        orb_state(self.phase, self.snapshot.as_ref())
+    }
+
+    /// Normalized 0…1 microphone loudness; zero while muted.
+    pub fn microphone_level(&self) -> f32 {
+        if self.muted {
+            0.0
+        } else {
+            f32::from(self.microphone) / f32::from(u16::MAX)
+        }
+    }
+
+    pub fn speaker_level(&self) -> f32 {
+        f32::from(self.speaker) / f32::from(u16::MAX)
+    }
+
+    fn current(&self, generation: u64) -> bool {
+        self.snapshot
+            .as_ref()
+            .is_some_and(|s| s.generation == generation)
+    }
+
+    /// Whether the event changed what the call shows.
+    pub fn reduce(&mut self, event: VoiceEvent, now: Instant) -> bool {
+        match event {
+            VoiceEvent::Snapshot { mut snapshot } => {
+                if let Some(old) = &self.snapshot {
+                    if old.generation != snapshot.generation
+                        || old.session_id != snapshot.session_id
+                    {
+                        return false;
+                    }
+                    snapshot.playing = old.playing;
+                }
+                snapshot.muted = self.muted;
+                self.phase = snapshot.phase;
+                self.snapshot = Some(snapshot);
+            }
+            VoiceEvent::Partial {
+                generation,
+                item_id,
+                text,
+            } if self.current(generation) => {
+                // A runaway utterance shows its tail rather than grow.
+                self.caption.partial(item_id, &text);
+            }
+            VoiceEvent::Final { transcript }
+                if self
+                    .snapshot
+                    .as_ref()
+                    .is_some_and(|s| s.session_id == transcript.session_id) =>
+            {
+                self.caption.complete(&transcript);
+            }
+            VoiceEvent::Levels {
+                generation,
+                microphone,
+                speaker,
+            } if self.current(generation) => {
+                self.microphone = microphone;
+                self.speaker = speaker;
+                let playing = self.speaker_activity.update(speaker, now);
+                if let Some(snapshot) = &mut self.snapshot {
+                    snapshot.playing = playing;
+                }
+            }
+            VoiceEvent::Closed { generation, reason } if self.current(generation) => {
+                self.phase = if reason.is_some() {
+                    VoicePhase::Failed
+                } else {
+                    VoicePhase::Closed
+                };
+            }
+            _ => return false,
+        }
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn snapshot(generation: u64) -> VoiceSnapshot {
+        VoiceSnapshot {
+            session_id: "session".into(),
+            chat_id: "voice-orchestrator-full-id".into(),
+            generation,
+            phase: VoicePhase::Active,
+            muted: false,
+            playing: false,
+            work: VoiceWork::Idle,
+            reason: None,
+            voice: None,
+            voices: vec![],
+        }
+    }
+
+    #[test]
+    fn speaker_activity_ignores_noise_and_holds_through_syllable_gaps() {
+        let now = Instant::now();
+        let mut activity = SpeakerActivity::default();
+        assert!(!activity.update(500, now));
+        assert!(activity.update(1024, now));
+        assert!(activity.update(0, now + Duration::from_millis(249)));
+        assert!(!activity.update(0, now + Duration::from_millis(250)));
+        assert!(!activity.update(500, now + Duration::from_millis(300)));
+    }
+
+    #[test]
+    fn remote_view_derives_speaking_and_keeps_it_across_snapshots() {
+        let now = Instant::now();
+        let mut view = VoiceView::new();
+        assert_eq!(view.orb_state(), OrbState::Connecting);
+        assert!(view.reduce(
+            VoiceEvent::Snapshot {
+                snapshot: snapshot(2)
+            },
+            now
+        ));
+        assert_eq!(view.chat_id(), Some("voice-orchestrator-full-id"));
+        assert_eq!(view.orb_state(), OrbState::Listening);
+        view.reduce(
+            VoiceEvent::Levels {
+                generation: 2,
+                microphone: 0,
+                speaker: 4000,
+            },
+            now,
+        );
+        assert_eq!(view.orb_state(), OrbState::Composing);
+        let mut working = snapshot(2);
+        working.work = VoiceWork::AwaitingInput;
+        view.reduce(VoiceEvent::Snapshot { snapshot: working }, now);
+        // The host never meters client media; its `playing: false` is stale.
+        assert!(view.playing());
+        view.reduce(
+            VoiceEvent::Levels {
+                generation: 2,
+                microphone: 0,
+                speaker: 0,
+            },
+            now + Duration::from_secs(1),
+        );
+        assert_eq!(view.orb_state(), OrbState::Solving);
+        assert!(view.set_muted(true));
+        assert_eq!(view.microphone_level(), 0.0);
+    }
+
+    #[test]
+    fn stale_events_and_runaway_partials_stay_bounded() {
+        let now = Instant::now();
+        let mut view = VoiceView::new();
+        assert!(!view.reduce(
+            VoiceEvent::Partial {
+                generation: 1,
+                item_id: None,
+                text: "early".into()
+            },
+            now
+        ));
+        view.reduce(
+            VoiceEvent::Snapshot {
+                snapshot: snapshot(2),
+            },
+            now,
+        );
+        assert!(!view.reduce(
+            VoiceEvent::Snapshot {
+                snapshot: snapshot(3)
+            },
+            now
+        ));
+        assert!(!view.reduce(
+            VoiceEvent::Closed {
+                generation: 1,
+                reason: None
+            },
+            now
+        ));
+        for _ in 0..5 {
+            view.reduce(
+                VoiceEvent::Partial {
+                    generation: 2,
+                    item_id: Some("item".into()),
+                    text: "x".repeat(MAX_TRANSCRIPT_BYTES / 2),
+                },
+                now,
+            );
+        }
+        assert!(view.caption().len() <= MAX_TRANSCRIPT_BYTES);
+        view.reduce(
+            VoiceEvent::Final {
+                transcript: VoiceTranscript {
+                    session_id: "session".into(),
+                    item_id: "item".into(),
+                    role: VoiceRole::Assistant,
+                    text: "done".into(),
+                    promoted_message_id: None,
+                },
+            },
+            now,
+        );
+        assert_eq!(view.caption(), "done");
+        assert_eq!(view.caption_role(), Some(VoiceRole::Assistant));
+        view.reduce(
+            VoiceEvent::Partial {
+                generation: 2,
+                item_id: Some("next-item".into()),
+                text: "next".into(),
+            },
+            now,
+        );
+        assert_eq!(view.caption(), "next");
+        assert_eq!(view.caption_role(), None);
+        assert!(view.reduce(
+            VoiceEvent::Closed {
+                generation: 2,
+                reason: Some(VoiceRejection::Protocol)
+            },
+            now
+        ));
+        assert_eq!(view.phase, VoicePhase::Failed);
+    }
+
+    fn final_of(item: &str, role: VoiceRole, text: &str) -> VoiceTranscript {
+        VoiceTranscript {
+            session_id: "session".into(),
+            item_id: item.into(),
+            role,
+            text: text.into(),
+            promoted_message_id: None,
+        }
+    }
+
+    /// The order Codex really sends: the user's final lands after the
+    /// assistant has started answering.
+    #[test]
+    fn a_late_user_final_never_takes_the_caption_from_the_assistant() {
+        let mut caption = Caption::default();
+        caption.partial(Some("user".into()), "Open the ");
+        caption.partial(Some("user".into()), "sync test");
+        caption.partial(Some("assistant".into()), "Sure, ");
+        caption.partial(Some("assistant".into()), "opening it");
+        assert_eq!(caption.text(), "Sure, opening it");
+        caption.complete(&final_of("user", VoiceRole::User, "Open the sync test."));
+        assert_eq!(caption.text(), "Sure, opening it");
+        assert_eq!(caption.item(), Some("assistant"));
+        assert_eq!(caption.role(), None);
+        caption.partial(Some("assistant".into()), " now.");
+        assert_eq!(caption.text(), "Sure, opening it now.");
+        caption.complete(&final_of(
+            "assistant",
+            VoiceRole::Assistant,
+            "Sure, opening it now.",
+        ));
+        assert_eq!(caption.text(), "Sure, opening it now.");
+        assert_eq!(caption.role(), Some(VoiceRole::Assistant));
+    }
+
+    /// A user turn transcribed only as a final, after the answer started.
+    #[test]
+    fn an_unseen_final_is_older_than_the_streaming_turn() {
+        let mut caption = Caption::default();
+        caption.partial(Some("assistant".into()), "On it");
+        caption.complete(&final_of("user", VoiceRole::User, "Open the test"));
+        assert_eq!(caption.text(), "On it");
+        assert_eq!(caption.item(), Some("assistant"));
+        // With nothing streaming, a final is the newest turn.
+        caption.complete(&final_of("assistant", VoiceRole::Assistant, "On it."));
+        caption.complete(&final_of("user-2", VoiceRole::User, "Thanks"));
+        assert_eq!(caption.text(), "Thanks");
+        assert_eq!(caption.role(), Some(VoiceRole::User));
+    }
+
+    #[test]
+    fn deltas_without_an_item_continue_the_streaming_turn() {
+        let mut caption = Caption::default();
+        caption.partial(None, "Hello ");
+        caption.partial(None, "there");
+        assert_eq!(caption.text(), "Hello there");
+        caption.complete(&final_of("a", VoiceRole::Assistant, "Hello there."));
+        assert_eq!(caption.item(), Some("a"));
+        // A settled turn is not continued: the next delta starts a new one.
+        caption.partial(None, "Next");
+        assert_eq!(caption.text(), "Next");
+        assert_eq!(caption.role(), None);
+    }
+
+    #[test]
+    fn a_settled_turn_ignores_late_deltas_and_old_turns_are_forgotten() {
+        let mut caption = Caption::default();
+        caption.partial(Some("a".into()), "Done");
+        caption.complete(&final_of("a", VoiceRole::Assistant, "Done."));
+        caption.partial(Some("a".into()), " again");
+        assert_eq!(caption.text(), "Done.");
+        for i in 0..CAPTION_TURNS * 2 {
+            caption.partial(Some(format!("turn-{i}")), "x");
+        }
+        assert_eq!(caption.turns.len(), CAPTION_TURNS);
+        assert_eq!(
+            caption.item(),
+            Some(format!("turn-{}", CAPTION_TURNS * 2 - 1).as_str())
+        );
+    }
+}
diff --git a/dist/macos/Info-dev.plist b/dist/macos/Info-dev.plist
index 8a01666242..1235ec6cce 100644
--- a/dist/macos/Info-dev.plist
+++ b/dist/macos/Info-dev.plist
@@ -2,8 +2,6 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-  <key>NSMicrophoneUsageDescription</key>
-  <string>Dictate into your draft using on-device Parakeet transcription.</string>
     <key>CFBundleDevelopmentRegion</key>
     <string>en</string>
     <key>CFBundleDisplayName</key>
@@ -36,6 +34,8 @@
         <key>ZERON_IPC_PORT</key>
         <string>__IPC_PORT__</string>
     </dict>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Zeron uses your microphone for on-device dictation and for voice sessions you start. Voice sessions stream your audio to OpenAI through your ChatGPT-authenticated Codex account.</string>
     <key>NSHighResolutionCapable</key>
     <true/>
     <key>NSSupportsAutomaticGraphicsSwitching</key>
diff --git a/dist/macos/Info-unbundled.plist b/dist/macos/Info-unbundled.plist
new file mode 100644
index 0000000000..af5ee44bd2
--- /dev/null
+++ b/dist/macos/Info-unbundled.plist
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Privacy declarations for direct source/CLI launches. App bundles keep
+         their own name, identity, version and runtime environment. -->
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Zeron uses your microphone for on-device dictation and for voice sessions you start. Voice sessions stream your audio to OpenAI through your ChatGPT-authenticated Codex account.</string>
+</dict>
+</plist>
diff --git a/dist/macos/Info.plist b/dist/macos/Info.plist
index 62b4052bda..555a551f10 100644
--- a/dist/macos/Info.plist
+++ b/dist/macos/Info.plist
@@ -4,8 +4,6 @@
      bundling steps. Replace __VERSION__ before packaging. -->
 <plist version="1.0">
 <dict>
-  <key>NSMicrophoneUsageDescription</key>
-  <string>Dictate into your draft using on-device Parakeet transcription.</string>
     <key>CFBundleDevelopmentRegion</key>
     <string>en</string>
     <key>CFBundleDisplayName</key>
@@ -39,6 +37,8 @@
     </array>
     <key>LSMinimumSystemVersion</key>
     <string>12.0</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Zeron uses your microphone for on-device dictation and for voice sessions you start. Voice sessions stream your audio to OpenAI through your ChatGPT-authenticated Codex account.</string>
     <key>NSHighResolutionCapable</key>
     <true/>
     <!-- Browser tabs load user-selected HTTP dev servers. Keep the exception
diff --git a/dist/macos/voice.entitlements b/dist/macos/voice.entitlements
new file mode 100644
index 0000000000..b1b58ec66e
--- /dev/null
+++ b/dist/macos/voice.entitlements
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+    <key>com.apple.security.device.audio-input</key><true/>
+</dict></plist>
diff --git a/dist/voice/Codex-LICENSE.txt b/dist/voice/Codex-LICENSE.txt
new file mode 100644
index 0000000000..4606e72e04
--- /dev/null
+++ b/dist/voice/Codex-LICENSE.txt
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 OpenAI
+
+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
+
+       http://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.
diff --git a/dist/voice/README.md b/dist/voice/README.md
new file mode 100644
index 0000000000..8806b25eb3
--- /dev/null
+++ b/dist/voice/README.md
@@ -0,0 +1,29 @@
+# Development media runtime
+
+Zeron packages do not contain the Codex voice runtime. On macOS, Linux and
+Windows, local and remote voice run the `codex-voice-host` helper of the user's
+own standalone Codex installation (layout 1, version 0.159 or later), resolved
+from the same `codex` executable the harness uses. npm installations do not
+include the runtime and report `nativeRuntimeUnavailable`.
+
+`scripts/package-voice-runtime.py` is a development tool only. It projects the
+voice subtree of a checksum-pinned official Codex `0.160.0` package into a
+`codex-resources/voice` directory (the helper refuses to initialize from any
+other directory name), for example to test a machine without Codex:
+
+```sh
+python3 scripts/package-voice-runtime.py --download \
+  --target x86_64-unknown-linux-gnu --destination /tmp/zeron/codex-resources/voice
+```
+
+macOS needs an explicit extracted package (`--package`). The projection keeps
+binaries and libraries byte-for-byte (macOS signatures are verified, not
+replaced), the dependency notices and sources manifest, and adds
+`Codex-LICENSE.txt`, the unmodified OpenAI license at source commit
+`a956835d020762cb2b570053af06f643a11c0ecc`:
+https://github.com/openai/codex/blob/a956835d020762cb2b570053af06f643a11c0ecc/LICENSE
+
+Point `ZERON_VOICE_MEDIA_DIR` at the projected directory to override the
+installed helper for remote voice. Do not ship a projected runtime: its
+GStreamer/GLib (LGPL-2.1), Opus, other native libraries and, on Windows, the
+Microsoft Visual C++ runtime carry their own redistribution obligations.
diff --git a/docs/research/codex-voice-ios.md b/docs/research/codex-voice-ios.md
new file mode 100644
index 0000000000..d4938d8dab
--- /dev/null
+++ b/docs/research/codex-voice-ios.md
@@ -0,0 +1,53 @@
+# Native iOS voice endpoint (development)
+
+Physical-device acceptance is delegated to the user; G3/G4 remain pending.
+The initial endpoint is foreground-only and does not contain Codex or credentials.
+
+The dependency is pinned to [stasel/WebRTC 150.0.0](https://github.com/stasel/WebRTC/blob/150.0.0/Package.swift),
+whose Swift package declares binary SHA-256
+`f9890492b0016e4c88ab20f07867b8b420054caedc8a692b2ec6ac041f3cf6b2`.
+Xcode verifies this artifact checksum and records the resolved revision. Retain
+WebRTC's bundled notices when distributing (`Voice/WebRTC-LICENSE.txt` is copied
+from the pinned XCFramework and included as an app resource, as is the orb's MIT
+notice `Voice/ThinkingOrbs-LICENSE.txt`; see `THIRD_PARTY_NOTICES.md` and the
+privacy/legal section of [codex-voice.md](codex-voice.md)). The package wraps the upstream native
+SDK rather than reimplementing its codecs, echo cancellation or audio device.
+
+Contract reference: the [pinned Codex helper transport](https://github.com/openai/codex/blob/a956835d020762cb2b570053af06f643a11c0ecc/codex-rs/voice-host/src/transport.rs)
+adds an audio track, creates an ordered `oai-events` data channel, gathers ICE into
+the offer, and waits for the channel to open after applying the answer. It discards
+incoming channel message bodies and rejects remotely created channels. The iOS
+endpoint follows those behaviors. This source inspection does not establish that
+subscription negotiation, interruption or MCP work on an actual iPhone.
+
+The endpoint keeps its audio track and manual audio device disabled until the
+host confirms the lease. Mute disables the local track without a network roundtrip.
+Close disables audio and releases the peer before remote cleanup. The WebRTC audio
+configuration is installed globally (`setWebRTCConfiguration`), because WebRTC
+re-applies its global configuration when the audio unit starts and would otherwise
+drop the app's category options mid-call. Output follows the proximity sensor
+(loudspeaker in hand, earpiece at the ear) unless a headset, Bluetooth or car route
+is active. The call survives the screen locking (background audio). An interruption
+or failed connection closes it; it never resumes automatically. Cancellation
+invalidates pending continuations so late SDK callbacks cannot return a second
+result or reactivate media.
+
+The orb is the desktop's: `zeron-orb` computes geometry, clock, audio response and
+crossfades for both, and iOS only paints the frames (`OrbView`).
+
+Required live checks: iPhone on Wi-Fi and cellular, Fedora and Mac hosts, actual
+bidirectional sound, barge-in/AEC, Bluetooth and route changes, background during
+startup and active speech, denied permission, full-ID MCP delegation and unique
+host-side transcripts. Measure package size, CPU and latency on the target device;
+none are claimed by an offline build.
+
+Pending before App Store submission (owner decisions, also tracked in the
+[acceptance checklist](voice-remote-testing.md#legal-and-privacy-blocks-a-public-release)):
+
+- Consent: guideline 5.1.2(i) requires disclosing that audio is shared with a
+  third-party AI (OpenAI) and explicit permission before doing so. The
+  microphone purpose string discloses it; an in-app consent step before the
+  first call is not implemented.
+- Privacy manifest: `PrivacyInfo.xcprivacy` declares no collected data. Decide
+  whether audio sent to OpenAI and synced voice transcripts must be declared,
+  consistently with the App Store privacy labels.
diff --git a/docs/research/codex-voice-remote.md b/docs/research/codex-voice-remote.md
new file mode 100644
index 0000000000..6c017ea311
--- /dev/null
+++ b/docs/research/codex-voice-remote.md
@@ -0,0 +1,166 @@
+# Split-host Codex voice: compatibility probe
+
+Status (2026-10-01): **G0 pending**. The diagnostic and its offline tests are
+implemented. No Mac/Fedora conversation, cross-network test, MCP roundtrip or
+iPhone test has been performed. These offline tests do not establish live
+subscription or audio compatibility.
+
+Current implementation: V2 client-owned audio is enabled by default in desktop
+apps and headless engines; the V1 RPC remains for compatibility. No environment
+flag is needed. See [testing instructions](voice-remote-testing.md).
+
+## Run the diagnostic
+
+From the Mac, using an explicitly selected local media helper and an already
+configured SSH host with subscription-authenticated Codex:
+
+```sh
+python3 scripts/codex-voice-remote-smoke.py --live \
+  --ssh-host YOUR_FEDORA_ALIAS \
+  --remote-codex /absolute/path/on/fedora/bin/codex \
+  --remote-cwd /absolute/existing/directory/on/fedora \
+  --helper /absolute/local/voice/bin/codex-voice-host
+```
+
+The command above negotiates without opening audio devices. Add
+`--devices --seconds 60` to open the **Mac's** microphone and speaker for a
+bounded conversation. Speak after the audio-active notice. Interrupt the spoken
+response to assess barge-in. Ctrl-C closes local audio before attempting remote
+stop. A desktop terminal needs macOS microphone permission for this live probe.
+
+The helper does not resolve a local Codex executable. Copying only its binary is
+insufficient: keep its adjacent libraries, plugins and runtime metadata intact.
+This probe does not package that runtime into Zeron; that is C02.
+
+SSH runs only metadata commands and Codex app-server on Fedora, never a helper
+or an audio-device command. SSH must already work noninteractively; unknown host
+keys are not auto-accepted. The script neither registers a Zeron device nor
+uses SSH as a proposed product transport. Product discovery and controls will
+reuse registered Zeron devices and the existing authenticated relay.
+
+`--live` explicitly opts into normal subscription usage. There is no API-key
+fallback. The diagnostic checks ChatGPT auth and rejects custom provider/realtime
+configuration before negotiating. Its ephemeral, read-only diagnostic thread
+instructs the model not to use tools. It does not create a Zeron orchestrator or
+send messages to other agents.
+
+## What the result means
+
+The output contains stage/error codes, platforms, helper build, remote Codex
+version, transport status, canonical final-item counts and cleanup results.
+It never prints SDP, ICE candidates, account fields, transcript contents or raw
+provider errors. It does not write protocol traffic to files. Codex's own logging
+policy on the host remains independent of this diagnostic.
+
+`ok` requires successful negotiation and both local shutdown and the provider's
+requested-close event. With `--devices`, it also requires at least one canonical
+user final and assistant final received on the remote app-server connection.
+These counters deduplicate by item ID and reject other thread/session IDs.
+They do not independently prove audible quality, echo cancellation or barge-in.
+`muteControlAccepted` means the helper acknowledged mute, not that silence was
+measured. `gateG0Passed` and `mcpRoutingVerified` always remain false: the tool
+cannot certify the product's full-ID MCP return path.
+
+The `thread/realtime/listVoices` call deliberately precedes thread creation.
+`voicesBeforeThread` records whether that request succeeded with the tested
+binary. It does not infer compatibility with every Codex version.
+
+A fresh app-server/thread/session is used for each run. The existing wire format
+can omit a session ID on SDP/close notifications; the diagnostic never reuses a
+thread for another negotiation. Production bridge generations still need the
+explicit lifecycle isolation described in C04.
+
+## Offline verification
+
+```sh
+python3 -m unittest discover -s scripts/tests -p 'test_voice_remote*.py' -v
+```
+
+The tests launch independent fake app-server/helper subprocesses using the real
+JSON-lines and length-prefixed pipes. They never launch Codex, contact a provider,
+open hardware or require credentials. Covered cases include:
+
+- Started/SDP in either order, final-item deduplication and stale identities.
+- Malformed and oversized SDP, with limits measured in bytes.
+- Truncated/oversized helper frames and stalled helper cleanup.
+- Provider closure/rejection, RPC EOF and request/negotiation deadlines.
+- Lost start reply and cancellation during start, including explicit stop.
+- Auth/config rejection before transport, secret-safe results and SSH quoting.
+
+A failed helper exchange permanently invalidates that pipe and reaps its child;
+a late reply cannot satisfy another command. Requests, signaling, queues and
+item tracking are bounded. Cleanup stops local media first, then requests remote
+stop, then closes/reaps only the diagnostic's own subprocesses.
+
+Observed locally: 17 tests passed on macOS ARM64. This is control/protocol
+coverage, **not live provider compatibility evidence**.
+
+## Local runtime inventory
+
+Read-only inspection of the installed standalone package on 2026-10-01:
+
+| Property | Observed value |
+| --- | --- |
+| Codex package | `0.160.0`, layout version `1` |
+| Target | `aarch64-apple-darwin` |
+| Source/helper build | `a956835d020762cb2b570053af06f643a11c0ecc` |
+| Helper SHA-256 | `e408413b79d76e518966046ce1d7758523c606844269fe4dd56446bed80c1062` |
+| Helper size | 9,900,112 bytes |
+| Complete voice subtree | 37 files, 21,237,467 bytes |
+| Dynamic libraries | 18 |
+| GStreamer plugins | 7 |
+| License files | 7 |
+| Metadata/notices | `manifest.json`, `runtime.json`, `sources.json`, `NOTICE.md` |
+| Package manifest hashes | All entries verified, no mismatches |
+| Helper code signature | `codesign --verify --strict` succeeded |
+
+`otool -L` confirms adjacent `@rpath` dependencies on libffi, GLib/GIO/GObject,
+GStreamer, libintl, Opus, PCRE2 and zlib, plus macOS system libraries/frameworks.
+The seven plugins are app, audioconvert, audioresample, coreelements, opus, rtp
+and rtpmanager. The package sources inventory identifies GStreamer 1.28.6,
+GLib 2.88.3, Opus 1.6.1, libffi 3.8.0, PCRE2 10.47, zlib 1.3.2 and
+proxy-libintl 0.5, with upstream archive hashes. Meson 1.12.0 and Ninja 1.13.2
+are recorded build inputs, not runtime libraries.
+
+Bundled notice files cover LGPL-2.1, Opus, PCRE2, libffi, proxy-libintl, sljit and
+zlib. The package's `NOTICE.md` identifies the upstream Codex
+`third_party/voice/` build/projection/package scripts and references
+`manifest.json` for the source commit. This inventories existing provenance.
+Zeron does not redistribute this runtime: the desktop client of a remote call
+runs the helper of its own standalone Codex installation, as local voice does.
+Redistributing it would make Zeron responsible for the LGPL source offer, the
+Apache NOTICE, the Windows Visual C++ runtime terms and security updates of the
+media stack. `scripts/package-voice-runtime.py` remains a development tool that
+projects a pinned package for `ZERON_VOICE_MEDIA_DIR`. The helper only
+initializes from a `codex-resources/voice` directory: anywhere else it exits
+with code 23 on `initializeRuntime`, which the client reports as an unavailable
+runtime. Projection never re-signs: upstream already signs the helper and
+libraries with OpenAI's Developer ID, hardened runtime and a secure timestamp.
+No binaries or credentials were copied into this repository.
+
+## Remaining G0 evidence
+
+Remaining live acceptance (the user requested proceeding with implementation
+and will run these checks after it):
+
+1. Supply the Fedora SSH alias, absolute Codex path and working directory, with
+   compatible subscription authentication already configured.
+2. Run negotiation and an actual bidirectional conversation, with media on Mac
+   and app-server on Fedora. Record sanitized versions/platforms and whether the
+   devices are on different networks. Verify Fedora has no audio-device access.
+3. Inspect the actual media contract: negotiated codecs, ICE gathering, required
+   data-channel messages/readiness, barge-in and echo behavior. The presence of
+   an Opus library alone does not establish the negotiated codec contract.
+4. Validate canonical finals and a real Zeron MCP delegation/return using the
+   full orchestrator ID. The standalone no-tools diagnostic cannot establish
+   this: it must be paired with a Zeron-hosted harness test. Do not interpret a
+   generic promoted-item notification as proof of MCP success.
+5. Record any provider restriction before committing the dependent product
+   architecture. Runtime redistribution is avoided: clients use their installed
+   standalone Codex helper.
+
+G0–G4 remain pending live validation. C02–C15 code is implemented,
+including the shared coordinator, remote engine control, desktop media runtime,
+UniFFI bridge and native iOS UI/audio. Automated tests cover a fake Codex host
+through two engines and the WebSocket relay; they do not establish live provider
+acceptance. A physical iPhone is required at G3/G4.
diff --git a/docs/research/codex-voice.md b/docs/research/codex-voice.md
new file mode 100644
index 0000000000..f975cc1215
--- /dev/null
+++ b/docs/research/codex-voice.md
@@ -0,0 +1,231 @@
+# Native Codex subscription voice
+
+Zeron connects a local Codex chat to the installed Codex voice runtime. Voice
+uses ChatGPT authentication and the normal Codex plan budget. Codex may use
+additional credits according to the user's account settings and usage limits.
+There is no OpenAI API-key fallback, separate public Realtime API client, or
+promise of an included-quota-only spending cap.
+
+Sources checked 2026-10-01:
+
+- [App-server](https://learn.chatgpt.com/docs/app-server)
+- [Voice](https://learn.chatgpt.com/docs/features/voice)
+- [Pricing](https://learn.chatgpt.com/docs/pricing#how-much-does-voice-cost)
+- [Official Codex source, rust-v0.159.0](https://github.com/openai/codex/tree/377f7f557a6bdea0f3a2d26d4d899c66db4789d0/codex-rs),
+  commit `377f7f557a6bdea0f3a2d26d4d899c66db4789d0`: app-server realtime schemas,
+  `core/src/realtime_conversation.rs`, `realtime-webrtc`, and `voice-host`.
+
+## Transport and authentication
+
+Codex 0.159's WebSocket audio path calls `realtime_api_key` and requires API-key
+credentials, including an environment-key fallback. That path is unsuitable for
+this integration. Native subscription voice uses **WebRTC V3** instead:
+
+1. Prepare or reuse an idle native thread with the normal Zeron MCP server.
+   No initial `turn/start`, empty user message, title request, or submitted draft.
+   Load the initial `account/read` snapshot before attaching the voice router:
+   Codex announces initial authentication with `account/updated`, which must not
+   be mistaken for a later identity change. Subsequent updates still retire voice.
+2. Check `account/read` on that same process for `chatgpt` authentication, reject
+   custom providers and realtime backend overrides in the effective project
+   configuration (`config/read` with the resolved thread cwd), validate the
+   provider returned by `thread/start` or `thread/resume`, inspect ordinary
+   usage permission, and obtain `thread/realtime/listVoices`. Exhausted ordinary
+   quota alone does not reject permitted credits; the native backend makes the
+   final usage and spend-control decision.
+3. Resolve the helper inside the physical standalone Codex package (layout 1,
+   version 0.159 or later). Its protocol/build handshake must succeed.
+4. Initialize the helper and gather its SDP offer. Call `thread/realtime/start`
+   with WebRTC, V3, audio output, the lease session id, startup context, and
+   `clientManagedHandoffs: false`. Codex owns background task delegation.
+5. The request response acknowledges submission. Independently wait for both
+   `thread/realtime/started` and `thread/realtime/sdp`; validate session/version.
+6. Apply the answer and wait for transport readiness. Open default local audio
+   devices while muted/suppressed. Only enable them for an attached owner.
+
+Audio, Opus, resampling, echo cancellation, reference audio, native interruption,
+and bounded playout remain in Codex's helper. No PCM or SDP reaches the UI,
+document, sync journal, or owner RPC stream. Helper stderr is discarded; errors
+and diagnostics use typed rejection reasons. Child processes are killed and
+reaped on cancellation, including when a helper control reply is stalled.
+
+The earlier `zeron-audio` PCM/AEC prototype remains isolated and tested offline;
+it is not a dependency of the released UI or the subscription voice path.
+`voice-experimental` is retained as an empty compatibility build feature. The
+Codex voice control is available in ordinary desktop builds.
+
+## Lifecycle, transcript and MCP
+
+One engine lease owns local voice. Tokens are redacted from Debug. Ownership is
+exclusive, generation checked, ephemeral, and cancelled when its scoped stream
+is dropped. A five-second unattached-owner watchdog prevents abandoned starts
+from creating a provider call. A successor waits for native stop and its terminal
+`requested` notification from that single stop; a spontaneous terminal cannot
+satisfy the barrier and leave our terminal queued for a successor. Late events
+cannot acquire the successor's generation. Native
+capture termination is independent of the actor's pending control I/O. The
+stdout reader also cancels capture on identity changes, overflow and EOF; it
+does not wait for a blocked audio-control reply. Identity retirement invalidates
+pending start reservations as well as existing leases. The physical Codex
+release is pinned before spawning app-server so an installer symlink change
+cannot select a different helper for a warm runtime. A reader identity change
+also permanently invalidates the voice bridge before any new token can be
+installed. A fresh explicit request can renew that idle runtime after cleanup;
+continuing delegated work is preserved and must finish before renewal.
+
+Voice protects the warm runtime from idle reaping and updates. Voice stop leaves
+delegated Codex work running. Account/profile retirement, engine/window owner
+loss, audio failure and provider termination close voice; navigating between
+threads does not. An agent question keeps voice open: the stage reports it and
+links to the session transcript, where the usual input UI answers it. Reconnection and
+microphone resumption require a fresh user action. Changes to the chat host,
+configuration or checkout invalidate pending starts and active ownership;
+workspace monitoring also covers synced host/configuration changes.
+
+Canonical `thread/realtime/item/completed` transcript segments are committed by
+the serialized document owner, deduplicated by session/item identity. Legacy
+transcript events and partial text never become durable messages. Only a newly
+inserted canonical final updates sidebar activity and preview; replay does not
+bump the timestamp. Native BEM
+promotion uses the existing Codex task transcript; it does not resubmit a spoken
+request or create another task response. Native `turn/started` publishes the
+engine turn boundary before its text/tools, including on an idle bootstrap.
+
+Every session is an orchestrator. `thread/realtime/start` carries one short
+English instruction, as `realtimeStartInstructions` for the backing Codex model
+and as a developer `initialItems` entry for the voice model: use the Zeron MCP
+to create, message and monitor chats, and delegate coding work to them.
+
+The voice agent uses the unchanged upstream Zeron MCP. Creating chats, sending
+messages and delegating tasks use the normal provider selection, authentication
+and device routing. A Codex voice session can create a Grok, Claude Code or other
+available provider session; those children use their own provider credentials.
+Codex/ChatGPT authentication and local-host checks apply to starting voice itself,
+not to the sessions it controls through MCP. Ending voice does not restrict
+continuing tasks or their children.
+
+## Interface and packaging
+
+Voice starts from the microphone in the sidebar footer, next to Settings. Each
+session creates a fresh projectless Codex chat (cwd `~`) on this device whose id
+starts with `voice-orchestrator-`. That prefix keeps it out of the sidebar,
+jump slots, command palette, archive and completion notifications, and the
+engine drops it as a `parentChatId`: chats the orchestrator creates are ordinary
+top-level sessions. The chat is deleted again if startup fails before a lease
+exists. It uses the composer's Codex model when Codex is selected, otherwise
+Codex's default. The composer is never replaced or suspended: the user keeps typing in
+and switching between threads while voice runs.
+
+While a session is live the microphone becomes a small orb. Pressing it toggles
+a stage over the conversation area (the whole window when the sidebar is
+collapsed); the titlebar cluster stays above it, and picking another thread,
+a new session or Settings steps it aside without ending voice. The stage shows
+the orb extracted from Bezel at `6141af9c16f7353cdf36003f7404e0a94566a163`
+(magnified), over the new-thread hero artwork with its soft bottom fade and a
+live caption. A video-call style bar at the bottom carries the session
+clock, microphone mute (with a live input ring), a next-session voice menu,
+transcript, a red End button and the way back to the chats (also Escape).
+Bezel is not a dependency. MIT notices accompany the extracted component.
+The orb tracks listening, speaking, task work and pending questions, uses the
+theme and reduced-motion setting, and stops hidden/background timers.
+
+Native voice ids from the provider catalog can be selected for the next session;
+only that preference is persisted. Devices use the operating system defaults.
+Codex's current helper protocol does not expose device selection.
+
+The native helper/runtime is supplied by the standalone Codex installation,
+not redistributed by Zeron, on macOS, Linux and Windows; the desktop client of
+a remote call uses its own installation the same way. npm/CLI-only
+installations without those resources report `nativeRuntimeUnavailable`. macOS production/dev bundles declare microphone
+usage and audio-input entitlements. The viewport verifies microphone authorization
+and requests it when voice is explicitly started, before creating a provider
+session or opening devices. Denied access shows a settings hint. Cargo builds
+embed the microphone purpose string in the executable's `__TEXT,__info_plist`
+section, so direct development launches can also request access. Missing
+metadata shows a rebuild hint instead of requesting permission and being
+terminated by macOS. `scripts/run-macos-dev.sh` builds the
+signed development bundle; `ZERON_DEV_BUILD_ONLY=1` prepares it without launching.
+No new DSP DLLs or C++ build dependency are
+added to the production UI. Apache-2.0 attribution for the adapted native helper
+protocol is included in `THIRD_PARTY_NOTICES.md`.
+
+## Privacy, notices and legal
+
+Data flow:
+
+- Audio goes from the device with the microphone (Codex's helper on desktop,
+  WebRTC on iOS) directly to OpenAI, under the user's own ChatGPT-authenticated
+  Codex account and OpenAI's terms. It never transits Zeron servers.
+- Remote calls exchange SDP signaling and controls over the authenticated
+  owner-only device relay; they are ephemeral and never persisted.
+- Canonical final transcript text is stored in the orchestrator chat's session
+  document and syncs like any chat, through Zeron's relay. Orchestrator chats
+  are hidden from the sidebar but are not deleted when a call ends.
+- Usage is billed to the user's Codex plan or credits by OpenAI.
+
+The microphone purpose strings (`dist/macos/Info*.plist`,
+`apps/ios/Zeron/Info.plist`) state that voice sessions stream audio to OpenAI;
+dictation stays on device.
+
+Notices: `THIRD_PARTY_NOTICES.md` covers the Apache-2.0 Codex protocol
+adaptation (with its upstream NOTICE and an OpenAI trademark/non-affiliation
+statement), the MIT orb chain (Bezel, gpui-thinking-orbs, thinking-orbs) and
+WebRTC for iOS. macOS, Windows and Linux packages ship `LICENSE` and
+`THIRD_PARTY_NOTICES.md`; the iOS app ships `Voice/WebRTC-LICENSE.txt` and
+`Voice/ThinkingOrbs-LICENSE.txt`. No Codex binaries are redistributed.
+
+Pending before a public release (owner decisions, not code):
+
+- iOS: App Review guideline 5.1.2(i) requires disclosing that personal data is
+  shared with a third-party AI and obtaining explicit permission before doing
+  so. The permission string discloses it; an explicit in-app consent step
+  before the first call is not implemented.
+- iOS privacy manifest (`PrivacyInfo.xcprivacy`) and App Store privacy labels
+  declare no collected data. Decide whether audio sent to OpenAI and synced
+  voice transcripts must be declared.
+- Zeron's public privacy policy and terms (outside this repository) should
+  describe the OpenAI audio flow and transcript sync.
+- WebRTC's embedded third-party licenses (BoringSSL, libsrtp, Opus, libyuv,
+  Abseil and others) are referenced, not reproduced; generate the full list
+  from the pinned XCFramework before distribution.
+
+## Validation and practical limits
+
+Offline CI never starts a provider session or microphone. Fake app-server and
+helper peers exercise actual engine RPC, independent start acknowledgements,
+SDP signaling, owner attachment, native controls, transcript replay, task
+continuation, stop/restart and authentication rejection. Synthetic audio tests
+remain offline. Cross-platform checks compile the native bridge without loading
+hardware; signed package/device trials require their actual operating systems.
+
+Read-only discovery:
+
+```sh
+python3 scripts/codex-voice-probe.py
+```
+
+Explicit opt-in connectivity smoke (consumes normal Codex voice usage, does not
+open microphone devices):
+
+```sh
+python3 scripts/codex-voice-smoke.py --live
+```
+
+Optional device/playout check opens default devices with the microphone **muted**
+and requests a short greeting:
+
+```sh
+python3 scripts/codex-voice-smoke.py --live --devices
+```
+
+Evidence on 2026-10-01, Linux, installed Codex 0.159.0: ChatGPT authentication,
+packaged helper initialization, real V3 WebRTC negotiation, transport readiness
+and native stop passed. No API fallback was used. The optional device trial
+failed at opening audio devices: this environment exposes a network output
+monitor, without a usable default microphone. No real speech or acoustic echo
+trial is claimed. macOS/Windows signed package and physical-device trials also
+remain unverified; protocol/fixture success does not establish those results.
+
+Implementation review and local test results are recorded in the ignored
+`.personal/codex-voice/` working notes. No push, deployment or remote PR is part
+of this task.
diff --git a/docs/research/voice-remote-testing.md b/docs/research/voice-remote-testing.md
new file mode 100644
index 0000000000..6b76577056
--- /dev/null
+++ b/docs/research/voice-remote-testing.md
@@ -0,0 +1,170 @@
+# Remote voice development testing
+
+Remote voice is enabled by default in desktop apps and headless engines.
+Real Mac/Fedora and physical iPhone acceptance is pending and will be performed
+by the user. Compilation and fake-provider tests
+are not evidence of subscription/media compatibility. No production rollout or
+server deployment is part of this change.
+
+## Desktop
+
+Start the execution host's new Zeron engine/app normally. No environment flag
+is required. Codex must already be installed and authenticated through
+ChatGPT on that host. It needs no audio helper, microphone or speaker. Continue
+using the existing registered device and account; do not register another host.
+
+The client (the device with the microphone) needs its own standalone Codex
+installation, version 0.159 or later, from the official installer: audio runs
+through that installation's `codex-voice-host` helper, on macOS, Linux and
+Windows alike. The client's Codex is resolved like the harness's (`CODEX_EXECUTABLE`,
+PATH, the login shell's PATH, known install locations); its credentials are not
+read. npm installations do not include the helper. Zeron packages contain no
+Codex runtime.
+
+```sh
+ZERON_DEV_BUILD_ONLY=1 ./scripts/run-macos-dev.sh
+```
+
+To test a client without Codex, or a specific helper build, set
+`ZERON_VOICE_MEDIA_DIR` to a runtime projected by
+`scripts/package-voice-runtime.py` (see [its notes](../../dist/voice/README.md)).
+It must be a `codex-resources/voice` directory containing `zeron-runtime.json`.
+
+Open `target/macos-dev/Zeron Dev.app`, select **Settings → Voice → Codex voice
+device**, choose the registered Fedora host and start voice from the sidebar orb.
+The microphone permission belongs to this Mac. Host choice is local to these UI
+settings and cannot change an active call. A host with an older build that does
+not advertise the remote voice capability is not eligible. Style is validated
+by the chosen host at Prepare.
+
+Desktop uses client-owned audio for both this device and a remote execution
+host. Only an explicit call opens the microphone; advertising the capability
+does not start audio capture. No transcript migration or credential transfer
+is needed.
+
+### Linux and Windows desktop clients
+
+They follow the same rule: the installed standalone Codex supplies the helper
+(`codex-voice-host` / `codex-voice-host.exe` with its `.so`/DLL tree). The Linux
+helper requires the host's glibc and ALSA libraries. On Windows, verify live that
+the `codex.exe` installed by `install.ps1` resolves inside its package (next to
+`codex-package.json`); otherwise voice reports `nativeRuntimeUnavailable`.
+
+Offline checks:
+
+```sh
+python3 -m unittest discover -s scripts/tests -p 'test_voice_packaging.py' -v
+cargo test --locked -p zeron-voice-media --lib
+```
+
+To check an actual projected runtime's initialization without opening audio
+devices or contacting a provider:
+
+```sh
+ZERON_VOICE_MEDIA_DIR=/absolute/path/to/codex-resources/voice \
+  cargo test --locked -p zeron-voice-media --lib \
+  packaged_native_runtime_initializes_without_audio_devices -- --ignored
+```
+
+On Windows set `$env:ZERON_VOICE_MEDIA_DIR` before the same Cargo command.
+Real microphone, playback, permissions, interruption and live-provider
+acceptance still need to be performed on each physical platform.
+
+## Acceptance checklist
+
+- Mac audio and Fedora Codex, including a host without an audio device/helper.
+- Bidirectional conversation, interruption, mute and immediate local hang-up.
+- Two successive calls and MCP delegation to a different provider, with return
+  messages addressed to the complete orchestrator chat ID.
+- One final transcript copy after sync; no active call or audio on other devices.
+- Host shutdown, owner disconnect, half-open connection and late callbacks.
+- Cancel while preparing/negotiating, then immediately start another call.
+- 20 start/stop cycles, one 15-minute call and devices on separate networks.
+- Open/reopen from Settings and drag the topbar; retain existing orb smoothing.
+
+Record versions, anonymized platform/network labels, observed outcomes and
+monotonic durations. Do not record SDP, tokens, audio or private transcript text.
+A failed negotiation should be investigated using the opt-in split-host smoke
+and its sanitized stages; it does not imply trying an API-key fallback.
+
+### Legal and privacy (blocks a public release)
+
+Owner decisions, not code; see the privacy/legal section of
+[codex-voice.md](codex-voice.md).
+
+- [ ] iOS consent: App Review guideline 5.1.2(i) requires disclosing that audio
+  is shared with a third-party AI (OpenAI) and explicit permission before the
+  first call. The microphone string discloses it; add an in-app consent step.
+- [ ] iOS privacy manifest and App Store privacy labels: decide whether audio sent
+  to OpenAI and synced voice transcripts are declared in `PrivacyInfo.xcprivacy`,
+  and keep App Store Connect consistent with it.
+- [ ] Zeron's public privacy policy and terms (outside this repository) describe
+  the OpenAI audio flow and transcript sync.
+- [ ] WebRTC's embedded third-party licenses (BoringSSL, libsrtp, Opus, libyuv,
+  Abseil and others) are generated from the pinned XCFramework and shipped
+  with the iOS app.
+
+## Automated coverage
+
+`voice-tests.yml` includes the new media/coordinator crates and default
+fake-provider remote-engine tests. These require no live provider or microphone.
+The new V2 controls travel over the existing relay and remain ephemeral; no audio
+frames or volume-meter stream are added to sync or the command ledger.
+
+## iOS
+
+Build the Rust core with `scripts/ios/build-core.sh iphonesimulator` (or `iphoneos`
+for a physical device). Open `apps/ios/Zeron.xcodeproj` and use the **Zeron** scheme.
+Sign a physical-device build using your existing development team. No Codex
+executable or OpenAI credentials are installed in the iOS app.
+
+Voice appears by itself once a registered execution host advertises
+`voice-client-media-v1` (all current engines advertise it; calls require
+authenticated Codex on the host); the `-remote-voice` launch argument still
+forces it on for development.
+Tap the waveform at the end of the **New session** bar to call the chosen host —
+or the only one online — and hold it to pick the host and voice. On iPad it sits
+beside compose in the sidebar toolbar. **More → Settings → Voice** keeps the same
+choices. Microphone permission is requested after checking the host capability.
+
+During a call the bar becomes a live strip (orb, clock, mute, hang-up) and an
+open session shows the live orb in its navigation bar; both open the full-screen
+stage. The stage has the desktop orb, caption, transcript button (marked when
+Codex is waiting for an answer) and mute/route/end. Mute and hang-up act locally
+first. Like a phone call: in hand audio plays on the loudspeaker, held to the ear
+the proximity sensor turns the screen off and moves it to the earpiece, and a
+headset or car route always wins. Locking the screen keeps the call (background
+audio); an interruption such as an incoming call ends it, without automatic
+restart. Losing a headset re-routes instead of ending the call.
+
+`-demo -voice-preview [-voice-stage]` (debug builds) plays a scripted call for
+screenshots and UI work without audio, host or relay.
+
+Offline iOS lifecycle tests (no microphone permission or provider):
+
+```sh
+scripts/ios/build-core.sh iphonesimulator
+ZERON_SKIP_CORE=1 xcodebuild -project apps/ios/Zeron.xcodeproj -scheme Zeron \
+  -destination 'platform=iOS Simulator,name=Zeron iPhone 17 Pro' \
+  ARCHS=arm64 ONLY_ACTIVE_ARCH=YES CODE_SIGN_IDENTITY=- \
+  -only-testing:ZeronTests/RemoteVoiceLifecycleTests test
+```
+
+Use an available ARM64 simulator name on your machine. The Rust build script
+currently creates an ARM64 simulator archive; a generic x86_64 simulator build
+cannot link that archive. Keep simulator ad-hoc signing enabled so it can launch.
+
+## Local validation record
+
+On macOS ARM64, the iOS simulator build and all six native lifecycle tests
+passed (including the shared orb frames). Rust tests cover incompatible hosts before permission, cancellation
+while an offer is stalled, a half-open heartbeat, local meters, owner drop,
+duplicate prepare/negotiation, late controls and bounded UniFFI callbacks.
+The full remote flow also passed with two engines over the WebSocket test relay
+and a fake Codex package whose audio helper was removed. The test checks that
+closing the owner releases the call without breaking the shared connection.
+
+Live sound, Wi-Fi/cellular behavior, Bluetooth, battery/CPU, latency, cross-network
+provider acceptance and real MCP delegation are still the user's acceptance tests.
+These live checks remain pending; default enablement does not establish that
+all of those environments have been verified.
diff --git a/scripts/codex-voice-probe.py b/scripts/codex-voice-probe.py
new file mode 100644
index 0000000000..f3f6a86879
--- /dev/null
+++ b/scripts/codex-voice-probe.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Bounded, read-only native Codex voice probe. Never starts inference/audio."""
+import asyncio
+import json
+import shutil
+
+METHODS = (
+    ("initialize", {"clientInfo": {"name": "zeron-voice-probe", "version": "1"},
+                    "capabilities": {"experimentalApi": True}}),
+    ("account/read", {"refreshToken": False}),
+    ("account/rateLimits/read", {}),
+    ("thread/realtime/listVoices", {}),
+)
+
+async def probe():
+    executable = shutil.which("codex")
+    if not executable:
+        raise RuntimeError("Codex is not installed")
+    child = await asyncio.create_subprocess_exec(
+        executable, "app-server", stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+        limit=256 * 1024)
+    pending = {}
+
+    async def read():
+        try:
+            while line := await child.stdout.readline():
+                message = json.loads(line)
+                future = pending.get(message.get("id"))
+                if future and not future.done():
+                    future.set_result(message)
+        finally:
+            for future in pending.values():
+                if not future.done():
+                    future.set_exception(RuntimeError("Codex stdout closed"))
+
+    reader = asyncio.create_task(read())
+    result = {}
+    try:
+        for identifier, (method, params) in enumerate(METHODS, 1):
+            future = asyncio.get_running_loop().create_future()
+            pending[identifier] = future
+            child.stdin.write((json.dumps({"id": identifier, "method": method,
+                                         "params": params}) + "\n").encode())
+            await child.stdin.drain()
+            try:
+                message = await asyncio.wait_for(future, timeout=8)
+            finally:
+                pending.pop(identifier, None)
+            # Expose only successful method support and account type. Never
+            # print raw errors, account identifiers, balances, tokens or audio.
+            result[method] = {"supported": "result" in message}
+            if method == "account/read":
+                account = (message.get("result") or {}).get("account") or {}
+                kind = account.get("type")
+                result[method]["chatgpt"] = kind == "chatgpt" if kind else None
+        result["creditExclusionVerified"] = False
+        print(json.dumps(result, indent=2))
+    finally:
+        reader.cancel()
+        await asyncio.gather(reader, return_exceptions=True)
+        if child.returncode is None:
+            try:
+                child.terminate()
+            except ProcessLookupError:
+                pass
+            try:
+                await asyncio.wait_for(child.wait(), 2)
+            except asyncio.TimeoutError:
+                child.kill()
+                await child.wait()
+
+if __name__ == "__main__":
+    asyncio.run(probe())
diff --git a/scripts/codex-voice-remote-smoke.py b/scripts/codex-voice-remote-smoke.py
new file mode 100644
index 0000000000..1e97e75424
--- /dev/null
+++ b/scripts/codex-voice-remote-smoke.py
@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""Split-host voice diagnostic. Offline tests never start Codex or audio.
+
+Live mode uses an explicit local helper and Codex app-server over SSH. Only
+sanitized stage/counter results are printed; no SDP, transcript or raw errors.
+This diagnostic does not use Zeron's production relay or certify its MCP routing.
+"""
+import argparse
+import asyncio
+import contextlib
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import shlex
+import struct
+import sys
+import uuid
+
+MAX_SDP = 64 * 1024
+MAX_FRAME = 128 * 1024
+MAX_RPC = 1024 * 1024
+
+
+class ProbeError(Exception):
+    """A fixed diagnostic code, never a provider's error message."""
+
+
+def validate_sdp(value):
+    if not isinstance(value, str) or not 0 < len(value.encode()) <= MAX_SDP:
+        raise ProbeError('invalid_sdp')
+    lines = value.replace('\r\n', '\n').splitlines()
+    if not lines or lines[0] != 'v=0' or not any(x.startswith('m=audio ') for x in lines):
+        raise ProbeError('invalid_sdp')
+    return value
+
+
+def helper_environment():
+    # Match the harness allowlist. In particular, no API key or loader overrides.
+    allowed = {'HOME', 'USERPROFILE', 'SYSTEMROOT', 'WINDIR', 'TEMP', 'TMP',
+               'TMPDIR', 'XDG_RUNTIME_DIR', 'PULSE_SERVER', 'PULSE_COOKIE',
+               'PIPEWIRE_REMOTE', 'DBUS_SESSION_BUS_ADDRESS', 'HTTP_PROXY',
+               'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY', 'SSL_CERT_FILE',
+               'SSL_CERT_DIR', 'REQUESTS_CA_BUNDLE', 'CURL_CA_BUNDLE'}
+    env = {k: v for k, v in os.environ.items() if k.upper() in allowed}
+    for name in ('GST_PLUGIN_PATH', 'GST_PLUGIN_PATH_1_0',
+                 'GST_PLUGIN_SYSTEM_PATH', 'GST_PLUGIN_SYSTEM_PATH_1_0'):
+        env[name] = ''
+    env.update(GST_REGISTRY=os.devnull, GST_REGISTRY_UPDATE='no', GST_REGISTRY_FORK='no')
+    return env
+
+
+def ssh_command(host, argv):
+    if not host or host.startswith('-') or not re.fullmatch(r'[\w.@:-]+', host):
+        raise ProbeError('invalid_ssh_host')
+    # SSH accepts one remote shell command, so quote each argument for that shell.
+    return ['ssh', '-T', '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8',
+            host, 'exec ' + shlex.join(argv)]
+
+
+async def spawn(argv, **kwargs):
+    return await asyncio.create_subprocess_exec(
+        *argv, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.DEVNULL, limit=MAX_RPC, **kwargs)
+
+
+async def reap(child):
+    if child.returncode is None:
+        with contextlib.suppress(ProcessLookupError):
+            child.terminate()
+        try:
+            await asyncio.wait_for(child.wait(), 2)
+        except asyncio.TimeoutError:
+            with contextlib.suppress(ProcessLookupError):
+                child.kill()
+            await child.wait()
+
+
+async def metadata(argv, pattern, **kwargs):
+    child = await spawn(argv, **kwargs)
+    try:
+        # Bounded read, not communicate(): an unexpected program cannot fill RAM.
+        data = await asyncio.wait_for(child.stdout.read(513), 8)
+        await asyncio.wait_for(child.wait(), 2)
+        value = data.decode().strip()
+        if child.returncode != 0 or len(data) > 512 or not re.fullmatch(pattern, value):
+            raise ProbeError('invalid_build_metadata')
+        return value
+    finally:
+        await reap(child)
+
+
+class Helper:
+    def __init__(self, child, timeout=20):
+        self.child = child
+        self.timeout = timeout
+        self.broken = False
+
+    async def exchange(self, message, expected):
+        async def operation():
+            payload = json.dumps(message).encode()
+            if len(payload) > MAX_FRAME:
+                raise ProbeError('helper_frame_overflow')
+            self.child.stdin.write(struct.pack('>I', len(payload)) + payload)
+            await self.child.stdin.drain()
+            size = struct.unpack('>I', await self.child.stdout.readexactly(4))[0]
+            if not 0 < size <= MAX_FRAME:
+                raise ProbeError('helper_frame_overflow')
+            reply = json.loads(await self.child.stdout.readexactly(size))
+            if not isinstance(reply, dict) or reply.get('type') != expected:
+                raise ProbeError('helper_protocol')
+            return reply
+        if self.broken:
+            raise ProbeError('helper_closed')
+        try:
+            return await asyncio.wait_for(operation(), self.timeout)
+        except BaseException:
+            # Never reuse a pipe after a timed-out/cancelled partial frame.
+            self.broken = True
+            await reap(self.child)
+            raise
+
+
+class Server:
+    def __init__(self, child, timeout=30):
+        self.child = child
+        self.timeout = timeout
+        self.pending = {}
+        self.sequence = 0
+        self.events = asyncio.Queue(128)
+        self.failure = None
+        self.reader = asyncio.create_task(self.read())
+
+    async def read(self):
+        code = 'server_closed'
+        try:
+            while line := await self.child.stdout.readline():
+                frame = json.loads(line)
+                if not isinstance(frame, dict):
+                    raise ProbeError('server_protocol')
+                future = self.pending.get(frame.get('id'))
+                if future is not None:
+                    if not future.done():
+                        future.set_result(frame)
+                elif 'id' in frame and 'method' in frame:
+                    # Never auto-approve an interactive tool or permission request.
+                    await self.send({'id': frame['id'], 'error': {
+                        'code': -32601, 'message': 'Diagnostic does not handle server requests'}})
+                elif frame.get('method', '').startswith('thread/realtime/'):
+                    self.events.put_nowait(frame)
+        except asyncio.CancelledError:
+            raise
+        except asyncio.QueueFull:
+            code = 'event_overflow'
+        except Exception:
+            code = 'server_protocol'
+        finally:
+            self.failure = code
+            for future in self.pending.values():
+                if not future.done():
+                    future.set_exception(ProbeError(code))
+            # Wake a notification waiter even when the queue had filled.
+            if self.events.full():
+                self.events.get_nowait()
+            self.events.put_nowait(None)
+
+    async def send(self, message):
+        self.child.stdin.write((json.dumps(message) + '\n').encode())
+        await self.child.stdin.drain()
+
+    async def request(self, method, params):
+        if self.failure:
+            raise ProbeError(self.failure)
+        self.sequence += 1
+        identifier = self.sequence
+        future = asyncio.get_running_loop().create_future()
+        self.pending[identifier] = future
+        try:
+            async def operation():
+                await self.send({'id': identifier, 'method': method, 'params': params})
+                frame = await future
+                if 'error' in frame or 'result' not in frame:
+                    raise ProbeError('request_rejected')
+                return frame['result']
+            return await asyncio.wait_for(operation(), self.timeout)
+        finally:
+            self.pending.pop(identifier, None)
+
+    async def event(self):
+        if self.failure:
+            raise ProbeError(self.failure)
+        event = await self.events.get()
+        if event is None:
+            raise ProbeError(self.failure or 'server_closed')
+        return event
+
+    async def close(self):
+        self.reader.cancel()
+        await asyncio.gather(self.reader, return_exceptions=True)
+        await reap(self.child)
+
+
+class Observation:
+    def __init__(self, thread, session):
+        self.thread = thread
+        self.session = session
+        self.started = False
+        self.answer = None
+        self.finals = set()
+        self.counts = {'userFinals': 0, 'assistantFinals': 0, 'handoffPromotions': 0}
+
+    def accept(self, frame):
+        p = frame.get('params') or {}
+        if p.get('threadId') != self.thread:
+            return
+        if p.get('realtimeSessionId', self.session) != self.session:
+            return
+        method = frame.get('method')
+        if method == 'thread/realtime/started':
+            if p.get('realtimeSessionId') != self.session or p.get('version') != 'v3':
+                raise ProbeError('session_mismatch')
+            self.started = True
+        elif method == 'thread/realtime/sdp':
+            answer = validate_sdp(p.get('sdp'))
+            if self.answer is not None and self.answer != answer:
+                raise ProbeError('conflicting_answer')
+            self.answer = answer
+        elif method in ('thread/realtime/closed', 'thread/realtime/error'):
+            raise ProbeError('provider_closed')
+        elif method == 'thread/realtime/item/completed':
+            item = p.get('item') or {}
+            if item.get('realtimeSessionId') != self.session or not isinstance(item.get('id'), str):
+                return
+            key = item['id']
+            if key in self.finals:
+                return
+            if len(self.finals) >= 4096:
+                raise ProbeError('item_overflow')
+            self.finals.add(key)
+            if item.get('type') == 'transcriptSegment' and item.get('role') in ('user', 'assistant'):
+                self.counts[item['role'] + 'Finals'] += 1
+            elif item.get('type') == 'bemItemPromoted':
+                self.counts['handoffPromotions'] += 1
+
+    async def negotiate(self, server, timeout=90):
+        async def wait():
+            while not (self.started and self.answer is not None):
+                self.accept(await server.event())
+            # Catch a close already queued alongside the two successful events.
+            while not server.events.empty():
+                self.accept(await server.event())
+            return self.answer
+        return await asyncio.wait_for(wait(), timeout)
+
+
+async def exercise(server, helper, build, cwd, report, seconds=0):
+    """One fresh provider thread: no cross-generation SDP without session IDs."""
+    thread = None
+    started = False
+    try:
+        report['stage'] = 'initialize'
+        await server.request('initialize', {
+            'clientInfo': {'name': 'zeron-voice-remote-smoke', 'version': '1'},
+            'capabilities': {'experimentalApi': True}})
+        await server.send({'method': 'initialized'})
+        account = await server.request('account/read', {'refreshToken': False})
+        if (account.get('account') or {}).get('type') != 'chatgpt':
+            raise ProbeError('chatgpt_required')
+        config = (await server.request('config/read', {'includeLayers': False, 'cwd': cwd}))['config']
+        if (config.get('model_provider') not in (None, 'openai')
+                or config.get('model_providers', {}).get('openai')
+                or any(config.get(k) for k in ('experimental_realtime_ws_base_url',
+                       'experimental_realtime_webrtc_call_base_url', 'experimental_realtime_ws_model'))):
+            raise ProbeError('custom_provider')
+        await server.request('thread/realtime/listVoices', {})
+        report['voicesBeforeThread'] = True
+        report['stage'] = 'local_runtime'
+        await helper.exchange({'type': 'hello', 'protocol': 1, 'buildCommit': build}, 'ready')
+        await helper.exchange({'type': 'initializeRuntime'}, 'runtimeReady')
+        offer = await helper.exchange({'type': 'startTransport'}, 'offer')
+        sdp = validate_sdp(offer.get('sdp'))
+        result = await server.request('thread/start', {
+            'ephemeral': True, 'cwd': cwd, 'approvalPolicy': 'never', 'sandbox': 'read-only',
+            'developerInstructions': 'Voice connectivity diagnostic. Stay silent until spoken to. Do not use tools.'})
+        thread = result['thread']['id']
+        if result.get('modelProvider') != 'openai':
+            raise ProbeError('custom_provider')
+        observation = Observation(thread, str(uuid.uuid4()))
+        report['stage'] = 'negotiate'
+        # Stop even if the start reply is lost after reaching the provider.
+        started = True
+        await server.request('thread/realtime/start', {
+            'threadId': thread, 'transport': {'type': 'webrtc', 'sdp': sdp},
+            'version': 'v3', 'realtimeSessionId': observation.session,
+            'outputModality': 'audio', 'clientManagedHandoffs': False,
+            'includeStartupContext': True})
+        answer = await observation.negotiate(server)
+        await helper.exchange({'type': 'applyAnswer', 'sdp': answer}, 'transportReady')
+        report['transportReady'] = True
+        report['stage'] = 'observe'
+        if seconds:
+            await helper.exchange({'type': 'openDevices'}, 'devicesOpened')
+            await helper.exchange({'type': 'setAudioControls', 'controls': {
+                'microphoneMuted': True, 'speakerSuppressed': True}}, 'audioControlsApplied')
+            report['muteControlAccepted'] = True
+            await helper.exchange({'type': 'setAudioControls', 'controls': {
+                'microphoneMuted': False, 'speakerSuppressed': False}}, 'audioControlsApplied')
+            report['devicesOpened'] = True
+            print('Audio local activo durante la prueba; habla para verificar la respuesta.', file=sys.stderr)
+        deadline = asyncio.get_running_loop().time() + (seconds or 1)
+        while (remaining := deadline - asyncio.get_running_loop().time()) > 0:
+            try:
+                event = await asyncio.wait_for(server.event(), min(remaining, 0.25))
+                observation.accept(event)
+            except asyncio.TimeoutError:
+                pass
+        report.update(observation.counts)
+        if seconds:
+            report['bidirectionalFinalsObserved'] = all(
+                observation.counts[key] > 0 for key in ('userFinals', 'assistantFinals'))
+        report['stage'] = 'stop'
+    finally:
+        # Local audio closes first, including after cancellation or lost control.
+        if not helper.broken:
+            try:
+                await asyncio.wait_for(helper.exchange({'type': 'close'}, 'closed'), 3)
+                report['localClosed'] = True
+            except Exception:
+                report['localClosed'] = False
+        await reap(helper.child)
+        if started:
+            try:
+                await asyncio.wait_for(server.request('thread/realtime/stop', {'threadId': thread}), 8)
+                report['stopAcknowledged'] = True
+                async def closed():
+                    while True:
+                        event = await server.event()
+                        if (event.get('method') == 'thread/realtime/closed'
+                                and event.get('params', {}).get('threadId') == thread
+                                and event['params'].get('reason') == 'requested'):
+                            return
+                await asyncio.wait_for(closed(), 3)
+                report['providerClosed'] = True
+            except Exception:
+                report.setdefault('stopAcknowledged', False)
+                report['providerClosed'] = False
+
+
+async def live(args):
+    report = {'mode': 'split-host', 'gateG0Passed': False,
+              'mcpRoutingVerified': False, 'localPlatform': platform.system() + ' ' + platform.machine()}
+    children = []
+    server = None
+    try:
+        report['stage'] = 'metadata'
+        helper_path = Path(args.helper).resolve(strict=True)
+        env = helper_environment()
+        build = await metadata([str(helper_path), '--build-commit'], r'[a-zA-Z0-9._-]{1,128}', env=env)
+        report['helperBuild'] = build
+        report['remoteCodex'] = await metadata(
+            ssh_command(args.ssh_host, ['env', '-u', 'OPENAI_API_KEY', args.remote_codex, '--version']),
+            r'codex(?:-cli)? [0-9][a-zA-Z0-9.+_-]{0,100}')
+        report['remotePlatform'] = await metadata(ssh_command(args.ssh_host, ['uname', '-sm']),
+                                                 r'[a-zA-Z0-9 _.-]{1,100}')
+        child = await spawn([str(helper_path)], env=env, cwd=str(helper_path.parent))
+        children.append(child)
+        remote = await spawn(ssh_command(args.ssh_host, [
+            'env', '-u', 'OPENAI_API_KEY', args.remote_codex, 'app-server']))
+        children.append(remote)
+        server = Server(remote)
+        await exercise(server, Helper(child), build, args.remote_cwd, report,
+                       args.seconds if args.devices else 0)
+        report['ok'] = (report.get('localClosed', False) and report.get('providerClosed', False)
+                        and (not args.devices or report.get('bidirectionalFinalsObserved', False)))
+    except ProbeError as error:
+        report.update(ok=False, error=str(error))
+    except asyncio.TimeoutError:
+        report.update(ok=False, error='timeout')
+    except asyncio.CancelledError:
+        report.update(ok=False, error='cancelled')
+    except Exception:
+        report.update(ok=False, error='io_or_protocol')
+    finally:
+        if server:
+            await server.close()
+        for child in reversed(children):
+            await reap(child)
+        print(json.dumps(report, indent=2))
+    return 0 if report.get('ok') else 1
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--live', action='store_true', help='Use real subscription voice on the named host')
+    parser.add_argument('--ssh-host', required=True, help='Explicit configured SSH host; no discovery')
+    parser.add_argument('--remote-codex', required=True, help='Absolute Codex executable path on the host')
+    parser.add_argument('--remote-cwd', required=True, help='Absolute existing directory on the host')
+    parser.add_argument('--helper', required=True, help='Explicit local codex-voice-host; no local CLI lookup')
+    parser.add_argument('--devices', action='store_true', help='Open LOCAL microphone/speaker for a bounded conversation')
+    parser.add_argument('--seconds', type=int, default=30, help='Conversation duration, 1–120 seconds')
+    args = parser.parse_args()
+    if not args.live:
+        parser.error('--live is required; offline: python3 -m unittest discover -s scripts/tests -p "test_voice_remote*.py"')
+    if not 1 <= args.seconds <= 120:
+        parser.error('--seconds must be between 1 and 120')
+    if not all(x.startswith('/') for x in (args.remote_codex, args.remote_cwd, args.helper)):
+        parser.error('Codex, helper and cwd must be absolute paths')
+    return asyncio.run(live(args))
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/scripts/codex-voice-smoke.py b/scripts/codex-voice-smoke.py
new file mode 100644
index 0000000000..bf33e88c3f
--- /dev/null
+++ b/scripts/codex-voice-smoke.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Explicit live, subscription WebRTC connectivity check. No microphone/device opens.
+This can consume normal Codex voice usage. Offline CI must never invoke --live.
+SDP, account details, native errors and media are never printed or persisted.
+"""
+import argparse, asyncio, json, os, pathlib, shutil, struct, uuid
+async def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--live',action='store_true',help='Authorize a short real Codex voice call using normal plan usage')
+    parser.add_argument('--devices',action='store_true',help='Also open default audio devices with microphone muted and play a short greeting')
+    args=parser.parse_args()
+    if not args.live:parser.error('Pass --live explicitly; use codex-voice-probe.py for read-only discovery')
+    binary=pathlib.Path(shutil.which('codex') or '').resolve()
+    root=binary.parent.parent
+    helper=root/'codex-resources/voice/bin/codex-voice-host'
+    if not helper.is_file():raise RuntimeError('packaged native runtime unavailable')
+    children=[];pending={};notifications=asyncio.Queue(32);reader=None;thread=None;server=None
+    result={'chatgpt':False,'helperReady':False,'transportReady':False,'microphoneOpened':False,'apiFallback':False}
+    stage='helper'
+    async def stop(child):
+        if child.returncode is None:
+            child.terminate()
+            try:await asyncio.wait_for(child.wait(),3)
+            except asyncio.TimeoutError:child.kill();await child.wait()
+    async def exchange(host,v):
+        p=json.dumps(v).encode();host.stdin.write(struct.pack('>I',len(p))+p);await host.stdin.drain()
+        n=struct.unpack('>I',await host.stdout.readexactly(4))[0]
+        if not 0<n<=128*1024:raise RuntimeError('invalid helper frame')
+        return json.loads(await host.stdout.readexactly(n))
+    async def request(method,params):
+        identifier=len(pending)+1+request.counter;request.counter+=1
+        f=asyncio.get_running_loop().create_future();pending[identifier]=f
+        server.stdin.write((json.dumps({'id':identifier,'method':method,'params':params})+'\n').encode());await server.stdin.drain()
+        try:
+            v=await asyncio.wait_for(f,25)
+            if 'error' in v:raise RuntimeError('native request rejected')
+            return v['result']
+        finally:pending.pop(identifier,None)
+    request.counter=0
+    try:
+        environment={k:v for k,v in os.environ.items() if k.upper() not in ('OPENAI_API_KEY','LD_PRELOAD','LD_LIBRARY_PATH','GST_PLUGIN_PATH','GST_PLUGIN_SYSTEM_PATH')}
+        environment.update(GST_PLUGIN_PATH='',GST_PLUGIN_PATH_1_0='',GST_PLUGIN_SYSTEM_PATH='',GST_PLUGIN_SYSTEM_PATH_1_0='',GST_REGISTRY='/dev/null',GST_REGISTRY_UPDATE='no',GST_REGISTRY_FORK='no')
+        for directory in ('/usr/lib/x86_64-linux-gnu/alsa-lib','/usr/lib64/alsa-lib','/usr/lib/alsa-lib'):
+            if pathlib.Path(directory).is_dir():environment['ALSA_PLUGIN_DIR']=directory;break
+        commit_child=await asyncio.create_subprocess_exec(str(helper),'--build-commit',stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.DEVNULL,env=environment)
+        children.append(commit_child)
+        commit=(await commit_child.communicate())[0].decode().strip()
+        host=await asyncio.create_subprocess_exec(str(helper),stdin=asyncio.subprocess.PIPE,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.DEVNULL,env=environment)
+        children.append(host)
+        assert (await exchange(host,{'type':'hello','protocol':1,'buildCommit':commit}))['type']=='ready'
+        assert (await exchange(host,{'type':'initializeRuntime'}))['type']=='runtimeReady'
+        result['helperReady']=True
+        offer=await exchange(host,{'type':'startTransport'})
+        assert offer['type']=='offer'
+        stage='auth'
+        server=await asyncio.create_subprocess_exec(str(binary),'app-server',stdin=asyncio.subprocess.PIPE,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.DEVNULL,env=environment,limit=8*1024*1024)
+        children.append(server)
+        async def read():
+            while line:=await server.stdout.readline():
+                v=json.loads(line)
+                if v.get('id') in pending:
+                    f=pending[v['id']]
+                    if not f.done():f.set_result(v)
+                elif v.get('method','').startswith('thread/realtime/'):
+                    notifications.put_nowait(v)
+        reader=asyncio.create_task(read())
+        await request('initialize',{'clientInfo':{'name':'zeron-voice-smoke','version':'1'},'capabilities':{'experimentalApi':True}})
+        server.stdin.write(b'{"method":"initialized"}\n');await server.stdin.drain()
+        account=await request('account/read',{'refreshToken':False})
+        assert account.get('account',{}).get('type')=='chatgpt';result['chatgpt']=True
+        config=(await request('config/read',{'includeLayers':False,'cwd':str(pathlib.Path.cwd())}))['config']
+        assert config.get('model_provider','openai') in ('openai',None)
+        assert not config.get('model_providers',{}).get('openai')
+        assert not any(config.get(k) for k in ('experimental_realtime_ws_base_url','experimental_realtime_webrtc_call_base_url','experimental_realtime_ws_model'))
+        started=await request('thread/start',{'ephemeral':True,'cwd':str(pathlib.Path.cwd()),'approvalPolicy':'never','sandbox':'read-only','developerInstructions':'Connectivity check. Do not use tools or perform tasks. Stay silent until user speech.'})
+        thread=started['thread']['id']
+        assert started['modelProvider']=='openai'
+        stage='nativeCall'
+        session=str(uuid.uuid4())
+        await request('thread/realtime/start',{'threadId':thread,'transport':{'type':'webrtc','sdp':offer['sdp']},'version':'v3','realtimeSessionId':session,'outputModality':'audio','clientManagedHandoffs':False,'includeStartupContext':False})
+        accepted=False;answer=None
+        while not (accepted and answer):
+            v=await asyncio.wait_for(notifications.get(),30)
+            if v['method']=='thread/realtime/started':assert v['params']['version']=='v3';accepted=True
+            elif v['method']=='thread/realtime/sdp':answer=v['params']['sdp']
+            elif v['method'] in ('thread/realtime/error','thread/realtime/closed'):raise RuntimeError('native call failed')
+        stage='applyAnswer'
+        assert (await exchange(host,{'type':'applyAnswer','sdp':answer}))['type']=='transportReady'
+        result['transportReady']=True
+        if args.devices:
+            stage='audioDevices'
+            assert (await exchange(host,{'type':'openDevices'}))['type']=='devicesOpened'
+            result['devicesOpened']=True
+            assert (await exchange(host,{'type':'setAudioControls','controls':{'microphoneMuted':True,'speakerSuppressed':False}}))['type']=='audioControlsApplied'
+            result['microphoneMuted']=True
+            stage='playout'
+            await request('thread/realtime/appendSpeech',{'threadId':thread,'text':'Hola.'})
+            for _ in range(60):
+                audio=await exchange(host,{'type':'inspectAudio'})
+                if audio['state']['speakerPeak']>0:result['speakerAudioReceived']=True;break
+                await asyncio.sleep(0.1)
+            if not result.get('speakerAudioReceived'):raise RuntimeError('no playout observed')
+        else:
+            await asyncio.sleep(1)
+        stage='stop'
+        await request('thread/realtime/stop',{'threadId':thread});thread=None
+        assert (await exchange(host,{'type':'close'}))['type']=='closed'
+        await asyncio.wait_for(host.wait(),3)
+        result['stopped']=True
+    except Exception:
+        result['failedStage']=stage
+    finally:
+        if server and thread:
+            try:await request('thread/realtime/stop',{'threadId':thread})
+            except Exception:pass
+        if reader:reader.cancel();await asyncio.gather(reader,return_exceptions=True)
+        for child in reversed(children):await stop(child)
+        print(json.dumps(result,indent=2))
+if __name__=='__main__':asyncio.run(asyncio.wait_for(main(),120))
diff --git a/scripts/package-linux.sh b/scripts/package-linux.sh
index 8fe6ba27b2..454f7769bb 100755
--- a/scripts/package-linux.sh
+++ b/scripts/package-linux.sh
@@ -33,6 +33,7 @@ mkdir -p "$STAGE"
 install -m 755 "$BIN" "$STAGE/zeron"
 install -m 644 "$ROOT/dist/zeron.desktop" "$STAGE/zeron.desktop"
 install -m 644 "$ROOT/dist/zeron.png" "$STAGE/zeron.png"
+install -m 644 "$ROOT/LICENSE" "$ROOT/THIRD_PARTY_NOTICES.md" "$STAGE/"
 mkdir -p "$STAGE/licenses/fonts"
 cp "$ROOT/crates/ui/assets/fonts/licenses/"* "$STAGE/licenses/fonts/"
 cp "$ROOT/crates/voice/NOTICE.md" "$STAGE/licenses/parakeet-v3.txt"
diff --git a/scripts/package-macos.sh b/scripts/package-macos.sh
index 8adec844c1..929b0ca3a5 100755
--- a/scripts/package-macos.sh
+++ b/scripts/package-macos.sh
@@ -30,6 +30,7 @@ install -m 755 "$ROOT/target/release/zeron" "$APP/Contents/MacOS/zeron"
 sed "s/__VERSION__/$VERSION/" "$ROOT/dist/macos/Info.plist" >"$APP/Contents/Info.plist"
 mkdir -p "$APP/Contents/Resources/licenses/fonts"
 cp "$ROOT/crates/ui/assets/fonts/licenses/"* "$APP/Contents/Resources/licenses/fonts/"
+cp "$ROOT/THIRD_PARTY_NOTICES.md" "$ROOT/LICENSE" "$APP/Contents/Resources/licenses/"
 
 mkdir -p "$APP/Contents/Resources/licenses"
 cp "$ROOT/crates/voice/NOTICE.md" "$APP/Contents/Resources/licenses"/parakeet-v3.txt
@@ -54,7 +55,7 @@ if [[ -n "${CODESIGN_IDENTITY:-}" ]]; then
 else
   # Ad-hoc signature so the app launches on Apple silicon (Gatekeeper still
   # requires right-click → Open on first launch without notarization).
-  codesign --deep --force --sign - "$APP"
+  codesign --deep --force --entitlements "$ROOT/dist/macos/voice.entitlements" --sign - "$APP"
 fi
 
 # notarize <path>: submit to Apple and wait for the verdict. A rejection may
diff --git a/scripts/package-voice-runtime.py b/scripts/package-voice-runtime.py
new file mode 100644
index 0000000000..1e7f495ba3
--- /dev/null
+++ b/scripts/package-voice-runtime.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Package the pinned native voice runtime without installing or copying the CLI."""
+import argparse
+import hashlib
+import json
+from pathlib import Path, PurePosixPath, PureWindowsPath
+import platform
+import shutil
+import subprocess
+import tempfile
+import tarfile
+import urllib.request
+
+BUILD = 'a956835d020762cb2b570053af06f643a11c0ecc'
+VERSION = '0.160.0'
+PACKAGES = {
+    'aarch64-apple-darwin': ('aarch64-apple-darwin', None),
+    'x86_64-unknown-linux-gnu': ('x86_64-unknown-linux-musl', '4fcc47ab57f52ff75363951a8761146cd10c8288bd86fed45487dbb204a16b71'),
+    'aarch64-unknown-linux-gnu': ('aarch64-unknown-linux-musl', '7f0fe42ff22ecfa3a47bc4a34f5b22c4218b431a4ec0aba51c7d98299f07900c'),
+    'x86_64-pc-windows-msvc': ('x86_64-pc-windows-msvc', '7f7fbbc8d6fd4ea2f3b13855ef47ea59663ba7e61fb2e9821df37163b8030891'),
+    'aarch64-pc-windows-msvc': ('aarch64-pc-windows-msvc', '0bb6ecbad9c2f5d352ad539bbe43d627b32453bad1d61e5315ec9868f78e1b3c'),
+}
+
+
+def host_target():
+    arch = {'amd64': 'x86_64', 'arm64': 'aarch64'}.get(platform.machine().lower(), platform.machine().lower())
+    suffix = {'Darwin': 'apple-darwin', 'Linux': 'unknown-linux-gnu', 'Windows': 'pc-windows-msvc'}.get(platform.system())
+    target = f'{arch}-{suffix}'
+    if target not in PACKAGES:
+        raise ValueError(f'unsupported voice target: {target}')
+    return target
+
+
+def relative_path(name):
+    path = PurePosixPath(name)
+    if (not name or '\\' in name or ':' in name or path.is_absolute()
+            or PureWindowsPath(name).drive or '..' in path.parts or path.as_posix() != name
+            or name == '.'):
+        raise ValueError('invalid manifest path')
+    return Path(*path.parts)
+
+
+def checksum(path):
+    with path.open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def download_package(directory, target):
+    app_target, digest = PACKAGES[target]
+    if digest is None:
+        raise ValueError('supply an explicit source package for macOS')
+    name = f'codex-package-{app_target}.tar.gz'
+    archive = directory / name
+    url = f'https://github.com/openai/codex/releases/download/rust-v{VERSION}/{name}'
+    # Only the build machine downloads this fixed, checksum-pinned release.
+    with urllib.request.urlopen(url, timeout=120) as response, archive.open('wb') as output:
+        shutil.copyfileobj(response, output)
+    if checksum(archive) != digest:
+        raise ValueError('voice archive checksum mismatch')
+    package = directory / 'package'
+    package.mkdir()
+    with tarfile.open(archive) as source:
+        source.extractall(package, filter='data')
+    return package
+
+
+def install(package, destination, target=None):
+    target = target or host_target()
+    app_target, _ = PACKAGES[target]
+    # The helper only initializes from a `codex-resources/voice` directory; it
+    # exits with code 23 on initializeRuntime anywhere else.
+    if (destination.parent.name, destination.name) != ('codex-resources', 'voice'):
+        raise ValueError('destination must end in codex-resources/voice')
+    metadata = json.loads((package / 'codex-package.json').read_text())
+    if (metadata['layoutVersion'], metadata['version'], metadata['target']) != (1, VERSION, app_target):
+        raise ValueError('unsupported Codex package layout, version or target')
+    source = package / 'codex-resources/voice'
+    manifest = json.loads((source / 'manifest.json').read_text())
+    if (manifest['buildCommit'], manifest['appVersion'], manifest['appTarget'], manifest['voiceTarget']) != (BUILD, VERSION, app_target, target):
+        raise ValueError(f'unsupported voice package; expected pinned {VERSION} {target}')
+    for relative, digest in manifest['sha256'].items():
+        path = package / relative_path(relative)
+        if checksum(path) != digest:
+            raise ValueError('voice package checksum mismatch')
+    # Reject untracked runtime files and symlinks before signing/copying code.
+    for path in source.rglob('*'):
+        if path.is_symlink():
+            raise ValueError('voice runtime symlinks are unsupported')
+        if path.is_file() and path.name != 'manifest.json' and path.relative_to(package).as_posix() not in manifest['sha256']:
+            raise ValueError('untracked runtime resource')
+    helper = 'bin/codex-voice-host' + ('.exe' if target.endswith('windows-msvc') else '')
+    for required in [helper, 'runtime.json', 'NOTICE.md', 'sources.json']:
+        if not (source / required).is_file():
+            raise ValueError(f'missing runtime resource: {required}')
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(dir=destination.parent) as temporary:
+        stage = Path(temporary) / 'voice'
+        shutil.copytree(source, stage)
+        shutil.copyfile(Path(__file__).resolve().parents[1] / "dist/voice/Codex-LICENSE.txt", stage / "licenses/Codex-LICENSE.txt")
+        # Ship the runtime byte-for-byte: upstream already signs the helper and
+        # every library with OpenAI's Developer ID, hardened runtime and a
+        # secure timestamp, so re-signing would only downgrade them.
+        runtime = json.loads((stage / 'runtime.json').read_text())
+        if (runtime['target'], runtime['sourceCommit']) != (target, BUILD):
+            raise ValueError('incompatible native runtime')
+        for library in runtime['libraries']:
+            if checksum(stage / relative_path(library['path'])) != library['sha256']:
+                raise ValueError(f"runtime library does not match runtime.json: {library['path']}")
+        if target.endswith('apple-darwin'):
+            for path in sorted(stage.rglob('*')):
+                if path.is_file() and (path.suffix == '.dylib' or path.name == 'codex-voice-host'):
+                    subprocess.run(['codesign', '--verify', '--strict', str(path)], check=True)
+        hashes = {p.relative_to(stage).as_posix(): checksum(p)
+                  for p in sorted(stage.rglob('*')) if p.is_file()}
+        (stage / 'zeron-runtime.json').write_text(json.dumps({
+            'protocol': 1, 'buildCommit': BUILD, 'sourceVersion': VERSION,
+            'target': target, 'sha256': hashes}, indent=2) + '\n')
+        if destination.exists():
+            shutil.rmtree(destination)
+        shutil.move(str(stage), destination)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    inputs = parser.add_mutually_exclusive_group(required=True)
+    inputs.add_argument('--package', type=Path, help='explicit standalone Codex package directory')
+    inputs.add_argument('--download', action='store_true', help='download the checksum-pinned source package on the build machine')
+    parser.add_argument('--target', choices=PACKAGES, help='media target; defaults to the build machine')
+    parser.add_argument('--destination', type=Path, required=True)
+    args = parser.parse_args()
+    target = args.target or host_target()
+    if args.download:
+        with tempfile.TemporaryDirectory(prefix='zeron-voice-package-') as temporary:
+            package = download_package(Path(temporary), target)
+            install(package, args.destination.resolve(), target)
+    else:
+        install(args.package.resolve(), args.destination.resolve(), target)
diff --git a/scripts/package-windows.ps1 b/scripts/package-windows.ps1
index 77b40b4364..4c5e12211d 100644
--- a/scripts/package-windows.ps1
+++ b/scripts/package-windows.ps1
@@ -70,6 +70,7 @@ try {
     $out = Join-Path $root 'target/package'
     $arch = Get-WindowsPackageArch $probe.FileName
     $stage = Join-Path $out "zeron-$version-windows-$arch"
+    if (Test-Path -LiteralPath $stage) { Remove-Item -LiteralPath $stage -Recurse -Force }
     New-Item -ItemType Directory -Force -Path $stage | Out-Null
     Copy-Item -LiteralPath './target/release/zeron.exe' -Destination (Join-Path $stage 'zeron.exe')
     @{ releases_url = $ReleasesUrl } | ConvertTo-Json | Set-Content -Encoding utf8NoBOM -LiteralPath (Join-Path $stage 'zeron-update.json')
diff --git a/scripts/run-macos-dev.sh b/scripts/run-macos-dev.sh
index a5048c209f..7b2ab70fec 100755
--- a/scripts/run-macos-dev.sh
+++ b/scripts/run-macos-dev.sh
@@ -2,6 +2,7 @@
 # Build and run an isolated macOS development bundle. Zeron.app may remain
 # open: this bundle has a separate LaunchServices/TCC identity, data directory,
 # and engine IPC port.
+# Set ZERON_DEV_BUILD_ONLY=1 to prepare the signed bundle without launching it.
 
 set -euo pipefail
 
@@ -30,6 +31,9 @@ sed "s/__VERSION__/$VERSION/g" "$ROOT/dist/macos/Info-dev.plist" >"$CONTENTS/Inf
 plutil -replace CFBundleIdentifier -string "$BUNDLE_ID" "$CONTENTS/Info.plist"
 plutil -replace LSEnvironment.ZERON_DATA_DIR -string "$DATA_DIR" "$CONTENTS/Info.plist"
 plutil -replace LSEnvironment.ZERON_IPC_PORT -string "$IPC_PORT" "$CONTENTS/Info.plist"
+if [[ -n "${CODEX_EXECUTABLE:-}" ]]; then
+  plutil -insert LSEnvironment.CODEX_EXECUTABLE -string "$CODEX_EXECUTABLE" "$CONTENTS/Info.plist"
+fi
 
 mkdir -p "$CONTENTS/Resources/licenses"
 cp "$ROOT/crates/voice/NOTICE.md" "$CONTENTS/Resources/licenses"/parakeet-v3.txt
@@ -59,6 +63,11 @@ else
   echo "warning: no Apple Development signing identity found; macOS may ask for permissions again after a rebuild" >&2
 fi
 
+if [[ "${ZERON_DEV_BUILD_ONLY:-0}" == "1" ]]; then
+  echo "built: $APP" >&2
+  exit 0
+fi
+
 echo "running Zeron Dev (bundle $BUNDLE_ID, data $DATA_DIR, IPC $IPC_PORT)" >&2
 # LaunchServices must own the process. Launching Contents/MacOS/zeron directly
 # makes TCC attribute Screen Recording to the terminal (Warp, Terminal, etc.).
@@ -68,6 +77,9 @@ OPEN_ENV=(
   --env "ZERON_DATA_DIR=$DATA_DIR"
   --env "ZERON_IPC_PORT=$IPC_PORT"
 )
+if [[ -n "${CODEX_EXECUTABLE:-}" ]]; then
+  OPEN_ENV+=(--env "CODEX_EXECUTABLE=$CODEX_EXECUTABLE")
+fi
 if [[ -n "${ZERON_OPEN_ROUTE:-}" ]]; then
   OPEN_ENV+=(--env "ZERON_OPEN_ROUTE=$ZERON_OPEN_ROUTE")
 fi
diff --git a/scripts/tests/test_voice_packaging.py b/scripts/tests/test_voice_packaging.py
new file mode 100644
index 0000000000..42a2085377
--- /dev/null
+++ b/scripts/tests/test_voice_packaging.py
@@ -0,0 +1,154 @@
+"""Exercise development runtime projection and reject incompatible or altered inputs."""
+import importlib.util
+import io
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+SPEC = importlib.util.spec_from_file_location('voice_packaging', Path(__file__).parents[1] / 'package-voice-runtime.py')
+packager = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(packager)
+
+
+def write_json(path, value):
+    path.write_text(json.dumps(value))
+
+
+def fixture(root, target):
+    app_target = packager.PACKAGES[target][0]
+    voice = root / 'codex-resources/voice'
+    helper = 'bin/codex-voice-host' + ('.exe' if target.endswith('windows-msvc') else '')
+    extension = '.dll' if target.endswith('windows-msvc') else '.dylib' if target.endswith('apple-darwin') else '.so'
+    library = 'lib/native' + extension
+    files = {
+        'bin/codex': b'CLI: must never be copied',
+        'codex-resources/voice/' + helper: b'helper',
+        'codex-resources/voice/' + library: b'library',
+        'codex-resources/voice/NOTICE.md': b'notices',
+        'codex-resources/voice/sources.json': b'{}',
+        'codex-resources/voice/licenses/Opus.txt': b'upstream license',
+    }
+    for name, content in files.items():
+        path = root / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(content)
+    (voice / helper).chmod(0o755)
+    write_json(root / 'codex-package.json', {'layoutVersion': 1, 'version': packager.VERSION, 'target': app_target})
+    write_json(voice / 'runtime.json', {
+        'target': target, 'sourceCommit': packager.BUILD,
+        'libraries': [{'path': library, 'sha256': packager.checksum(voice / library)}],
+    })
+    refresh_manifest(root, target)
+    return voice, helper, library
+
+
+def refresh_manifest(root, target):
+    hashes = {p.relative_to(root).as_posix(): packager.checksum(p)
+              for p in root.rglob('*') if p.is_file() and p.name not in ('manifest.json', 'codex-package.json')}
+    write_json(root / 'codex-resources/voice/manifest.json', {
+        'buildCommit': packager.BUILD, 'appVersion': packager.VERSION,
+        'appTarget': packager.PACKAGES[target][0], 'voiceTarget': target, 'sha256': hashes,
+    })
+
+
+class RuntimePackagingTests(unittest.TestCase):
+    def test_all_platforms_preserve_complete_runtime_without_copying_cli(self):
+        for target in packager.PACKAGES:
+            with self.subTest(target=target), tempfile.TemporaryDirectory() as temporary:
+                root = Path(temporary)
+                source, helper, library = fixture(root / 'source', target)
+                destination = root / 'application with spaces/codex-resources/voice'
+                with patch.object(packager.subprocess, 'run') as codesign:
+                    packager.install(root / 'source', destination, target)
+                self.assertEqual(codesign.call_count, 2 if target.endswith('apple-darwin') else 0)
+                manifest = json.loads((destination / 'zeron-runtime.json').read_text())
+                self.assertEqual(manifest['target'], target)
+                for path in source.rglob('*'):
+                    if path.is_file():
+                        self.assertEqual(path.read_bytes(), (destination / path.relative_to(source)).read_bytes())
+                self.assertIn(helper, manifest['sha256'])
+                self.assertIn(library, manifest['sha256'])
+                self.assertIn('licenses/Codex-LICENSE.txt', manifest['sha256'])
+                for name, digest in manifest['sha256'].items():
+                    self.assertNotIn('\\', name)
+                    self.assertEqual(packager.checksum(destination / name), digest)
+                self.assertFalse((destination / 'bin/codex').exists())
+                # Windows hosts cannot represent POSIX execute bits.
+                if os.name != 'nt' and not target.endswith('windows-msvc'):
+                    self.assertTrue((destination / helper).stat().st_mode & 0o111)
+
+    def test_platform_and_version_mismatches_do_not_replace_existing_runtime(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            target = 'x86_64-unknown-linux-gnu'
+            fixture(root / 'source', target)
+            destination = root / 'app/codex-resources/voice'
+            destination.mkdir(parents=True)
+            (destination / 'previous').write_text('keep')
+            for wrong in ['aarch64-unknown-linux-gnu', 'x86_64-pc-windows-msvc']:
+                with self.assertRaises(ValueError):
+                    packager.install(root / 'source', destination, wrong)
+            metadata = json.loads((root / 'source/codex-package.json').read_text())
+            metadata['version'] = '0.159.0'
+            write_json(root / 'source/codex-package.json', metadata)
+            with self.assertRaises(ValueError):
+                packager.install(root / 'source', destination, target)
+            self.assertEqual((destination / 'previous').read_text(), 'keep')
+
+    def test_tampered_and_untracked_files_are_rejected(self):
+        for kind in ['tampered', 'untracked', 'symlink', 'missing']:
+            with self.subTest(kind=kind), tempfile.TemporaryDirectory() as temporary:
+                root = Path(temporary)
+                target = 'x86_64-pc-windows-msvc'
+                source, helper, _ = fixture(root / 'source', target)
+                if kind == 'tampered':
+                    (source / helper).write_bytes(b'altered')
+                elif kind == 'untracked':
+                    (source / 'untracked.dll').write_bytes(b'altered')
+                elif kind == 'missing':
+                    (source / helper).unlink()
+                else:
+                    if not hasattr(os, 'symlink'):
+                        continue
+                    try:
+                        (source / 'linked').symlink_to(source / helper)
+                    except OSError:
+                        continue  # Windows may not grant symlink creation.
+                with self.assertRaises((ValueError, FileNotFoundError)):
+                    packager.install(root / 'source', root / 'app/codex-resources/voice', target)
+
+    def test_inconsistent_library_inventory_is_rejected_before_replacement(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            target = 'x86_64-unknown-linux-gnu'
+            source, _, _ = fixture(root / 'source', target)
+            runtime = json.loads((source / 'runtime.json').read_text())
+            runtime['libraries'][0]['sha256'] = '0' * 64
+            write_json(source / 'runtime.json', runtime)
+            refresh_manifest(root / 'source', target)
+            destination = root / 'app/codex-resources/voice'
+            destination.mkdir(parents=True)
+            (destination / 'previous').write_text('keep')
+            with self.assertRaisesRegex(ValueError, 'runtime library'):
+                packager.install(root / 'source', destination, target)
+            self.assertEqual((destination / 'previous').read_text(), 'keep')
+
+    def test_manifest_paths_cannot_escape_on_either_platform(self):
+        for name in ['../outside', '/absolute', 'C:/outside', 'C:outside', 'lib\\outside.dll', 'lib/../outside', '.', 'lib//file']:
+            with self.subTest(name=name), self.assertRaises(ValueError):
+                packager.relative_path(name)
+
+    def test_download_checksum_failure_prevents_extraction(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            with patch.object(packager.urllib.request, 'urlopen', return_value=io.BytesIO(b'wrong archive')):
+                with self.assertRaisesRegex(ValueError, 'archive checksum'):
+                    packager.download_package(root, 'x86_64-pc-windows-msvc')
+            self.assertFalse((root / 'package').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/scripts/tests/test_voice_remote.py b/scripts/tests/test_voice_remote.py
new file mode 100644
index 0000000000..02b6381f1c
--- /dev/null
+++ b/scripts/tests/test_voice_remote.py
@@ -0,0 +1,211 @@
+"""Offline checks for the actual subprocess pipes, bounds and cleanup paths."""
+import asyncio
+import importlib.util
+import json
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+import unittest
+from unittest.mock import patch
+
+SPEC = importlib.util.spec_from_file_location('remote_probe', Path(__file__).parents[1] / 'codex-voice-remote-smoke.py')
+probe = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(probe)
+FIXTURE = Path(__file__).with_name('voice_remote_fixture.py')
+SDP = 'v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111\r\n'
+
+
+class ContractTests(unittest.TestCase):
+    def test_cli_requires_live_before_resolving_or_spawning_anything(self):
+        result = subprocess.run([sys.executable, str(SPEC.origin),
+            '--ssh-host', 'does-not-exist.invalid', '--remote-codex', '/no/codex',
+            '--remote-cwd', '/no/cwd', '--helper', '/no/helper'], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 2)
+        self.assertIn('--live is required', result.stderr)
+        self.assertNotIn('Traceback', result.stderr)
+
+    def test_sdp_bounds_are_bytes_and_reject_malformed(self):
+        for value in (None, '', 'secret', SDP + 'é' * (probe.MAX_SDP // 2)):
+            with self.subTest(value=type(value).__name__), self.assertRaisesRegex(probe.ProbeError, '^invalid_sdp$'):
+                probe.validate_sdp(value)
+        self.assertEqual(probe.validate_sdp(SDP), SDP)
+        self.assertEqual(len(probe.validate_sdp(SDP + ' ' * (probe.MAX_SDP - len(SDP))).encode()), probe.MAX_SDP)
+
+    def test_ssh_quotes_remote_command_and_rejects_option_injection(self):
+        args = ['env', '-u', 'OPENAI_API_KEY', '/tmp/a $(touch nope)/codex', 'app-server']
+        command = probe.ssh_command('user@fedora', args)
+        self.assertEqual(shlex.split(command[-1]), ['exec'] + args)
+        self.assertIn('BatchMode=yes', command)
+        for host in ('-oProxyCommand=bad', 'host;bad', 'host\ncmd', ''):
+            with self.assertRaises(probe.ProbeError):
+                probe.ssh_command(host, args)
+
+    def test_helper_does_not_inherit_credentials_or_loader_overrides(self):
+        with patch.dict(os.environ, {'OPENAI_API_KEY': 'SECRET', 'DYLD_INSERT_LIBRARIES': 'SECRET',
+                                     'LD_PRELOAD': 'SECRET', 'GST_PLUGIN_PATH': 'SECRET', 'HOME': '/tmp'}, clear=True):
+            env = probe.helper_environment()
+        self.assertNotIn('SECRET', env.values())
+        self.assertEqual(env['HOME'], '/tmp')
+        self.assertEqual(env['GST_PLUGIN_PATH'], '')
+
+    def test_observation_correlates_and_deduplicates_without_retaining_text(self):
+        observation = probe.Observation('thread', 'session')
+        frame = {'method': 'thread/realtime/item/completed', 'params': {
+            'threadId': 'other', 'item': {'id': 'i1', 'type': 'transcriptSegment',
+                'realtimeSessionId': 'session', 'role': 'user', 'text': 'SECRET'}}}
+        observation.accept(frame)
+        frame['params']['threadId'] = 'thread'
+        frame['params']['item']['realtimeSessionId'] = 'old-session'
+        observation.accept(frame)
+        self.assertEqual(observation.counts['userFinals'], 0)
+        frame['params']['item']['realtimeSessionId'] = 'session'
+        observation.accept(frame)
+        observation.accept(frame)
+        self.assertEqual(observation.counts['userFinals'], 1)
+        self.assertNotIn('SECRET', repr(vars(observation)))
+
+
+class PipeTests(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.children = []
+        self.servers = []
+
+    async def asyncTearDown(self):
+        for server in self.servers:
+            await server.close()
+        for child in self.children:
+            await probe.reap(child)
+            self.assertIsNotNone(child.returncode)
+
+    async def child(self, role, mode):
+        child = await probe.spawn([sys.executable, str(FIXTURE), role, mode])
+        self.children.append(child)
+        return child
+
+    async def server(self, mode='normal', timeout=1):
+        server = probe.Server(await self.child('server', mode), timeout=timeout)
+        self.servers.append(server)
+        return server
+
+    async def helper(self, mode='normal', timeout=1):
+        return probe.Helper(await self.child('helper', mode), timeout=timeout)
+
+    async def test_complete_split_pipes_with_both_notification_orders(self):
+        for mode in ('normal', 'reverse'):
+            report = {}
+            await probe.exercise(await self.server(mode), await self.helper(), 'fixture', '/tmp', report)
+            self.assertTrue(report['transportReady'])
+            self.assertTrue(report['voicesBeforeThread'])
+            self.assertTrue(report['localClosed'])
+            self.assertTrue(report['stopAcknowledged'])
+            self.assertTrue(report['providerClosed'])
+            self.assertEqual(report['userFinals'], 1)
+            self.assertEqual(report['assistantFinals'], 1)
+            self.assertNotIn('SECRET', json.dumps(report))
+            self.assertNotIn('devicesOpened', report)
+
+    async def test_provider_rejection_does_not_expose_payload(self):
+        with self.assertRaisesRegex(probe.ProbeError, '^request_rejected$'):
+            await (await self.server('reject')).request('initialize', {})
+
+    async def test_closed_server_wakes_pending_request(self):
+        with self.assertRaisesRegex(probe.ProbeError, '^server_closed$'):
+            await (await self.server('disconnect')).request('initialize', {})
+
+    async def test_request_timeout_removes_pending_future(self):
+        server = await self.server('hang', timeout=0.1)
+        with self.assertRaises(asyncio.TimeoutError):
+            await server.request('initialize', {})
+        self.assertEqual(server.pending, {})
+
+    async def test_bad_auth_and_config_fail_before_transport(self):
+        for mode, error in [('apikey', 'chatgpt_required'), ('custom', 'custom_provider')]:
+            report = {}
+            with self.assertRaisesRegex(probe.ProbeError, '^' + error + '$'):
+                await probe.exercise(await self.server(mode), await self.helper(), 'fixture', '/tmp', report)
+            self.assertNotIn('transportReady', report)
+            self.assertTrue(report['localClosed'])
+
+    async def test_failed_negotiation_closes_helper_and_stops_provider(self):
+        for mode, error in [('closed', 'provider_closed'), ('invalid-answer', 'invalid_sdp')]:
+            report = {}
+            with self.assertRaisesRegex(probe.ProbeError, '^' + error + '$'):
+                await probe.exercise(await self.server(mode), await self.helper(), 'fixture', '/tmp', report)
+            self.assertTrue(report['localClosed'])
+            self.assertTrue(report['stopAcknowledged'])
+
+    async def test_lost_start_reply_still_stops_provider(self):
+        report = {}
+        with self.assertRaises(asyncio.TimeoutError):
+            await probe.exercise(await self.server('lost-start', timeout=0.15),
+                                 await self.helper(), 'fixture', '/tmp', report)
+        self.assertTrue(report['localClosed'])
+        self.assertTrue(report['stopAcknowledged'])
+
+    async def test_cancel_during_start_reaps_and_stops(self):
+        report = {}
+        helper = await self.helper()
+        task = asyncio.create_task(probe.exercise(await self.server('lost-start'), helper, 'fixture', '/tmp', report))
+        async def reached_start():
+            while report.get('stage') != 'negotiate':
+                await asyncio.sleep(0.005)
+        await asyncio.wait_for(reached_start(), 1)
+        task.cancel()
+        with self.assertRaises(asyncio.CancelledError):
+            await task
+        self.assertTrue(report['localClosed'])
+        self.assertTrue(report['stopAcknowledged'])
+        self.assertIsNotNone(helper.child.returncode)
+
+    async def test_helper_truncated_oversized_and_hung_frames_are_reaped(self):
+        for mode, error in [('truncated', asyncio.IncompleteReadError),
+                            ('oversize', probe.ProbeError), ('hang', asyncio.TimeoutError)]:
+            helper = await self.helper(mode, timeout=0.1)
+            with self.assertRaises(error):
+                await helper.exchange({'type': 'hello'}, 'ready')
+            self.assertIsNotNone(helper.child.returncode)
+            with self.assertRaisesRegex(probe.ProbeError, '^helper_closed$'):
+                await helper.exchange({'type': 'close'}, 'closed')
+
+    async def test_negotiation_ignores_old_thread_and_session_and_times_out(self):
+        class Silent:
+            events = asyncio.Queue()
+            async def event(self):
+                return await self.events.get()
+        server = Silent()
+        await server.events.put({'method': 'thread/realtime/started', 'params': {
+            'threadId': 'old', 'realtimeSessionId': 'session', 'version': 'v3'}})
+        await server.events.put({'method': 'thread/realtime/started', 'params': {
+            'threadId': 'thread', 'realtimeSessionId': 'old', 'version': 'v3'}})
+        observation = probe.Observation('thread', 'session')
+        with self.assertRaises(asyncio.TimeoutError):
+            await observation.negotiate(server, timeout=0.05)
+        self.assertFalse(observation.started)
+
+    async def test_queued_close_prevents_successful_negotiation(self):
+        class Buffered:
+            events = asyncio.Queue()
+            async def event(self):
+                return await self.events.get()
+        server = Buffered()
+        for method, params in [('started', {'realtimeSessionId': 'session', 'version': 'v3'}),
+                               ('sdp', {'sdp': SDP}), ('closed', {'reason': 'transport_closed'})]:
+            await server.events.put({'method': 'thread/realtime/' + method,
+                                     'params': dict(threadId='thread', **params)})
+        with self.assertRaisesRegex(probe.ProbeError, '^provider_closed$'):
+            await probe.Observation('thread', 'session').negotiate(server)
+
+    async def test_conflicting_duplicate_answer_is_rejected(self):
+        observation = probe.Observation('thread', 'session')
+        frame = {'method': 'thread/realtime/sdp', 'params': {'threadId': 'thread', 'sdp': SDP}}
+        observation.accept(frame)
+        observation.accept(frame)
+        frame['params']['sdp'] = SDP + 'a=sendrecv\r\n'
+        with self.assertRaisesRegex(probe.ProbeError, '^conflicting_answer$'):
+            observation.accept(frame)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/scripts/tests/voice_remote_fixture.py b/scripts/tests/voice_remote_fixture.py
new file mode 100644
index 0000000000..e8f0900c01
--- /dev/null
+++ b/scripts/tests/voice_remote_fixture.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Independent subprocess fixtures. No network, hardware, credentials or wire logs."""
+import json
+import struct
+import sys
+import time
+
+ROLE, MODE = sys.argv[1:]
+SDP = 'v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111\r\n'
+
+
+def send(value):
+    payload = json.dumps(value).encode()
+    if ROLE == 'helper':
+        sys.stdout.buffer.write(struct.pack('>I', len(payload)) + payload)
+        sys.stdout.buffer.flush()
+    else:
+        print(payload.decode(), flush=True)
+
+
+def helper():
+    while header := sys.stdin.buffer.read(4):
+        frame = json.loads(sys.stdin.buffer.read(struct.unpack('>I', header)[0]))
+        if MODE == 'hang':
+            time.sleep(60)
+        if MODE == 'oversize':
+            sys.stdout.buffer.write(struct.pack('>I', 128 * 1024 + 1))
+            sys.stdout.buffer.flush()
+            return
+        if MODE == 'truncated':
+            sys.stdout.buffer.write(struct.pack('>I', 100) + b'{')
+            sys.stdout.buffer.flush()
+            return
+        kind = frame['type']
+        responses = {'hello': 'ready', 'initializeRuntime': 'runtimeReady',
+                     'startTransport': 'offer', 'applyAnswer': 'transportReady',
+                     'close': 'closed'}
+        # Offline exercise must never open audio. Fail if it tries.
+        if kind not in responses:
+            raise RuntimeError('unexpected helper command')
+        result = {'type': responses[kind]}
+        if kind == 'startTransport':
+            result['sdp'] = SDP if MODE != 'invalid-offer' else 'secret malformed offer'
+        if kind == 'applyAnswer':
+            assert frame['sdp'] == SDP
+        send(result)
+        if kind == 'close':
+            return
+
+
+def server():
+    voices_checked = False
+    for line in sys.stdin:
+        frame = json.loads(line)
+        if 'id' not in frame:
+            continue
+        method = frame['method']
+        result = {}
+        if MODE == 'disconnect':
+            return
+        if MODE == 'hang':
+            time.sleep(60)
+        if MODE == 'reject':
+            send({'id': frame['id'], 'error': {'message': 'SECRET provider contents'}})
+            continue
+        if method == 'account/read':
+            result = {'account': {'type': 'apikey' if MODE == 'apikey' else 'chatgpt',
+                                  'email': 'SECRET@example.test'}}
+        elif method == 'config/read':
+            result = {'config': {'model_provider': 'custom'} if MODE == 'custom' else {}}
+        elif method == 'thread/realtime/listVoices':
+            voices_checked = True
+        elif method == 'thread/start':
+            assert voices_checked
+            result = {'thread': {'id': 'fixture-thread'}, 'modelProvider': 'openai'}
+        elif method == 'thread/realtime/start':
+            p = frame['params']
+            assert p['transport'] == {'type': 'webrtc', 'sdp': SDP}
+            assert p['clientManagedHandoffs'] is False and p['version'] == 'v3'
+            if MODE == 'lost-start':
+                continue  # Still service stop after the caller's deadline.
+        send({'id': frame['id'], 'result': result})
+        if method == 'thread/realtime/stop':
+            send({'method': 'thread/realtime/closed', 'params': {
+                'threadId': 'fixture-thread', 'reason': 'requested'}})
+        if method == 'thread/realtime/start':
+            p = frame['params']
+            def event(name, **params):
+                send({'method': 'thread/realtime/' + name,
+                      'params': dict(threadId='fixture-thread', **params)})
+            if MODE == 'closed':
+                event('closed', reason='SECRET error details')
+                continue
+            started = {'realtimeSessionId': p['realtimeSessionId'], 'version': 'v3'}
+            if MODE == 'reverse':
+                event('sdp', sdp=SDP)
+                event('started', **started)
+            else:
+                event('started', **started)
+                event('sdp', sdp=SDP if MODE != 'invalid-answer' else 'SECRET SDP')
+            for _ in range(2):
+                event('item/completed', item={'type': 'transcriptSegment', 'id': 'u1',
+                      'realtimeSessionId': p['realtimeSessionId'], 'role': 'user', 'text': 'SECRET transcript'})
+            event('item/completed', item={'type': 'transcriptSegment', 'id': 'a1',
+                  'realtimeSessionId': p['realtimeSessionId'], 'role': 'assistant', 'text': 'SECRET answer'})
+
+
+if ROLE == 'helper':
+    helper()
+else:
+    server()

From 9e83ceea2b92f3627c39f5db2403cb487dad6c54 Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Tue, 6 Oct 2026 23:47:45 -0700
Subject: [PATCH 57/74] Bump version to v0.2.105

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 46 +++++++++++++++++++++++-----------------------
 Cargo.toml |  2 +-
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cdbe320ca9..5fac50821d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12941,7 +12941,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "clap",
@@ -12963,7 +12963,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-audio"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "base64 0.22.1",
  "cpal 0.18.2",
@@ -12975,7 +12975,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "async-trait",
  "chrono",
@@ -13000,7 +13000,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "chrono",
  "loro",
@@ -13014,7 +13014,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13055,7 +13055,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13083,14 +13083,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13108,7 +13108,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "async-trait",
  "serde",
@@ -13131,11 +13131,11 @@ dependencies = [
 
 [[package]]
 name = "zeron-orb"
-version = "0.2.104"
+version = "0.2.105"
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13163,7 +13163,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -13174,7 +13174,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13193,7 +13193,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -13216,7 +13216,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -13250,7 +13250,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -13267,7 +13267,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "clap",
@@ -13282,7 +13282,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -13355,7 +13355,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "futures",
@@ -13371,11 +13371,11 @@ dependencies = [
 
 [[package]]
 name = "zeron-veil"
-version = "0.2.104"
+version = "0.2.105"
 
 [[package]]
 name = "zeron-voice"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "anyhow",
  "cpal 0.17.3",
@@ -13392,7 +13392,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice-media"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "async-trait",
  "semver",
@@ -13407,7 +13407,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice-session"
-version = "0.2.104"
+version = "0.2.105"
 dependencies = [
  "async-trait",
  "futures",
diff --git a/Cargo.toml b/Cargo.toml
index 1715a65e49..5c5b53839f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.104"
+version = "0.2.105"
 edition = "2024"
 license = "MIT"
 publish = false

From 970f41fa7b930b27328efca05249f61bb3bea483 Mon Sep 17 00:00:00 2001
From: Wing <44917547+wingleeio@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:37:23 -0700
Subject: [PATCH 58/74] Fold dated Claude snapshot IDs into curated model rows
 (#835)

The Claude CLI lists Haiku 4.5 as claude-haiku-4-5-20251001 while the
curated catalog uses claude-haiku-4-5, so the exact-ID overlay added a
second "Haiku 4.5" row to the model picker. Treat a -YYYYMMDD snapshot
of a curated ID as that curated row.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/harness/src/claude/catalog.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/crates/harness/src/claude/catalog.rs b/crates/harness/src/claude/catalog.rs
index 21e3fc89da..fd0dadf601 100644
--- a/crates/harness/src/claude/catalog.rs
+++ b/crates/harness/src/claude/catalog.rs
@@ -254,6 +254,11 @@ pub(super) fn with_discovered_models(
             continue;
         }
         valid = true;
+        // The CLI lists some models by dated snapshot ("claude-haiku-4-5-20251001");
+        // fold those into the curated undated row instead of duplicating it.
+        let id = snapshot_base(id)
+            .filter(|base| models.iter().any(|model| model.id == *base))
+            .unwrap_or(id);
         if text("value") == Some("default") {
             default = Some(id.to_owned());
         }
@@ -314,6 +319,12 @@ pub(super) fn with_discovered_models(
     Ok(models)
 }
 
+/// `claude-haiku-4-5-20251001` -> `claude-haiku-4-5`.
+fn snapshot_base(id: &str) -> Option<&str> {
+    let (base, date) = id.rsplit_once('-')?;
+    (date.len() == 8 && date.bytes().all(|b| b.is_ascii_digit())).then_some(base)
+}
+
 pub fn static_models() -> Vec<Model> {
     vec![
         model(
@@ -397,6 +408,19 @@ mod tests {
         assert_eq!(to_effort(Some(ReasoningLevel::XHigh), None), Some("max"));
     }
 
+    #[test]
+    fn dated_snapshots_fold_into_curated_rows() {
+        let response = serde_json::json!({"response": {"models": [
+            {"value": "claude-haiku-4-5-20251001", "resolvedModel": "claude-haiku-4-5-20251001",
+             "displayName": "Haiku 4.5", "description": "Fastest for quick answers"},
+            {"value": "claude-haiku-9-9-20990101", "displayName": "Haiku 9.9"},
+        ]}});
+        let models = with_discovered_models(static_models(), &response).unwrap();
+        assert_eq!(models.iter().filter(|m| m.label == "Haiku 4.5").count(), 1);
+        // Snapshots with no curated base still surface as-is.
+        assert!(models.iter().any(|m| m.id == "claude-haiku-9-9-20990101"));
+    }
+
     #[test]
     fn xhigh_family_matching() {
         assert!(supports_xhigh("claude-fable-5"));

From 8930cd10360ea7919765050216be908d9b6bf5bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Gurruchaga?= <jsgrrchg@gmail.com>
Date: Wed, 7 Oct 2026 16:20:01 -0300
Subject: [PATCH 59/74] Fix voice helper compatibility with Codex 0.161 (#834)

---
 crates/harness/src/codex/realtime.rs          |   2 +-
 .../tests/fixtures/fake-codex-voice-host.py   |   5 +
 crates/voice-media/src/lib.rs                 | 100 +++++++++++++++++-
 3 files changed, 104 insertions(+), 3 deletions(-)

diff --git a/crates/harness/src/codex/realtime.rs b/crates/harness/src/codex/realtime.rs
index fa499db85e..39e1f00d91 100644
--- a/crates/harness/src/codex/realtime.rs
+++ b/crates/harness/src/codex/realtime.rs
@@ -474,7 +474,7 @@ async fn start(
         20,
     )
     .await?;
-    host.expect(json!({"type":"openDevices"}), "devicesOpened", 5)
+    host.open_devices()
         .await
         .map_err(|_| VoiceRejection::DeviceUnavailable)?;
     // Keep devices muted/suppressed until the engine confirms the owner stream.
diff --git a/crates/harness/tests/fixtures/fake-codex-voice-host.py b/crates/harness/tests/fixtures/fake-codex-voice-host.py
index fd1b38c703..acd8322c62 100755
--- a/crates/harness/tests/fixtures/fake-codex-voice-host.py
+++ b/crates/harness/tests/fixtures/fake-codex-voice-host.py
@@ -23,6 +23,11 @@ def send(value):
         elif kind=='startTransport':send({'type':'offer','sdp':'fixture-offer'})
         elif kind=='applyAnswer':assert frame['sdp']=='fixture-answer';send({'type':'transportReady'})
         elif kind=='openDevices':
+            manifest=pathlib.Path(__file__).resolve().parents[1]/'manifest.json'
+            version=json.loads(manifest.read_text())['appVersion'] if manifest.exists() else '0.159.0'
+            expected={'type':'openDevices'}
+            if tuple(map(int,version.split('.'))) >= (0,161,0):expected['selection']={}
+            assert frame==expected
             if (root/'helper-mode').exists() and (root/'helper-mode').read_text().strip()=='exit-open':sys.exit(25)
             send({'type':'devicesOpened'})
         elif kind=='setAudioControls':
diff --git a/crates/voice-media/src/lib.rs b/crates/voice-media/src/lib.rs
index 444ef053ef..f1a7584f89 100644
--- a/crates/voice-media/src/lib.rs
+++ b/crates/voice-media/src/lib.rs
@@ -18,6 +18,7 @@ pub struct NativeHost {
     stop: tokio_util::sync::CancellationToken,
     input: ChildStdin,
     output: ChildStdout,
+    device_selection: bool,
 }
 impl Drop for NativeHost {
     fn drop(&mut self) {
@@ -93,6 +94,7 @@ impl NativeHost {
         path: &Path,
         stop: tokio_util::sync::CancellationToken,
     ) -> Result<Self, VoiceRejection> {
+        let device_selection = helper_device_selection(path)?;
         let result = tokio::time::timeout(
             Duration::from_secs(5),
             Self::command(path).arg("--build-commit").output(),
@@ -124,6 +126,7 @@ impl NativeHost {
             stop: stop.clone(),
             input,
             output,
+            device_selection,
         };
         // A helper that cannot start its runtime (e.g. a library that no longer
         // matches its runtime.json) exits here; that is the runtime, not the call.
@@ -216,6 +219,15 @@ impl NativeHost {
     pub async fn controls(&mut self, muted: bool) -> Result<(), VoiceRejection> {
         self.expect(json!({"type":"setAudioControls","controls":{"microphoneMuted":muted,"speakerSuppressed":false}}),"audioControlsApplied",5).await
     }
+    pub async fn open_devices(&mut self) -> Result<(), VoiceRejection> {
+        let mut message = json!({"type":"openDevices"});
+        // Codex 0.161 requires selection even for the default devices. Older
+        // helpers reject that field, despite sharing the same protocol version.
+        if self.device_selection {
+            message["selection"] = json!({});
+        }
+        self.expect(message, "devicesOpened", 5).await
+    }
     /// Synchronous local shutdown, independent of pending RPC or helper I/O.
     pub fn close(&self) {
         self.stop.cancel();
@@ -237,6 +249,27 @@ impl NativeHost {
     }
 }
 
+fn helper_device_selection(path: &Path) -> Result<bool, VoiceRejection> {
+    let root = path
+        .parent()
+        .and_then(Path::parent)
+        .ok_or(VoiceRejection::NativeRuntimeUnavailable)?;
+    let bytes = match std::fs::read(root.join("manifest.json")) {
+        Ok(bytes) => bytes,
+        // The pinned development runtime and older fixtures may omit the
+        // upstream manifest; they use the original openDevices format.
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false),
+        Err(_) => return Err(VoiceRejection::NativeRuntimeUnavailable),
+    };
+    let manifest: Value =
+        serde_json::from_slice(&bytes).map_err(|_| VoiceRejection::NativeRuntimeUnavailable)?;
+    let version = manifest["appVersion"]
+        .as_str()
+        .and_then(|v| semver::Version::parse(v).ok())
+        .ok_or(VoiceRejection::Unsupported)?;
+    Ok(version >= semver::Version::new(0, 161, 0))
+}
+
 fn runtime_target() -> Result<&'static str, VoiceRejection> {
     match (std::env::consts::OS, std::env::consts::ARCH) {
         ("macos", "aarch64") => Ok("aarch64-apple-darwin"),
@@ -459,6 +492,70 @@ mod tests {
         assert!(verify_runtime(&dir).is_err());
     }
 
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn desktop_media_opens_default_devices_with_old_and_new_helpers() {
+        use std::os::unix::fs::PermissionsExt;
+        use zeron_voice_session::VoiceMediaEndpoint;
+
+        for version in [None, Some("0.159.0"), Some("0.160.0"), Some("0.161.0")] {
+            let dir = tempfile::tempdir().unwrap();
+            let codex = codex_package(dir.path(), version.unwrap_or("0.160.0"), true);
+            let helper = installed_helper(&codex).unwrap();
+            std::fs::write(
+                &helper,
+                include_bytes!("../../harness/tests/fixtures/fake-codex-voice-host.py"),
+            )
+            .unwrap();
+            std::fs::set_permissions(&helper, std::fs::Permissions::from_mode(0o755)).unwrap();
+            if let Some(version) = version {
+                std::fs::write(
+                    helper
+                        .parent()
+                        .unwrap()
+                        .parent()
+                        .unwrap()
+                        .join("manifest.json"),
+                    json!({"appVersion":version}).to_string(),
+                )
+                .unwrap();
+            }
+            let media = DesktopMedia {
+                path: helper,
+                host: Default::default(),
+                stop: Default::default(),
+            };
+            media.prepare().await.unwrap();
+            media.offer().await.unwrap();
+            media
+                .apply_answer(
+                    zeron_proto::voice::remote::Sdp::new("fixture-answer".into()).unwrap(),
+                )
+                .await
+                .unwrap();
+            media.set_muted(true).await.unwrap();
+            assert_eq!(media.levels().await.unwrap(), (1024, 0));
+            media.stop.cancel();
+        }
+    }
+
+    #[test]
+    fn malformed_helper_metadata_is_not_treated_as_a_legacy_runtime() {
+        let dir = tempfile::tempdir().unwrap();
+        let codex = codex_package(dir.path(), "0.161.0", true);
+        let helper = installed_helper(&codex).unwrap();
+        let manifest = helper
+            .parent()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join("manifest.json");
+        for contents in ["{", "{}", r#"{"appVersion":"invalid"}"#] {
+            std::fs::write(&manifest, contents).unwrap();
+            assert!(helper_device_selection(&helper).is_err());
+        }
+    }
+
     #[cfg(unix)]
     #[tokio::test]
     async fn helper_that_cannot_start_its_runtime_is_a_runtime_failure() {
@@ -537,8 +634,7 @@ impl zeron_voice_session::VoiceMediaEndpoint for DesktopMedia {
             20,
         )
         .await?;
-        host.expect(json!({"type":"openDevices"}), "devicesOpened", 5)
-            .await?;
+        host.open_devices().await?;
         host.expect(json!({"type":"setAudioControls","controls":{"microphoneMuted":true,"speakerSuppressed":true}}),"audioControlsApplied",5).await
     }
     async fn set_muted(&self, muted: bool) -> Result<(), VoiceRejection> {

From 916cb1ccb1342c2061963a5f6ecf5c977ba46f2c Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Wed, 7 Oct 2026 12:21:19 -0700
Subject: [PATCH 60/74] Bump version to v0.2.106

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 46 +++++++++++++++++++++++-----------------------
 Cargo.toml |  2 +-
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5fac50821d..8e3be05ea5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12941,7 +12941,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "clap",
@@ -12963,7 +12963,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-audio"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "base64 0.22.1",
  "cpal 0.18.2",
@@ -12975,7 +12975,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "async-trait",
  "chrono",
@@ -13000,7 +13000,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "chrono",
  "loro",
@@ -13014,7 +13014,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13055,7 +13055,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13083,14 +13083,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13108,7 +13108,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "async-trait",
  "serde",
@@ -13131,11 +13131,11 @@ dependencies = [
 
 [[package]]
 name = "zeron-orb"
-version = "0.2.105"
+version = "0.2.106"
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13163,7 +13163,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -13174,7 +13174,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13193,7 +13193,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -13216,7 +13216,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -13250,7 +13250,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -13267,7 +13267,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "clap",
@@ -13282,7 +13282,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -13355,7 +13355,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "futures",
@@ -13371,11 +13371,11 @@ dependencies = [
 
 [[package]]
 name = "zeron-veil"
-version = "0.2.105"
+version = "0.2.106"
 
 [[package]]
 name = "zeron-voice"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "anyhow",
  "cpal 0.17.3",
@@ -13392,7 +13392,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice-media"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "async-trait",
  "semver",
@@ -13407,7 +13407,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice-session"
-version = "0.2.105"
+version = "0.2.106"
 dependencies = [
  "async-trait",
  "futures",
diff --git a/Cargo.toml b/Cargo.toml
index 5c5b53839f..b5edee7fd6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.105"
+version = "0.2.106"
 edition = "2024"
 license = "MIT"
 publish = false

From 8646bde07e31e280dd3f7b887b465857e19527d7 Mon Sep 17 00:00:00 2001
From: neo773 <62795688+neo773@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:30:43 +0530
Subject: [PATCH 61/74] Cut startup memory from ~700 MB to ~200 MB on large
 local profiles (#818)

* Cut startup memory from ~700 MB to ~200 MB on large local profiles

- Registry: local-only replicas apply writes directly instead of queueing
  them forever (178k queued ops / 70 MB snapshot on an affected profile);
  coalesce the unsent tail per row with an edge, preserving push
  notifications, the per-op size limit and multi-op batches; compact
  bloated snapshots on load.
- Docs store: cap the WAL, truncate it at open, and VACUUM once when free
  pages dominate (again after registry compaction).
- Boot: read run journals backwards from the end; share one notify watcher
  for diff_sync and spaces with batched changes and a stream bridge; skip
  archived chats unless a transcript stream has them open.
- UI: notify only when watched state actually changed; fire clock-driven
  transitions (stale, device offline, send grace) at their deadlines
  instead of ticking every second.
- Fix the e2e generated-image test on macOS (/var vs /private/var).

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

* Address review: watcher races, Linux inotify sharing, deferred VACUUM

- fs_watch: release the batch worker flag under the same lock as the
  "no new changes" check, so a registration racing the worker's exit is
  never lost.
- fs_watch: give inotify/kqueue one watcher per installed root. A shared
  instance let a checkout symlinking into another (npm link) alias its
  watch descriptors, and a failed recursive watch leaked its partial
  watches for the life of the process. macOS/Windows keep one watcher.
- fs_watch: rescan a live registration whose covering OS watch was
  replaced (a nested path taking over from a dropped recursive root, a
  mode change); nothing observed the swap.
- diff_sync: serialize every discard on one lock, whether or not the
  checkout has an entry, so two discards of one root never interleave.
- registry: fold writes into rows only for Local profiles, which can
  never attach an edge. Re-seeding folded rows as full upserts on a later
  attach could revive rows another device deleted meanwhile.
- store: keep only the WAL truncate in DocsStore::open; the engine runs
  the thresholded VACUUM on a blocking task after boot instead of on the
  boot path (engine assembly, iOS client, local import).
- ui: refresh the clock-dependent presentation caches when a clock
  transition fires, so the frame that reverts it (a revived session or
  device) notifies and re-arms the next deadline; side chats now watch
  clock transitions too.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Wing <contact@winglee.io>
---
 crates/client/src/client.rs              |  55 +-
 crates/client/src/demo/fixtures.rs       |   4 +-
 crates/client/src/demo/mod.rs            |  57 +-
 crates/client/src/workspace/mod.rs       |   4 +-
 crates/doc/src/registry.rs               | 403 +++++++++-
 crates/doc/src/registry/tests.rs         | 619 +++++++++++++++
 crates/engine/src/diff_sync.rs           | 297 +++++--
 crates/engine/src/doc_host_sync_tests.rs |   1 +
 crates/engine/src/fs_watch.rs            | 964 +++++++++++++++++++++++
 crates/engine/src/lib.rs                 |   2 +
 crates/engine/src/rpc.rs                 |  36 +-
 crates/engine/src/run_journal.rs         | 359 ++++++++-
 crates/engine/src/sessions.rs            | 181 ++++-
 crates/engine/src/spaces.rs              | 140 +++-
 crates/engine/src/workspace_host.rs      | 206 ++++-
 crates/engine/tests/diff_sync_churn.rs   | 330 ++++++++
 crates/engine/tests/e2e.rs               |   4 +-
 crates/sync/src/store.rs                 | 305 ++++++-
 crates/ui/src/change_requests.rs         |  49 +-
 crates/ui/src/composer.rs                |  45 +-
 crates/ui/src/lib.rs                     |   6 +-
 crates/ui/src/shell.rs                   | 238 +++++-
 crates/ui/src/state.rs                   | 660 ++++++++++++++--
 23 files changed, 4615 insertions(+), 350 deletions(-)
 create mode 100644 crates/engine/src/fs_watch.rs

diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 0d075c8afa..6d5333abe0 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -146,11 +146,11 @@ impl ClientInner {
         }
     }
 
-    /// After any local registry write: settle (demo) / push (live), re-derive.
+    /// After any local registry write: push (live), re-derive. Demo's
+    /// local-only replica already holds the write.
     pub(crate) fn after_registry_write(self: &Arc<Self>) {
-        match self.backend() {
-            Backend::Demo(demo) => demo.settle_registry(&self.workspace),
-            Backend::Live(live) => live.registry_written(),
+        if let Backend::Live(live) = self.backend() {
+            live.registry_written();
         }
         self.recompute_workspace();
     }
@@ -586,7 +586,12 @@ impl Client {
         // Live: restore the registry replica + open the docs store first, so
         // the very first snapshot renders the cached workspace (instant).
         let (registry, store) = if credentials.is_demo() {
-            (RegistryDoc::new(config.device_id.clone()), None)
+            // Demo has no edge: nothing would ever ack a queued write, so the
+            // replica folds writes straight into its rows (as the engine does
+            // for edge-less profiles).
+            let mut registry = RegistryDoc::new(config.device_id.clone());
+            registry.set_local_only(true);
+            (registry, None)
         } else {
             let (store, registry) = LiveBackend::open(&config.data_dir, &config.device_id)?;
             (registry, Some(store))
@@ -1518,3 +1523,43 @@ pub struct PushPrefs {
     /// A run failed.
     pub failed: bool,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn demo_replica_is_local_only_and_never_queues() {
+        let dir = tempfile::tempdir().unwrap();
+        let mut config = ClientConfig::new("https://edge.invalid", dir.path());
+        config.device_id = "ios-test".into();
+        let client = Client::new(
+            config,
+            Credentials::Demo(Default::default()),
+            Arc::new(crate::events::NullListener),
+        )
+        .unwrap();
+        let chat_id = client
+            .inner
+            .workspace
+            .mutate(|doc| doc.read_chats())
+            .unwrap()
+            .into_iter()
+            .find(|c| c.parent_chat_id.is_none())
+            .expect("seeded chat")
+            .id;
+        for i in 0..20 {
+            client
+                .rename_session(&chat_id, &format!("title {i}"))
+                .unwrap();
+        }
+        let (pending, title) = client.inner.workspace.mutate(|doc| {
+            (
+                doc.pending_len(),
+                doc.chat(&chat_id).unwrap().unwrap().title,
+            )
+        });
+        assert_eq!(pending, 0);
+        assert_eq!(title.as_deref(), Some("title 19"));
+    }
+}
diff --git a/crates/client/src/demo/fixtures.rs b/crates/client/src/demo/fixtures.rs
index 218f89decb..f718b4512b 100644
--- a/crates/client/src/demo/fixtures.rs
+++ b/crates/client/src/demo/fixtures.rs
@@ -353,8 +353,8 @@ pub(crate) struct Seeded {
     pub change_requests: Vec<CheckoutChangeRequestStatus>,
 }
 
-/// Write the whole dataset into the replica (as local writes; the demo
-/// server settles them).
+/// Write the whole dataset into the replica (as local writes, which the
+/// local-only demo replica folds straight into its rows).
 pub(crate) fn seed(
     doc: &mut RegistryDoc,
     fixture: DemoFixture,
diff --git a/crates/client/src/demo/mod.rs b/crates/client/src/demo/mod.rs
index c6d92e005c..e969dd431c 100644
--- a/crates/client/src/demo/mod.rs
+++ b/crates/client/src/demo/mod.rs
@@ -2,8 +2,8 @@
 //! simulated host.
 //!
 //! Nothing here short-circuits the client: the dataset lives in a real
-//! [`RegistryDoc`] (local writes settle through [`DemoServer`], a stand-in for
-//! the registry room) and real [`SessionDoc`]s. The viewer side writes
+//! [`RegistryDoc`] (local-only, like an edge-less engine: writes fold straight
+//! into its rows, with no room to ack them) and real [`SessionDoc`]s. The viewer side writes
 //! commands and queue rows exactly as in live mode; [`DemoHost`] plays the
 //! engine — adopting commands (writing the user entry under the client-minted
 //! id), streaming replies through `SegmentWriter`, flipping session status
@@ -21,8 +21,8 @@ use std::time::Duration;
 use chrono::Utc;
 use tokio_util::sync::CancellationToken;
 use zeron_doc::{
-    MessagePart, MessageRole, MessageStatus, QueueDeliveryGate, RegistryDoc, RegistryRow, RowOp,
-    SegmentWriter, SessionCommandPayload, SessionCommandStatus, SessionDoc, apply_op,
+    MessagePart, MessageRole, MessageStatus, QueueDeliveryGate, SegmentWriter,
+    SessionCommandPayload, SessionCommandStatus, SessionDoc,
 };
 use zeron_proto::{FolderEntry, FolderListing, RepoRef, Session, SessionStatus};
 
@@ -32,7 +32,6 @@ use crate::config::{DemoOptions, StreamSpeed};
 use crate::error::{ClientError, Result};
 use crate::rpc::ProgressFn;
 use crate::session::SessionCore;
-use crate::workspace::WorkspaceStore;
 use crate::{lock, now_ms};
 
 use transcripts::Step;
@@ -43,46 +42,6 @@ const ADOPT_DELAY: Duration = Duration::from_millis(180);
 const HEARTBEAT: Duration = Duration::from_secs(10);
 const LEASE_MS: i64 = 60_000;
 
-/// In-process registry room: merges pushed op batches into server rows and
-/// broadcasts them back (the mock server's merge, minus the socket).
-#[derive(Default)]
-pub(crate) struct DemoServer {
-    rows: HashMap<(String, String), RegistryRow>,
-    seq: u64,
-}
-
-impl DemoServer {
-    fn settle(&mut self, doc: &mut RegistryDoc) {
-        loop {
-            let batches = doc.take_pushable();
-            if batches.is_empty() {
-                return;
-            }
-            for batch in batches {
-                let mut touched = Vec::new();
-                for op in &batch.ops {
-                    self.apply(op, &mut touched);
-                }
-                self.seq = self.seq.max(doc.cursor()) + 1;
-                let _ = doc.apply_rows(self.seq, touched);
-                doc.ack_batch(&batch.batch, self.seq);
-            }
-        }
-    }
-
-    fn apply(&mut self, op: &RowOp, touched: &mut Vec<RegistryRow>) {
-        let key = (op.kind.clone(), op.id.clone());
-        let (next, changed) = apply_op(self.rows.get(&key), op);
-        if let Some(mut row) = next
-            && changed
-        {
-            row.seq = self.seq + 1;
-            self.rows.insert(key, row.clone());
-            touched.push(row);
-        }
-    }
-}
-
 /// A tiny deterministic PRNG (xorshift64*): demo cadence is reproducible.
 struct Rng(u64);
 
@@ -109,7 +68,6 @@ struct Lease {
 pub(crate) struct DemoHost {
     options: DemoOptions,
     client: Weak<ClientInner>,
-    server: Mutex<DemoServer>,
     refs: Mutex<HashMap<String, Vec<RepoRef>>>,
     /// Running turn per chat: (turn id, cancel token).
     turns: Mutex<HashMap<String, (u64, CancellationToken)>>,
@@ -132,7 +90,6 @@ impl DemoHost {
         Arc::new(Self {
             options,
             client: Arc::downgrade(client),
-            server: Mutex::new(DemoServer::default()),
             refs: Mutex::new(HashMap::new()),
             turns: Mutex::new(HashMap::new()),
             turn_seq: AtomicU64::new(1),
@@ -164,16 +121,10 @@ impl DemoHost {
         for status in seeded.change_requests {
             client.workspace.put_change_request(status);
         }
-        self.settle_registry(&client.workspace);
         self.beat_presence(client);
         Ok(())
     }
 
-    pub(crate) fn settle_registry(&self, workspace: &WorkspaceStore) {
-        let mut server = lock(&self.server);
-        workspace.mutate(|doc| server.settle(doc));
-    }
-
     fn beat_presence(&self, client: &ClientInner) {
         let now = now_ms();
         for device in fixtures::ONLINE {
diff --git a/crates/client/src/workspace/mod.rs b/crates/client/src/workspace/mod.rs
index a0ad5d3e50..2b919de375 100644
--- a/crates/client/src/workspace/mod.rs
+++ b/crates/client/src/workspace/mod.rs
@@ -1,8 +1,8 @@
 //! The workspace registry replica and its derived [`WorkspaceSnapshot`].
 //!
 //! The replica is a [`RegistryDoc`] shared (`Arc<Mutex<_>>`) with the
-//! `zeron_sync::RegistryClient` in live mode; Demo mode settles local writes
-//! through an in-process stand-in for the registry room. Reads materialize
+//! `zeron_sync::RegistryClient` in live mode; Demo mode's replica is
+//! local-only (writes fold straight into its rows). Reads materialize
 //! the rows once per registry *generation* (cached), so the 1 Hz time-driven
 //! re-derivation (staleness, presence expiry, send grace) never re-decodes.
 
diff --git a/crates/doc/src/registry.rs b/crates/doc/src/registry.rs
index 28a078cee6..eb28b36bcf 100644
--- a/crates/doc/src/registry.rs
+++ b/crates/doc/src/registry.rs
@@ -6,9 +6,17 @@
 //!   `rows` frames (the server merges; clients never re-merge server rows);
 //! - `pending` op batches — local writes not yet acked, replayed over the
 //!   authoritative rows for every read (optimistic overlay), re-pushed on
-//!   reconnect (idempotent by strict-`>` clock compare);
+//!   reconnect (idempotent by strict-`>` clock compare). Repeated writes to
+//!   one row in the unsent tail coalesce ([`coalesce_ops`]) wherever the
+//!   room's outcome — rows AND push notifications — stays identical, so an
+//!   offline queue grows with rows touched and status transitions, not with
+//!   writes made (see `RegistryDoc::coalesce_unsent`);
 //! - an HLC clock stamping every local write.
 //!
+//! A local-only replica ([`RegistryDoc::set_local_only`]) has no server to
+//! ack anything: its writes fold straight into `authoritative` and `pending`
+//! stays empty.
+//!
 //! The merge function [`apply_op`] mirrors `edge/src/registry-core.ts` 1:1 —
 //! the shared test vectors live in both files; change them together. The
 //! typed API mirrors the old `WorkspaceDoc` surface so `WorkspaceHost` is a
@@ -290,6 +298,111 @@ pub fn row_to_seed_op(row: &RegistryRow) -> RowOp {
     }
 }
 
+/// One op with EXACTLY the effect of applying `a` then `b` (same row) to any
+/// row state — live, tombstoned, or missing — or `None` when no single op
+/// can express the pair. Per-field writes always merge (newest clock wins, a
+/// tie keeps `a`, as in [`apply_op`]); what can break exactness is
+/// existence: an update never creates/revives, and an upsert revives a
+/// tombstone on its own `hlc` with ALL its fields. So:
+/// - `b` update: `a` alone decides existence → `a`'s kind and revival clock;
+/// - `b` upsert: exact when `a` (an upsert) can never revive where `b` would
+///   not (`b.hlc <= a.hlc`), or when `b` overwrites every field `a` wrote
+///   with a newer clock — whatever `a` revived or created, `b` replaces;
+/// - deletes compare against the row's clocks at apply time and never fold.
+///
+/// The steady-state writers (full-row session/chat/device upserts, field
+/// updates) all hit the exact cases. A merge whose result the room would
+/// reject as oversized ([`MAX_OP_BYTES`]) is refused too: the inputs stay
+/// separate and each still fits.
+pub fn coalesce_ops(a: &RowOp, b: &RowOp) -> Option<RowOp> {
+    if a.kind != b.kind || a.id != b.id {
+        return None;
+    }
+    let (op, hlc) = match (a.op, b.op) {
+        (OpKind::Delete, _) | (_, OpKind::Delete) => return None,
+        (_, OpKind::Update) => (a.op, a.hlc.clone()),
+        (OpKind::Upsert, OpKind::Upsert) if b.hlc <= a.hlc || shadows(b, a) => {
+            (OpKind::Upsert, a.hlc.clone().max(b.hlc.clone()))
+        }
+        (OpKind::Update, OpKind::Upsert) if shadows(b, a) => (OpKind::Upsert, b.hlc.clone()),
+        _ => return None,
+    };
+    let mut writes: BTreeMap<String, (Value, String)> = BTreeMap::new();
+    for (key, value) in a.set.iter().flatten() {
+        writes.insert(key.clone(), (value.clone(), a.clock_for(key).to_string()));
+    }
+    for (key, value) in b.set.iter().flatten() {
+        let clock = b.clock_for(key);
+        if writes
+            .get(key)
+            .is_none_or(|(_, prev)| hlc_newer(clock, Some(prev)))
+        {
+            writes.insert(key.clone(), (value.clone(), clock.to_string()));
+        }
+    }
+    // Every write keeps its ORIGINAL clock; only those differing from the
+    // op's `hlc` need an explicit override.
+    let mut set = BTreeMap::new();
+    let mut clocks = BTreeMap::new();
+    for (key, (value, clock)) in writes {
+        if clock != hlc {
+            clocks.insert(key.clone(), clock);
+        }
+        set.insert(key, value);
+    }
+    let merged = RowOp {
+        kind: a.kind.clone(),
+        id: a.id.clone(),
+        op,
+        set: Some(set),
+        hlc,
+        clocks: (!clocks.is_empty()).then_some(clocks),
+    };
+    fits_op_budget(&merged).then_some(merged)
+}
+
+/// Per-op serialized budget — the 1:1 mirror of `MAX_OP_BYTES` in
+/// `edge/src/registry-core.ts`; `validateOp` rejects (and with it the whole
+/// batch) any op whose `JSON.stringify` is longer.
+pub const MAX_OP_BYTES: usize = 16 * 1024;
+
+/// Whether `op` passes the room's size check. serde_json's UTF-8 byte count
+/// is never below `JSON.stringify`'s UTF-16 length for the same value, so
+/// this errs toward "too large".
+fn fits_op_budget(op: &RowOp) -> bool {
+    serde_json::to_vec(op).is_ok_and(|bytes| bytes.len() <= MAX_OP_BYTES)
+}
+
+/// The `sessions` fields the room's push notifications switch on
+/// (`notificationFor` in `edge/src/push-notify.ts`): the status indicator
+/// and the completed-turn marker. `updatedAt` only gates staleness, so the
+/// 10 s keepalive touch differs from its predecessor only there.
+fn session_signal(op: &RowOp) -> (Option<&Value>, Option<&Value>) {
+    let field = |name: &str| op.set.as_ref().and_then(|s| s.get(name));
+    (field("status"), field("lastCompletedTurn"))
+}
+
+/// A `chats` op that can change what a session notification sees
+/// (`chatForNotification`: existence/deletion, side-chat origin, archived,
+/// title). Freshness writes (`lastMessage*`, `lastSeenAt`, …) cannot.
+fn chat_gates_notifications(op: &RowOp) -> bool {
+    op.op != OpKind::Update
+        || op.set.as_ref().is_some_and(|s| {
+            ["title", "archived", "parentChatId"]
+                .iter()
+                .any(|k| s.contains_key(*k))
+        })
+}
+
+/// `b` writes every field `a` writes, each with a strictly newer clock.
+fn shadows(b: &RowOp, a: &RowOp) -> bool {
+    let b_set = b.set.as_ref();
+    a.set.iter().flatten().all(|(key, _)| {
+        b_set.is_some_and(|s| s.contains_key(key))
+            && hlc_newer(b.clock_for(key), Some(a.clock_for(key)))
+    })
+}
+
 // ── pending batches ─────────────────────────────────────────────────────────
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -337,6 +450,10 @@ struct PersistedState {
     server_seq: u64,
     gc_floor: u64,
     clock: HlcClock,
+    /// See [`RegistryDoc::local_writes`]. Additive — older snapshots default
+    /// to `false`.
+    #[serde(default)]
+    local_writes: bool,
     rows: Vec<RegistryRow>,
     pending: Vec<PendingBatch>,
 }
@@ -351,6 +468,15 @@ pub struct RegistryDoc {
     gc_floor: u64,
     clock: HlcClock,
     pending: Vec<PendingBatch>,
+    /// No server will ever ack (local profile): writes fold straight into
+    /// `authoritative` — queueing them grew `pending` without bound (a field
+    /// snapshot held 178k never-acked batches for 289 rows). Runtime mode,
+    /// set by the host; not persisted.
+    local_only: bool,
+    /// Writes were folded into `authoritative` that no server has seen. If
+    /// an edge ever attaches to this replica, every row re-seeds once (see
+    /// [`Self::set_local_only`]). Persisted.
+    local_writes: bool,
     /// Bumped on every mutation (local or applied) — the engine host converts
     /// this into watch-channel publishes and snapshot debounces.
     generation: u64,
@@ -365,6 +491,8 @@ impl RegistryDoc {
             gc_floor: 0,
             clock: HlcClock::default(),
             pending: Vec::new(),
+            local_only: false,
+            local_writes: false,
             generation: 0,
         }
     }
@@ -387,6 +515,59 @@ impl RegistryDoc {
         self.pending.len()
     }
 
+    /// Total ops across pending batches (introspection/tests).
+    pub fn pending_ops_len(&self) -> usize {
+        self.pending.iter().map(|b| b.ops.len()).sum()
+    }
+
+    /// Switch local-only mode (see the `local_only` field). Entering it folds
+    /// any queued batches into `authoritative` — nothing can be in flight
+    /// without a transport. Leaving it after local-only writes re-seeds every
+    /// row with its ORIGINAL clocks (the server may hold some of them with
+    /// older values; a full `state` replace would otherwise drop the newer
+    /// local ones), exactly like the server-behind recovery in
+    /// [`Self::apply_state`]. Call before a transport attaches.
+    pub fn set_local_only(&mut self, local_only: bool) {
+        self.local_only = local_only;
+        if local_only {
+            let pending = std::mem::take(&mut self.pending);
+            if pending.is_empty() {
+                return;
+            }
+            let ops: usize = pending.iter().map(|b| b.ops.len()).sum();
+            tracing::info!(
+                batches = pending.len(),
+                ops,
+                "registry: folded queued writes into the local-only replica"
+            );
+            self.generation += 1;
+            self.local_writes = true;
+            for batch in pending {
+                for op in &batch.ops {
+                    self.fold_op(op);
+                }
+            }
+        } else if self.local_writes {
+            self.local_writes = false;
+            let seed: Vec<RowOp> = self
+                .authoritative
+                .values()
+                .flat_map(|m| m.values())
+                .map(row_to_seed_op)
+                .collect();
+            self.enqueue_ops(seed);
+        }
+    }
+
+    /// Apply one op straight to the authoritative row — the same step the
+    /// overlay replays, made permanent.
+    fn fold_op(&mut self, op: &RowOp) {
+        let row = self.authoritative.get(&op.kind).and_then(|m| m.get(&op.id));
+        if let (Some(next), true) = apply_op(row, op) {
+            self.put_authoritative(next);
+        }
+    }
+
     // ── persistence ─────────────────────────────────────────────────────────
 
     // (see PersistedState::resync_epoch)
@@ -404,6 +585,7 @@ impl RegistryDoc {
             server_seq: self.server_seq,
             gc_floor: self.gc_floor,
             clock: self.clock.clone(),
+            local_writes: self.local_writes,
             rows,
             pending: self.pending.clone(),
         };
@@ -432,6 +614,7 @@ impl RegistryDoc {
         }
         doc.gc_floor = state.gc_floor;
         doc.clock = state.clock;
+        doc.local_writes = state.local_writes;
         doc.pending = state.pending;
         for row in state.rows {
             doc.authoritative
@@ -439,6 +622,18 @@ impl RegistryDoc {
                 .or_default()
                 .insert(row.id.clone(), row);
         }
+        // Nothing is in flight after a load, so the whole queue coalesces —
+        // this shrinks snapshots bloated before coalescing existed (178k
+        // batches → one op per touched row). The host persists the result.
+        let before = doc.pending_ops_len();
+        if doc.coalesce_unsent() > 0 {
+            tracing::info!(
+                before,
+                after = doc.pending_ops_len(),
+                batches = doc.pending.len(),
+                "registry: compacted queued writes on load"
+            );
+        }
         Ok(doc)
     }
 
@@ -594,6 +789,14 @@ impl RegistryDoc {
         if ops.is_empty() {
             return;
         }
+        if self.local_only {
+            self.generation += 1;
+            self.local_writes = true;
+            for op in &ops {
+                self.fold_op(op);
+            }
+            return;
+        }
         // The registry room rejects any batch over its op cap (500), and a
         // rejected batch is a PERMANENT wedge: error frames carry no batch
         // id, so the client can never retire it — it replays and fails on
@@ -620,6 +823,132 @@ impl RegistryDoc {
             });
             ops = tail;
         }
+        self.coalesce_unsent();
+    }
+
+    /// Collapse repeated writes to one row across the UNSENT tail of
+    /// `pending` (everything after the last in-flight batch) into single ops
+    /// via [`coalesce_ops`]; returns how many ops were folded away.
+    ///
+    /// The room treats a batch as a unit (`applyPushBatch` in
+    /// `edge/src/registry-room.ts`): validated and committed atomically,
+    /// one seq and one rows broadcast, and push notifications derived from
+    /// each `sessions` row before vs after the WHOLE batch, labelled from the
+    /// chat row after it. So:
+    /// - only single-op batches (one local write each) take part. Multi-op
+    ///   batches — cascade deletes, re-seeds, migration seeds — are written
+    ///   as units and keep every op, in place;
+    /// - a merged op lands at the LATER op's position and the earlier one is
+    ///   removed. Moving an op later only reorders it against other rows,
+    ///   which merge independently — except a session notification reads
+    ///   its chat row, so a session op never moves past a chat op that
+    ///   gates notifications, nor such a chat op past a session op;
+    /// - session ops merge only when status and completed turn match, and
+    ///   the first op of each such run (a potential notification) never
+    ///   absorbs later ones: working→needs-input→working stays three ops,
+    ///   while a run of keepalive touches folds into the run head plus one.
+    ///   Then every batch the room applies yields the same notifications as
+    ///   the unmerged queue (the merged follower can only re-cross the
+    ///   staleness window once, exactly as the touches it replaces would).
+    ///
+    /// Ack safety: in-flight batches are never touched, so an ack always
+    /// retires exactly what was pushed. A tail batch may still have been
+    /// pushed on a dead connection (its late HTTPS ack can race a
+    /// disconnect), so a batch that gained content takes a fresh id: a stale
+    /// ack then retires nothing, and a removed batch's ack finds nothing.
+    /// Re-pushing merged ops is an idempotent LWW replay.
+    fn coalesce_unsent(&mut self) -> usize {
+        let start = self
+            .pending
+            .iter()
+            .rposition(|b| b.in_flight)
+            .map_or(0, |i| i + 1);
+        if self.pending.len().saturating_sub(start) < 2 {
+            return 0;
+        }
+        let mut tail: Vec<(String, Vec<Option<RowOp>>, bool)> = self
+            .pending
+            .split_off(start)
+            .into_iter()
+            .map(|b| (b.batch, b.ops.into_iter().map(Some).collect(), false))
+            .collect();
+        // (kind, id) → (position of that row's latest live op in the tail,
+        // whether that op heads a session-signal run).
+        let mut last: HashMap<(String, String), ((usize, usize), bool)> = HashMap::new();
+        // chat id → position of its latest notification-gating chat op.
+        let mut gating_chat: HashMap<String, (usize, usize)> = HashMap::new();
+        let mut folded = 0;
+        for bi in 0..tail.len() {
+            for oi in 0..tail[bi].1.len() {
+                let Some(op) = tail[bi].1[oi].as_ref() else {
+                    continue;
+                };
+                let here = (bi, oi);
+                let key = (op.kind.clone(), op.id.clone());
+                let prev = last
+                    .get(&key)
+                    .and_then(|&(at, head)| Some((at, head, tail[at.0].1[at.1].as_ref()?)));
+                let session = op.kind == KIND_SESSIONS;
+                let head = session
+                    && prev.is_none_or(|(_, _, p)| {
+                        p.op == OpKind::Delete || session_signal(p) != session_signal(op)
+                    });
+                let merged = prev.and_then(|(at, prev_head, prev_op)| {
+                    let single = tail[bi].1.len() == 1 && tail[at.0].1.len() == 1;
+                    let may_move = if session {
+                        !head && !prev_head && !gating_chat.get(&op.id).is_some_and(|&c| c > at)
+                    } else if op.kind == KIND_CHATS && chat_gates_notifications(prev_op) {
+                        !last
+                            .get(&(KIND_SESSIONS.to_string(), op.id.clone()))
+                            .is_some_and(|&(s, _)| s > at)
+                    } else {
+                        true
+                    };
+                    (single && may_move)
+                        .then(|| coalesce_ops(prev_op, op))
+                        .flatten()
+                        .map(|merged| (at, merged))
+                });
+                if let Some((at, merged)) = merged {
+                    tail[at.0].1[at.1] = None;
+                    tail[bi].1[oi] = Some(merged);
+                    tail[bi].2 = true;
+                    folded += 1;
+                }
+                let op = tail[bi].1[oi].as_ref().expect("op stays live");
+                if op.kind == KIND_CHATS && chat_gates_notifications(op) {
+                    gating_chat.insert(op.id.clone(), here);
+                }
+                last.insert(key, (here, head));
+            }
+        }
+        if folded == 0 {
+            self.pending
+                .extend(tail.into_iter().map(|(batch, ops, _)| PendingBatch {
+                    batch,
+                    ops: ops.into_iter().flatten().collect(),
+                    in_flight: false,
+                }));
+            return 0;
+        }
+        for (batch, ops, gained) in tail {
+            let ops: Vec<RowOp> = ops.into_iter().flatten().collect();
+            if ops.is_empty() {
+                continue;
+            }
+            let batch = if gained {
+                format!("b-{}", self.next_hlc())
+            } else {
+                batch
+            };
+            self.pending.push(PendingBatch {
+                batch,
+                ops,
+                in_flight: false,
+            });
+        }
+        self.generation += 1;
+        folded
     }
 
     fn write(&mut self, kind: &str, id: &str, op: OpKind, set: BTreeMap<String, Value>) {
@@ -652,42 +981,42 @@ impl RegistryDoc {
 
     // ── overlay reads ───────────────────────────────────────────────────────
 
+    fn pending_ops(&self) -> impl Iterator<Item = &RowOp> {
+        self.pending.iter().flat_map(|b| &b.ops)
+    }
+
     /// The row as this device should display it: authoritative + pending ops.
     fn overlay_row(&self, kind: &str, id: &str) -> Option<RegistryRow> {
-        let mut row = self
-            .authoritative
-            .get(kind)
-            .and_then(|m| m.get(id))
-            .cloned();
-        for batch in &self.pending {
-            for op in &batch.ops {
-                if op.kind == kind && op.id == id {
-                    let (next, _) = apply_op(row.as_ref(), op);
-                    if let Some(next) = next {
-                        row = Some(next);
-                    }
-                }
-            }
-        }
-        row.filter(|r| !r.deleted)
+        overlay(
+            self.authoritative.get(kind).and_then(|m| m.get(id)),
+            self.pending_ops()
+                .filter(|op| op.kind == kind && op.id == id),
+        )
     }
 
-    /// All live rows of `kind`, overlay applied.
+    /// All live rows of `kind`, overlay applied. Pending ops are grouped by
+    /// row in one pass — rescanning the queue per row made every read
+    /// O(rows × pending).
     fn overlay_rows(&self, kind: &str) -> Vec<RegistryRow> {
-        let mut ids: Vec<String> = self
-            .authoritative
-            .get(kind)
-            .map(|m| m.keys().cloned().collect())
+        let authoritative = self.authoritative.get(kind);
+        let mut ids: Vec<&str> = authoritative
+            .map(|m| m.keys().map(String::as_str).collect())
             .unwrap_or_default();
-        for batch in &self.pending {
-            for op in &batch.ops {
-                if op.kind == kind && !ids.iter().any(|id| id == &op.id) {
-                    ids.push(op.id.clone());
-                }
+        let mut ops: HashMap<&str, Vec<&RowOp>> = HashMap::new();
+        for op in self.pending_ops().filter(|op| op.kind == kind) {
+            let row_ops = ops.entry(op.id.as_str()).or_default();
+            if row_ops.is_empty() && !authoritative.is_some_and(|m| m.contains_key(&op.id)) {
+                ids.push(&op.id);
             }
+            row_ops.push(op);
         }
-        ids.iter()
-            .filter_map(|id| self.overlay_row(kind, id))
+        ids.into_iter()
+            .filter_map(|id| {
+                overlay(
+                    authoritative.and_then(|m| m.get(id)),
+                    ops.get(id).into_iter().flatten().copied(),
+                )
+            })
             .collect()
     }
 
@@ -1368,6 +1697,22 @@ impl RegistryDoc {
     }
 }
 
+/// Replay `ops` (one row's, in queue order) over its authoritative state;
+/// `None` when the result is missing or a tombstone.
+fn overlay<'a>(
+    base: Option<&RegistryRow>,
+    ops: impl IntoIterator<Item = &'a RowOp>,
+) -> Option<RegistryRow> {
+    let mut row = base.cloned();
+    for op in ops {
+        let (next, _) = apply_op(row.as_ref(), op);
+        if let Some(next) = next {
+            row = Some(next);
+        }
+    }
+    row.filter(|r| !r.deleted)
+}
+
 // ── field helpers ───────────────────────────────────────────────────────────
 
 fn fields<const N: usize>(entries: [(&str, Value); N]) -> BTreeMap<String, Value> {
diff --git a/crates/doc/src/registry/tests.rs b/crates/doc/src/registry/tests.rs
index 6d7e1ef8fa..dec98ed2fd 100644
--- a/crates/doc/src/registry/tests.rs
+++ b/crates/doc/src/registry/tests.rs
@@ -1527,3 +1527,622 @@ fn side_chat_origin_syncs_and_survives_updates_and_restart() {
         Some("main")
     );
 }
+
+// ── bounded pending: local-only folding and tail coalescing ─────────────────
+
+/// Deterministic xorshift — random op shapes without a rand dependency.
+struct Rng(u64);
+
+impl Rng {
+    fn next(&mut self, n: u64) -> u64 {
+        self.0 ^= self.0 << 13;
+        self.0 ^= self.0 >> 7;
+        self.0 ^= self.0 << 17;
+        self.0 % n
+    }
+
+    fn hlc(&mut self) -> String {
+        let device = if self.next(2) == 0 { "dev-a" } else { "dev-b" };
+        encode_hlc(1 + self.next(12) as i64, 0, device)
+    }
+
+    /// An op on `chats/chat-1` with a random kind, field subset (nulls
+    /// included), revival clock and per-field clock overrides.
+    fn op(&mut self) -> RowOp {
+        let kind = match self.next(5) {
+            0 => OpKind::Delete,
+            1 | 2 => OpKind::Update,
+            _ => OpKind::Upsert,
+        };
+        let mut set = BTreeMap::new();
+        let mut clocks = BTreeMap::new();
+        for field in ["a", "b", "c"] {
+            if self.next(3) == 0 {
+                continue;
+            }
+            let value = match self.next(4) {
+                0 => Value::Null,
+                v => json!(v),
+            };
+            set.insert(field.to_string(), value);
+            if self.next(3) == 0 {
+                clocks.insert(field.to_string(), self.hlc());
+            }
+        }
+        RowOp {
+            kind: "chats".into(),
+            id: "chat-1".into(),
+            op: kind,
+            set: (kind != OpKind::Delete).then_some(set),
+            hlc: self.hlc(),
+            clocks: (kind != OpKind::Delete && !clocks.is_empty()).then_some(clocks),
+        }
+    }
+}
+
+/// Overlay-style sequential replay (tombstones kept, so they compare too).
+fn replay(base: Option<RegistryRow>, ops: &[&RowOp]) -> Option<RegistryRow> {
+    let mut row = base;
+    for op in ops {
+        if let Some(next) = apply_op(row.as_ref(), op).0 {
+            row = Some(next);
+        }
+    }
+    row
+}
+
+#[test]
+fn coalesced_ops_are_exact_on_every_row_state() {
+    let mut rng = Rng(0x5eed_cafe_f00d);
+    let mut merged = 0;
+    for _ in 0..50_000 {
+        // Bases: missing, live, tombstoned and revived rows with mixed clocks.
+        let history: Vec<RowOp> = (0..rng.next(4)).map(|_| rng.op()).collect();
+        let base = replay(None, &history.iter().collect::<Vec<_>>());
+        let (a, b) = (rng.op(), rng.op());
+        let Some(c) = coalesce_ops(&a, &b) else {
+            continue;
+        };
+        merged += 1;
+        assert_eq!(
+            replay(base.clone(), &[&c]),
+            replay(base.clone(), &[&a, &b]),
+            "a={a:?}\nb={b:?}\nc={c:?}\nbase={base:?}"
+        );
+    }
+    assert!(merged > 10_000, "only {merged} pairs coalesced");
+}
+
+#[test]
+fn steady_state_writers_coalesce_to_a_bounded_queue() {
+    let mut doc = RegistryDoc::new("dev-a");
+    doc.upsert_chat(&chat("chat-1", "dev-a")).unwrap();
+    for i in 0..500 {
+        let mut touch = session("chat-1", "dev-a", SessionStatus::Working);
+        touch.updated_at = ts(10_000 + i * 10_000);
+        doc.upsert_session(&touch).unwrap();
+        doc.set_chat_last_message("chat-1", &format!("msg {i}"), ts(10_000 + i))
+            .unwrap();
+    }
+    doc.rename_chat("chat-1", "Renamed").unwrap();
+    // chat: the creating upsert (it gates notifications, so it never moves
+    // past the session touches) + every later update folded into one;
+    // sessions: the run head + one op for the other 499 keepalives.
+    assert_eq!(doc.pending_ops_len(), 4);
+    let chat = doc.chat("chat-1").unwrap().unwrap();
+    assert_eq!(chat.title.as_deref(), Some("Renamed"));
+    assert_eq!(chat.last_message_preview.as_deref(), Some("msg 499"));
+    assert_eq!(
+        doc.read_sessions().unwrap()[0].updated_at,
+        ts(10_000 + 499 * 10_000)
+    );
+}
+
+/// Session statuses of the queued `sessions` ops, in push order.
+fn queued_statuses(doc: &RegistryDoc) -> Vec<String> {
+    doc.pending_ops()
+        .filter(|op| op.kind == KIND_SESSIONS)
+        .map(|op| op.set.as_ref().unwrap()["status"].as_str().unwrap().into())
+        .collect()
+}
+
+#[test]
+fn status_changes_never_coalesce_but_keepalives_do() {
+    let mut doc = RegistryDoc::new("dev-a");
+    let mut at = 10_000;
+    let mut touch = |doc: &mut RegistryDoc, status| {
+        at += 10_000;
+        let mut row = session("chat-1", "dev-a", status);
+        row.updated_at = ts(at);
+        doc.upsert_session(&row).unwrap();
+    };
+    touch(&mut doc, SessionStatus::Working);
+    touch(&mut doc, SessionStatus::AwaitingInput);
+    touch(&mut doc, SessionStatus::Working);
+    // working → needs input → working: each transition can raise a push.
+    assert_eq!(
+        queued_statuses(&doc),
+        ["working", "awaitingInput", "working"]
+    );
+    for _ in 0..50 {
+        touch(&mut doc, SessionStatus::Working);
+    }
+    // The keepalives fold into one op behind the run head.
+    assert_eq!(
+        queued_statuses(&doc),
+        ["working", "awaitingInput", "working", "working"]
+    );
+}
+
+/// Mirror of `notificationFor` (edge/src/push-notify.ts).
+fn notification(
+    before: Option<&RegistryRow>,
+    after: &RegistryRow,
+    now: i64,
+) -> Option<&'static str> {
+    let before = before.filter(|r| !r.deleted)?;
+    if after.deleted {
+        return None;
+    }
+    let indicator = |row: &RegistryRow| {
+        let updated = row
+            .fields
+            .get("updatedAt")
+            .and_then(Value::as_i64)
+            .unwrap_or(0);
+        match row.fields.get("status").and_then(Value::as_str) {
+            Some("errored") => "errored",
+            Some("working") if now - updated <= 45_000 => "working",
+            Some("awaitingInput") if now - updated <= 45_000 => "awaiting",
+            _ => "none",
+        }
+    };
+    let (prev, next) = (indicator(before), indicator(after));
+    if next == "errored" && prev != "errored" {
+        return Some("failed");
+    }
+    if next == "awaiting" && prev != "awaiting" {
+        return Some("input");
+    }
+    let turn = |row: &RegistryRow| {
+        row.fields
+            .get("lastCompletedTurn")
+            .and_then(Value::as_str)
+            .map(str::to_owned)
+    };
+    let updated = after
+        .fields
+        .get("updatedAt")
+        .and_then(Value::as_i64)
+        .unwrap_or(0);
+    let fresh = now - updated <= 45_000;
+    (fresh && turn(after).is_some() && turn(after) != turn(before)).then_some("done")
+}
+
+/// Push `batches` the way the room does: apply each atomically, then derive
+/// one notification per touched session from its before/after rows.
+fn pushed_notifications(
+    base: &HashMap<(String, String), RegistryRow>,
+    batches: &[Vec<RowOp>],
+    now: i64,
+) -> Vec<&'static str> {
+    let mut rows = base.clone();
+    let mut out = Vec::new();
+    for batch in batches {
+        let mut before: HashMap<String, Option<RegistryRow>> = HashMap::new();
+        for op in batch {
+            let key = (op.kind.clone(), op.id.clone());
+            if op.kind == KIND_SESSIONS {
+                before
+                    .entry(op.id.clone())
+                    .or_insert_with(|| rows.get(&key).cloned());
+            }
+            if let (Some(next), true) = apply_op(rows.get(&key), op) {
+                rows.insert(key, next);
+            }
+        }
+        for (id, prev) in before {
+            if let Some(after) = rows.get(&(KIND_SESSIONS.to_string(), id)) {
+                out.extend(notification(prev.as_ref(), after, now));
+            }
+        }
+    }
+    out
+}
+
+#[test]
+fn coalescing_preserves_every_push_notification() {
+    let mut rng = Rng(0xa1e7_5eed);
+    let statuses = ["working", "awaitingInput", "errored", "idle"];
+    let mut notified = 0;
+    for _ in 0..300 {
+        let mut doc = RegistryDoc::new("dev-a");
+        let mut base = HashMap::new();
+        let mut at = 100_000 + rng.next(100_000) as i64;
+        let mut turn = 0;
+        let row_for = |rng: &mut Rng, at: &mut i64, turn: &mut i32, ms: i64| {
+            *at += 1 + rng.next(30_000) as i64;
+            if rng.next(4) == 0 {
+                *turn += 1;
+            }
+            let set: BTreeMap<String, Value> = [
+                ("chatId".to_string(), json!("chat-1")),
+                ("status".to_string(), json!(statuses[rng.next(4) as usize])),
+                ("lastCompletedTurn".to_string(), json!(format!("t{turn}"))),
+                ("updatedAt".to_string(), json!(*at)),
+            ]
+            .into();
+            RowOp {
+                kind: KIND_SESSIONS.into(),
+                id: "chat-1".into(),
+                op: OpKind::Upsert,
+                set: Some(set),
+                hlc: encode_hlc(ms, 0, "dev-a"),
+                clocks: None,
+            }
+        };
+        // The room already holds an older version of the row.
+        let seed = row_for(&mut rng, &mut at, &mut turn, 1);
+        base.insert(
+            (KIND_SESSIONS.to_string(), "chat-1".to_string()),
+            apply_op(None, &seed).0.unwrap(),
+        );
+        // Long status runs (keepalives) with occasional transitions.
+        let mut ops = Vec::new();
+        let mut current = row_for(&mut rng, &mut at, &mut turn, 2);
+        for i in 0..20 + rng.next(40) as i64 {
+            if rng.next(6) == 0 {
+                current = row_for(&mut rng, &mut at, &mut turn, 3 + i);
+            } else {
+                at += 1 + rng.next(30_000) as i64;
+                let set = current.set.as_mut().unwrap();
+                set.insert("updatedAt".into(), json!(at));
+                current.hlc = encode_hlc(3 + i, 0, "dev-a");
+            }
+            ops.push(current.clone());
+            doc.enqueue_ops(vec![current.clone()]);
+        }
+        let original: Vec<Vec<RowOp>> = ops.iter().map(|op| vec![op.clone()]).collect();
+        let coalesced: Vec<Vec<RowOp>> = doc.pending.iter().map(|b| b.ops.clone()).collect();
+        assert!(coalesced.len() <= original.len());
+        // Any push time: before, during and after the queued window.
+        for _ in 0..8 {
+            let now = 100_000 + rng.next((at - 50_000).max(1) as u64 + 200_000) as i64;
+            let expected = pushed_notifications(&base, &original, now);
+            assert_eq!(
+                pushed_notifications(&base, &coalesced, now),
+                expected,
+                "now={now}"
+            );
+            notified += expected.len();
+        }
+    }
+    assert!(notified > 500, "only {notified} notifications exercised");
+}
+
+#[test]
+fn a_session_op_never_moves_past_a_notification_gating_chat_op() {
+    let mut doc = RegistryDoc::new("dev-a");
+    doc.upsert_chat(&chat("chat-1", "dev-a")).unwrap();
+    let touch = |doc: &mut RegistryDoc, ms| {
+        let mut row = session("chat-1", "dev-a", SessionStatus::Working);
+        row.updated_at = ts(ms);
+        doc.upsert_session(&row).unwrap();
+    };
+    touch(&mut doc, 10_000);
+    touch(&mut doc, 20_000);
+    // Archiving silences the chat's pushes: the follower touch before it
+    // must not be carried past it (nor the archive past the next touch).
+    doc.set_chat_archived("chat-1", true).unwrap();
+    touch(&mut doc, 30_000);
+    let order: Vec<(String, bool)> = doc
+        .pending_ops()
+        .map(|op| {
+            (
+                op.kind.clone(),
+                op.set
+                    .as_ref()
+                    .is_some_and(|s| s.contains_key("archived") && op.op == OpKind::Update),
+            )
+        })
+        .collect();
+    assert_eq!(
+        order,
+        [
+            ("chats".to_string(), false),
+            ("sessions".to_string(), false),
+            ("sessions".to_string(), false),
+            ("chats".to_string(), true),
+            ("sessions".to_string(), false),
+        ]
+    );
+    // Freshness writes gate nothing and still fold across session touches.
+    let before = doc.pending_ops_len();
+    for i in 0..20 {
+        doc.set_chat_last_message("chat-1", &format!("m{i}"), ts(40_000 + i))
+            .unwrap();
+        touch(&mut doc, 40_000 + i * 1_000);
+    }
+    assert!(
+        doc.pending_ops_len() <= before + 2,
+        "{}",
+        doc.pending_ops_len()
+    );
+}
+
+#[test]
+fn merges_that_would_exceed_the_op_budget_stay_separate() {
+    let big = |field: &str, at: i64| {
+        let mut op = update(&[(field, json!("x".repeat(9 * 1024)))], hlc(at));
+        op.kind = KIND_SPACES.into();
+        op
+    };
+    let (a, b) = (big("name", 1), big("path", 2));
+    assert!(fits_op_budget(&a) && fits_op_budget(&b));
+    assert_eq!(coalesce_ops(&a, &b), None);
+    // Same field: the merge is no larger than `b`, so it folds.
+    assert!(coalesce_ops(&a, &big("name", 2)).is_some());
+
+    let mut doc = RegistryDoc::new("dev-a");
+    doc.enqueue_ops(vec![a.clone()]);
+    doc.enqueue_ops(vec![b.clone()]);
+    assert_eq!(doc.pending_ops_len(), 2);
+    for batch in doc.take_pushable() {
+        assert!(batch.ops.iter().all(fits_op_budget));
+    }
+}
+
+#[test]
+fn multi_op_batches_keep_their_ops_in_place() {
+    let mut doc = RegistryDoc::new("dev-a");
+    let state = WorkspaceState {
+        devices: vec![device("dev-a", "laptop")],
+        spaces: vec![space("space-1", "dev-a", "/p")],
+        chats: vec![chat("chat-1", "dev-a")],
+        sessions: vec![],
+    };
+    doc.seed_from_workspace(&state).unwrap();
+    let seed = doc.pending[0].clone();
+    assert_eq!(seed.ops.len(), 3);
+    for i in 0..5 {
+        doc.rename_chat("chat-1", &format!("t{i}")).unwrap();
+    }
+    // The migration batch is untouched (id and every op); the renames fold
+    // among themselves.
+    assert_eq!(doc.pending[0].batch, seed.batch);
+    assert_eq!(doc.pending[0].ops, seed.ops);
+    assert_eq!(doc.pending_ops_len(), 4);
+    assert_eq!(
+        doc.chat("chat-1").unwrap().unwrap().title.as_deref(),
+        Some("t4")
+    );
+}
+
+#[test]
+fn tail_coalescing_preserves_the_overlay_and_the_server_outcome() {
+    let mut rng = Rng(0x0dd_ba11);
+    for _ in 0..300 {
+        let mut doc = RegistryDoc::new("dev-a");
+        let history: Vec<RowOp> = (0..rng.next(4)).map(|_| rng.op()).collect();
+        let base = replay(None, &history.iter().collect::<Vec<_>>());
+        if let Some(row) = base.clone() {
+            doc.put_authoritative(row);
+        }
+        let ops: Vec<RowOp> = (0..1 + rng.next(30)).map(|_| rng.op()).collect();
+        for op in &ops {
+            doc.enqueue_ops(vec![op.clone()]);
+        }
+        let expected = replay(base.clone(), &ops.iter().collect::<Vec<_>>());
+        assert!(doc.pending_ops_len() <= ops.len());
+        // The local overlay…
+        assert_eq!(
+            doc.overlay_row("chats", "chat-1"),
+            expected.clone().filter(|r| !r.deleted)
+        );
+        // …and a server holding the same base row applying the pushed queue.
+        let pushed: Vec<RowOp> = doc
+            .take_pushable()
+            .into_iter()
+            .flat_map(|b| b.ops)
+            .collect();
+        assert_eq!(replay(base, &pushed.iter().collect::<Vec<_>>()), expected);
+    }
+}
+
+#[test]
+fn in_flight_batches_are_never_coalesced_and_still_ack() {
+    let mut doc = RegistryDoc::new("dev-a");
+    doc.upsert_chat(&chat("chat-1", "dev-a")).unwrap();
+    let sent = doc.take_pushable();
+    assert_eq!(sent.len(), 1);
+    for i in 0..10 {
+        doc.rename_chat("chat-1", &format!("title {i}")).unwrap();
+    }
+    // The in-flight upsert keeps its id and ops; the ten renames are one op.
+    assert_eq!(doc.pending_len(), 2);
+    assert_eq!(doc.pending[0].batch, sent[0].batch);
+    assert_eq!(doc.pending[0].ops, sent[0].ops);
+    assert_eq!(doc.pending[1].ops.len(), 1);
+    // The room broadcasts merged rows before the ack.
+    assert!(doc.apply_rows(1, vec![applied(None, &sent[0].ops[0])]));
+    assert!(doc.ack_batch(&sent[0].batch, 1));
+    assert_eq!(doc.pending_len(), 1);
+    assert_eq!(
+        doc.chat("chat-1").unwrap().unwrap().title.as_deref(),
+        Some("title 9")
+    );
+    let renames = doc.take_pushable();
+    assert!(doc.ack_batch(&renames[0].batch, 2));
+    assert_eq!(doc.pending_len(), 0);
+}
+
+#[test]
+fn a_late_ack_for_a_coalesced_away_batch_cannot_drop_newer_writes() {
+    let mut doc = RegistryDoc::new("dev-a");
+    doc.upsert_chat(&chat("chat-1", "dev-a")).unwrap();
+    // Pushed over HTTPS, then the socket drops before the ack lands.
+    let raced = doc.take_pushable().pop().unwrap();
+    doc.mark_disconnected();
+    doc.rename_chat("chat-1", "after the drop").unwrap();
+    // The upsert folded forward into a batch under a FRESH id…
+    assert_eq!(doc.pending_len(), 1);
+    assert_ne!(doc.pending[0].batch, raced.batch);
+    // …so the stale ack retires nothing and the rename still pushes.
+    assert!(!doc.ack_batch(&raced.batch, 1));
+    assert_eq!(doc.pending_ops_len(), 1);
+    assert_eq!(
+        doc.chat("chat-1").unwrap().unwrap().title.as_deref(),
+        Some("after the drop")
+    );
+}
+
+#[test]
+fn local_only_writes_fold_and_keep_pending_empty() {
+    let mut local = RegistryDoc::new("dev-a");
+    local.set_local_only(true);
+    let mut queued = RegistryDoc::new("dev-a");
+    for doc in [&mut local, &mut queued] {
+        doc.upsert_device(&device("dev-a", "laptop")).unwrap();
+        doc.upsert_space(&space("space-1", "dev-a", "/p")).unwrap();
+        doc.upsert_chat(&chat("chat-1", "dev-a")).unwrap();
+        doc.upsert_chat(&chat("chat-2", "dev-a")).unwrap();
+        for _ in 0..50 {
+            doc.upsert_session(&session("chat-1", "dev-a", SessionStatus::Working))
+                .unwrap();
+        }
+        doc.rename_chat("chat-1", "renamed").unwrap();
+        doc.delete_chat("chat-2").unwrap();
+        pin_sessions(doc, &["chat-1"]);
+    }
+    assert_eq!(local.pending_len(), 0);
+    assert!(queued.pending_len() > 0);
+    assert_eq!(local.read_all().unwrap(), queued.read_all().unwrap());
+    assert_eq!(local.sidebar_preferences(), queued.sidebar_preferences());
+    assert_eq!(local.read_chats().unwrap().len(), 1);
+}
+
+/// A pre-fix snapshot: every write its own batch, none ever acked. Marking
+/// each batch in flight as it is written keeps the doc from coalescing,
+/// and `in_flight` is not persisted, so the snapshot reloads all-unsent.
+fn bloated_snapshot() -> (Vec<u8>, Vec<RowOp>) {
+    let mut doc = RegistryDoc::new("dev-a");
+    let mut ops = Vec::new();
+    let mut write = |doc: &mut RegistryDoc, f: &dyn Fn(&mut RegistryDoc)| {
+        f(doc);
+        ops.extend(doc.take_pushable().into_iter().flat_map(|b| b.ops));
+    };
+    write(&mut doc, &|d| {
+        d.upsert_device(&device("dev-a", "laptop")).unwrap()
+    });
+    write(&mut doc, &|d| {
+        d.upsert_chat(&chat("chat-1", "dev-a")).unwrap()
+    });
+    write(&mut doc, &|d| {
+        d.upsert_chat(&chat("chat-2", "dev-a")).unwrap()
+    });
+    for i in 0..2_000 {
+        write(&mut doc, &|d| {
+            d.upsert_session(&session("chat-1", "dev-a", SessionStatus::Working))
+                .unwrap()
+        });
+        if i % 10 == 0 {
+            write(&mut doc, &|d| {
+                d.set_chat_seen("chat-1", ts(5_000 + i)).unwrap();
+            });
+        }
+    }
+    write(&mut doc, &|d| {
+        d.delete_chat("chat-2").unwrap();
+    });
+    assert_eq!(doc.pending_ops_len(), ops.len());
+    (doc.to_bytes().unwrap(), ops)
+}
+
+#[test]
+fn loading_a_bloated_snapshot_coalesces_it() {
+    let (bytes, ops) = bloated_snapshot();
+    assert!(ops.len() > 2_000);
+    let doc = RegistryDoc::from_bytes(&bytes, "dev-a").unwrap();
+    // device; chat-1's creating upsert + its folded seen-markers; session-1's
+    // run head + folded keepalives; chat-2's upsert and its two-op delete
+    // batch (deletes never fold, multi-op batches stay whole) — 8, not 2k.
+    assert_eq!(doc.pending_ops_len(), 8);
+    let expected = {
+        let mut server = HashMap::new();
+        for op in &ops {
+            let key = (op.kind.clone(), op.id.clone());
+            if let Some(next) = apply_op(server.get(&key), op).0 {
+                server.insert(key, next);
+            }
+        }
+        server
+    };
+    // Pushing the compacted queue lands the server on the same rows.
+    let mut server = HashMap::new();
+    let mut seq = 0;
+    let mut doc = doc;
+    server_round(&mut server, &mut seq, &mut [&mut doc]);
+    assert_eq!(server.len(), expected.len());
+    for (key, row) in &expected {
+        let got = &server[key];
+        assert_eq!(
+            (&got.fields, &got.clocks, got.deleted),
+            (&row.fields, &row.clocks, row.deleted)
+        );
+    }
+    assert!(doc.to_bytes().unwrap().len() * 50 < bytes.len());
+}
+
+#[test]
+fn loading_a_bloated_snapshot_local_only_folds_it() {
+    let (bytes, _) = bloated_snapshot();
+    let queued = RegistryDoc::from_bytes(&bytes, "dev-a").unwrap();
+    let mut doc = RegistryDoc::from_bytes(&bytes, "dev-a").unwrap();
+    doc.set_local_only(true);
+    assert_eq!(doc.pending_len(), 0);
+    assert_eq!(doc.read_all().unwrap(), queued.read_all().unwrap());
+    // The compacted snapshot round-trips with nothing queued.
+    let compact = doc.to_bytes().unwrap();
+    assert!(compact.len() * 50 < bytes.len());
+    let restored = RegistryDoc::from_bytes(&compact, "dev-a").unwrap();
+    assert_eq!(restored.pending_len(), 0);
+    assert_eq!(restored.read_all().unwrap(), queued.read_all().unwrap());
+}
+
+#[test]
+fn attaching_an_edge_after_local_only_writes_reseeds_them() {
+    // Synced once, then edited with no edge (e.g. a dev profile run
+    // without a token), then attached again.
+    let mut doc = RegistryDoc::new("dev-a");
+    doc.upsert_chat(&chat("chat-1", "dev-a")).unwrap();
+    let mut server = HashMap::new();
+    let mut seq = 0;
+    server_round(&mut server, &mut seq, &mut [&mut doc]);
+    let mut doc = RegistryDoc::from_bytes(&doc.to_bytes().unwrap(), "dev-a").unwrap();
+    doc.set_local_only(true);
+    doc.rename_chat("chat-1", "offline edit").unwrap();
+    doc.upsert_chat(&chat("chat-2", "dev-a")).unwrap();
+    assert_eq!(doc.pending_len(), 0);
+
+    // The flag survives a restart; leaving local-only queues a re-seed.
+    let mut doc = RegistryDoc::from_bytes(&doc.to_bytes().unwrap(), "dev-a").unwrap();
+    doc.set_local_only(false);
+    assert!(doc.pending_len() > 0);
+    // A full state carrying the server's OLDER chat-1 must not erase the
+    // offline rename: the re-seed overlays it and wins LWW on push.
+    let rows: Vec<RegistryRow> = server.values().cloned().collect();
+    doc.apply_state(seq, true, 0, rows);
+    let title = |d: &RegistryDoc| d.chat("chat-1").unwrap().unwrap().title;
+    assert_eq!(title(&doc).as_deref(), Some("offline edit"));
+    server_round(&mut server, &mut seq, &mut [&mut doc]);
+    assert_eq!(doc.pending_len(), 0);
+    assert_eq!(title(&doc).as_deref(), Some("offline edit"));
+    assert_eq!(doc.read_chats().unwrap().len(), 2);
+    let key = ("chats".to_string(), "chat-1".to_string());
+    assert_eq!(server[&key].fields["title"], json!("offline edit"));
+
+    // Re-seeding is one-shot: the next attach queues nothing.
+    let mut doc = RegistryDoc::from_bytes(&doc.to_bytes().unwrap(), "dev-a").unwrap();
+    doc.set_local_only(false);
+    assert_eq!(doc.pending_len(), 0);
+}
diff --git a/crates/engine/src/diff_sync.rs b/crates/engine/src/diff_sync.rs
index 8f2796d9b8..a81dd9b50b 100644
--- a/crates/engine/src/diff_sync.rs
+++ b/crates/engine/src/diff_sync.rs
@@ -15,8 +15,13 @@
 //! is captured by the command host and is never rewritten from this watcher;
 //! otherwise one checkout change would relabel every chat sharing that folder.
 //!
-//! Fast recursive `notify` watchers (debounced [`WATCH_DEBOUNCE`]) are backed by a
-//! slow 2-minute repair tick because native watchers may coalesce or drop events.
+//! Archived chats are ignored: they get no entry, no watcher, and no captures
+//! (an entry whose every chat was archived is dropped on the next reconcile;
+//! unarchiving re-adds it).
+//!
+//! Fast recursive watches on the process-wide [`FsWatchHub`] (one watcher thread
+//! for every checkout; debounced [`WATCH_DEBOUNCE`]) are backed by a slow
+//! 2-minute repair tick because native watchers may coalesce or drop events.
 //! Snapshots carry a sha256 checksum; an unchanged checksum publishes nothing.
 //!
 //! Reconcile is deliberately damped, because it runs on *every* workspace chat
@@ -36,19 +41,21 @@
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsString;
 use std::path::{Component, Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, MutexGuard, PoisonError, Weak};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use serde::Serialize;
 use sha2::{Digest, Sha256};
 use tokio::io::AsyncReadExt;
-use tokio::sync::{mpsc, watch};
+use tokio::sync::{Notify, mpsc, watch};
 use tokio_util::sync::CancellationToken;
 
 use zeron_proto::{Chat, CheckoutDiff, DiffFileSummary};
 
 use crate::EngineError;
 use crate::doc_host::EdgeConfig;
+use crate::fs_watch::{FsWatch, FsWatchHub};
 use crate::repos::{CheckoutIdentity, Repos};
 use crate::workspace_host::WorkspaceHost;
 
@@ -61,6 +68,10 @@ pub const MAX_DIFF_SOURCE_BYTES: usize = 2 * 1024 * 1024;
 const WATCH_DEBOUNCE: Duration = Duration::from_millis(500);
 /// Slow repair pass: re-reconcile + re-sync every checkout.
 const REPAIR_INTERVAL: Duration = Duration::from_secs(120);
+/// How long an archived chat stays tracked after its last viewer leaves —
+/// flicking between chats must not tear down and rebuild (full capture) its
+/// checkout every time.
+const INTEREST_LINGER: Duration = Duration::from_secs(30);
 /// Max subdirectories a checkout may have before we skip its live recursive
 /// watch (one OS watch per dir; past this the watcher thread's own bookkeeping
 /// costs more than instant diffs are worth). A normal source tree is well
@@ -127,16 +138,16 @@ struct CheckoutEntry {
     /// of CPU on a big checkout, so a single flapping chat-watch emission or
     /// transient identity failure must never destroy a live entry.
     orphaned_since: Mutex<Option<std::time::Instant>>,
+    /// A kick arrived while orphaned and was skipped — a chat-less checkout
+    /// is not worth a capture. Reconcile re-kicks if chats come back.
+    skipped_while_orphaned: AtomicBool,
     /// Kick channel into the entry's debounce/sync task.
     kick_tx: mpsc::UnboundedSender<()>,
-    /// Destructive mutations are serialized per checkout. File-system
-    /// watchers and read-only captures may still run concurrently.
-    discard_lock: tokio::sync::Mutex<()>,
-    /// Keeps the recursive fs watchers alive; dropped on entry close. Filled
-    /// asynchronously — watcher setup (budget walk + FSEvents registration) can
-    /// block for seconds, so [`add_entry`] does it off the runtime and attaches
-    /// the result here once ready.
-    watchers: Mutex<Vec<notify::RecommendedWatcher>>,
+    /// Keeps the recursive fs watches alive on the shared [`FsWatchHub`];
+    /// dropped on entry close. Filled asynchronously — watcher setup (budget
+    /// walk + FSEvents registration) can block for seconds, so [`add_entry`]
+    /// does it off the runtime and attaches the result here once ready.
+    watchers: Mutex<Vec<FsWatch>>,
 }
 
 /// Working-tree snapshot recorded when a chat's turn dispatches — the diff
@@ -175,6 +186,84 @@ struct DiffSyncInner {
     /// upgraded Arc — the token cuts it so no sidecar HTTP outlives shutdown.
     cancel: CancellationToken,
     supervisor: Mutex<Option<tokio::task::JoinHandle<()>>>,
+    /// chat_id → viewer interest; see [`CheckoutDiffSync::retain_chat`].
+    interest: Mutex<HashMap<String, Interest>>,
+    /// How long released interest keeps an archived chat tracked.
+    interest_linger: Duration,
+    /// Wakes the supervisor to reconcile when an archived chat's interest
+    /// starts or lapses.
+    interest_changed: Arc<Notify>,
+    /// Serializes discards, whether or not their checkout has an entry: an
+    /// entry can appear between the lookup and the lock, and two discards of
+    /// one root must never interleave. File-system watchers and read-only
+    /// captures may still run concurrently.
+    discard_lock: tokio::sync::Mutex<()>,
+}
+
+#[derive(Default)]
+struct Interest {
+    holders: usize,
+    /// When `holders` last fell to zero; interest lingers `interest_linger`.
+    released_at: Option<Instant>,
+}
+
+/// Keeps a chat tracked by diff sync while alive, even if archived. See
+/// [`CheckoutDiffSync::retain_chat`].
+pub struct ChatInterest {
+    inner: Weak<DiffSyncInner>,
+    chat_id: String,
+}
+
+impl Drop for ChatInterest {
+    fn drop(&mut self) {
+        let Some(inner) = self.inner.upgrade() else {
+            return;
+        };
+        {
+            let mut interest = lock(&inner.interest);
+            let Some(state) = interest.get_mut(&self.chat_id) else {
+                return;
+            };
+            state.holders = state.holders.saturating_sub(1);
+            if state.holders > 0 {
+                return;
+            }
+            state.released_at = Some(Instant::now());
+        }
+        // Only an archived chat's entry depends on interest; reconcile once the
+        // linger runs out so its checkout is released.
+        if is_archived_here(&inner, &self.chat_id)
+            && let Ok(runtime) = tokio::runtime::Handle::try_current()
+        {
+            let notify = inner.interest_changed.clone();
+            let linger = inner.interest_linger;
+            runtime.spawn(async move {
+                tokio::time::sleep(linger + Duration::from_millis(50)).await;
+                notify.notify_one();
+            });
+        }
+    }
+}
+
+fn is_archived_here(inner: &DiffSyncInner, chat_id: &str) -> bool {
+    inner
+        .workspace
+        .watch_chats()
+        .borrow()
+        .iter()
+        .any(|chat| chat.id == chat_id && chat.archived && chat.device_id == inner.device_id)
+}
+
+/// Chats with live or lingering interest; prunes lapsed records.
+fn interested_chats(inner: &DiffSyncInner) -> HashSet<String> {
+    let mut interest = lock(&inner.interest);
+    interest.retain(|_, state| {
+        state.holders > 0
+            || state
+                .released_at
+                .is_some_and(|at| at.elapsed() < inner.interest_linger)
+    });
+    interest.keys().cloned().collect()
 }
 
 fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
@@ -209,6 +298,27 @@ impl CheckoutDiffSync {
         device_id: &str,
         edge: Option<EdgeConfig>,
         orphan_grace: Duration,
+    ) -> Self {
+        Self::start_with_timings(
+            repos,
+            workspace,
+            device_id,
+            edge,
+            orphan_grace,
+            INTEREST_LINGER,
+        )
+    }
+
+    /// [`CheckoutDiffSync::start_with_orphan_grace`] plus an explicit interest
+    /// linger — test hook for archived-chat interest release.
+    #[doc(hidden)]
+    pub fn start_with_timings(
+        repos: Repos,
+        workspace: WorkspaceHost,
+        device_id: &str,
+        edge: Option<EdgeConfig>,
+        orphan_grace: Duration,
+        interest_linger: Duration,
     ) -> Self {
         let (diffs_tx, _) = watch::channel(Vec::new());
         let sync = Self {
@@ -227,11 +337,16 @@ impl CheckoutDiffSync {
                 turn_trees: Mutex::new(HashMap::new()),
                 cancel: CancellationToken::new(),
                 supervisor: Mutex::new(None),
+                interest: Mutex::new(HashMap::new()),
+                interest_linger,
+                interest_changed: Arc::new(Notify::new()),
+                discard_lock: tokio::sync::Mutex::new(()),
             }),
         };
         let task = tokio::spawn(diff_sync_task(
             Arc::downgrade(&sync.inner),
             workspace.watch_chats(),
+            sync.inner.interest_changed.clone(),
             sync.inner.cancel.clone(),
         ));
         *lock(&sync.inner.supervisor) = Some(task);
@@ -276,6 +391,48 @@ impl CheckoutDiffSync {
         self.sync_all();
     }
 
+    /// Tracked checkout roots, each with its count of live fs watches — test
+    /// hook (watches attach asynchronously after an entry is added).
+    #[doc(hidden)]
+    pub fn tracked_checkouts(&self) -> Vec<(PathBuf, usize)> {
+        let mut tracked: Vec<(PathBuf, usize)> = lock(&self.inner.entries)
+            .values()
+            .map(|entry| {
+                let live = lock(&entry.watchers).iter().filter(|w| w.is_live()).count();
+                (entry.identity.root.clone(), live)
+            })
+            .collect();
+        tracked.sort();
+        tracked
+    }
+
+    /// Keep `chat_id` tracked while the returned guard lives — even when the
+    /// chat is archived. Archived chats otherwise cost nothing (no entry,
+    /// watch, capture or sidecar), but an archived chat someone has open must
+    /// still show its checkout's live diff, accept a discard, and get its
+    /// `checkoutId` stamped. The engine holds one guard per open transcript
+    /// stream; released interest lingers [`INTEREST_LINGER`].
+    pub fn retain_chat(&self, chat_id: &str) -> ChatInterest {
+        let first = {
+            let mut interest = lock(&self.inner.interest);
+            let state = interest.entry(chat_id.to_string()).or_default();
+            state.holders += 1;
+            let lapsed = state
+                .released_at
+                .take()
+                .is_none_or(|at| at.elapsed() >= self.inner.interest_linger);
+            state.holders == 1 && lapsed
+        };
+        // Non-archived chats are tracked anyway — no reconcile needed.
+        if first && is_archived_here(&self.inner, chat_id) {
+            self.inner.interest_changed.notify_one();
+        }
+        ChatInterest {
+            inner: Arc::downgrade(&self.inner),
+            chat_id: chat_id.to_string(),
+        }
+    }
+
     /// Kick an immediate sync of every tracked checkout (repair-tick path).
     pub fn sync_all(&self) {
         for entry in lock(&self.inner.entries).values() {
@@ -321,25 +478,33 @@ impl CheckoutDiffSync {
         lock(&self.inner.turn_trees).get(chat_id).cloned()
     }
 
-    /// Discard the complete uncommitted state for a tracked checkout after
-    /// verifying that the UI acted on the latest full snapshot.
+    /// Discard the complete uncommitted state of a checkout after verifying
+    /// that the UI acted on the latest full snapshot. A checkout without an
+    /// entry (e.g. only archived chats, interest not yet reconciled) is
+    /// discarded directly; there is just no live diff to republish.
     pub async fn discard_working_tree(
         &self,
-        checkout_id: &str,
+        identity: &CheckoutIdentity,
         expected_checksum: &str,
     ) -> Result<DiffSnapshot, EngineError> {
-        let entry = lock(&self.inner.entries)
-            .get(checkout_id)
-            .cloned()
-            .ok_or_else(|| EngineError::Other("checkout is no longer available".into()))?;
+        let entry = lock(&self.inner.entries).get(&identity.id).cloned();
         let inner = self.inner.clone();
         let expected_checksum = expected_checksum.to_owned();
+        let Some(entry) = entry else {
+            let root = identity.root.clone();
+            return tokio::spawn(async move {
+                let _guard = inner.discard_lock.lock().await;
+                discard_working_tree(&inner.repos, &root, &expected_checksum).await
+            })
+            .await
+            .map_err(|error| EngineError::Other(format!("discard task failed: {error}")))?;
+        };
         // Own task: a started discard always runs to completion even if the
         // RPC caller goes away, and the nested git captures start from a fresh
         // worker stack instead of stacking on the RPC dispatcher's frames
         // (which overflowed the 2 MiB worker stack in debug builds).
         tokio::spawn(async move {
-            let _guard = entry.discard_lock.lock().await;
+            let _guard = inner.discard_lock.lock().await;
             let result =
                 discard_working_tree(&inner.repos, &entry.identity.root, &expected_checksum).await;
 
@@ -413,10 +578,19 @@ async fn reconcile(inner: &Arc<DiffSyncInner>, chats: Vec<Chat>, fresh: bool) {
     let mut groups: HashMap<String, (CheckoutIdentity, Vec<Chat>)> = HashMap::new();
     // Dedupe resolution within this pass — many chats share one checkout.
     let mut resolved: HashMap<String, Option<CheckoutIdentity>> = HashMap::new();
+    // This device's archived chats nobody has open: never grouped (no entry,
+    // watcher, capture or sidecar), and an entry left holding only these is
+    // dropped below. An archived chat with a viewer is grouped like any other.
+    let interested = interested_chats(inner);
+    let mut archived: HashSet<String> = HashSet::new();
     for chat in chats {
         if chat.device_id != inner.device_id {
             continue;
         }
+        if chat.archived && !interested.contains(&chat.id) {
+            archived.insert(chat.id);
+            continue;
+        }
         let Some(cwd) = chat.cwd.clone() else {
             continue;
         };
@@ -447,14 +621,26 @@ async fn reconcile(inner: &Arc<DiffSyncInner>, chats: Vec<Chat>, fresh: bool) {
     // Close entries whose checkout has had no chats for a full grace period;
     // drop their published diff. A single pass that misses a checkout only
     // *marks* it — teardown is expensive to undo (re-add kicks a capture), so
-    // absence must be sustained before we act on it.
+    // absence must be sustained before we act on it. Archiving is not a flap:
+    // an entry whose every chat is now an archived row goes immediately.
     let removed: Vec<String> = {
         let now = std::time::Instant::now();
         let mut entries = lock(&inner.entries);
         let mut removed = Vec::new();
         for (id, entry) in entries.iter() {
             if groups.contains_key(id) {
-                *lock(&entry.orphaned_since) = None;
+                let was_orphaned = lock(&entry.orphaned_since).take().is_some();
+                if was_orphaned && entry.skipped_while_orphaned.swap(false, Ordering::AcqRel) {
+                    let _ = entry.kick_tx.send(()); // catch up on what we skipped
+                }
+                continue;
+            }
+            let archived_away = {
+                let held = lock(&entry.chats);
+                !held.is_empty() && held.iter().all(|chat| archived.contains(&chat.id))
+            };
+            if archived_away {
+                removed.push(id.clone());
                 continue;
             }
             let mut orphaned = lock(&entry.orphaned_since);
@@ -567,8 +753,8 @@ fn add_entry(inner: &Arc<DiffSyncInner>, identity: CheckoutIdentity, chats: Vec<
         chats: Mutex::new(chats),
         checksum: Mutex::new(None),
         orphaned_since: Mutex::new(None),
+        skipped_while_orphaned: AtomicBool::new(false),
         kick_tx: kick_tx.clone(),
-        discard_lock: tokio::sync::Mutex::new(()),
         watchers: Mutex::new(Vec::new()),
     });
     lock(&inner.entries).insert(entry.identity.id.clone(), entry.clone());
@@ -585,48 +771,39 @@ fn add_entry(inner: &Arc<DiffSyncInner>, identity: CheckoutIdentity, chats: Vec<
     // for seconds when fseventsd is contended. Doing it inline starved the whole
     // runtime (workspace watches, presence) whenever entries were (re)built, so
     // it runs on the blocking pool and attaches to the entry when ready. Events
-    // occurring before attachment are covered by the initial sync; one extra
-    // kick after attachment closes the capture→attach gap.
+    // occurring before attachment are covered by the initial sync; the hub's
+    // rescan when each watch goes live closes the capture→attach gap.
     let weak = Arc::downgrade(&entry);
     tokio::task::spawn_blocking(move || {
         let Some(entry) = weak.upgrade() else {
             return; // entry removed before watchers were ready
         };
-        let watchers = build_watchers(&entry.identity, &kick_tx);
+        let watchers = build_watchers(&FsWatchHub::global(), &entry.identity, &kick_tx);
         *lock(&entry.watchers) = watchers;
-        let _ = kick_tx.send(());
     });
 }
 
-/// Recursive watchers on the worktree root (budget permitting) and the git
-/// dir — HEAD/index churn and file edits both land here. Failures are fine:
-/// the initial + repair sync still keep the snapshot correct. Blocking — call
-/// from the blocking pool.
+/// Recursive watches on the worktree root (budget permitting) and the git
+/// dir — HEAD/index churn and file edits both land here. Registered on the
+/// shared [`FsWatchHub`], so a checkout costs OS watches but no thread of its
+/// own; the hub's rescan signals (watch went live, events possibly lost) kick
+/// like any change. Failures are fine: the initial + repair sync still keep
+/// the snapshot correct. Blocking (budget walk) — call from the blocking pool.
 fn build_watchers(
+    hub: &Arc<FsWatchHub>,
     identity: &CheckoutIdentity,
     kick_tx: &mpsc::UnboundedSender<()>,
-) -> Vec<notify::RecommendedWatcher> {
+) -> Vec<FsWatch> {
     let mut watchers = Vec::new();
     for target in watch_targets(identity) {
         let tx = kick_tx.clone();
-        let watcher =
-            notify::recommended_watcher(move |event: Result<notify::Event, notify::Error>| {
-                if event.as_ref().is_ok_and(is_checkout_change) {
+        watchers.push(
+            hub.watch(&target, notify::RecursiveMode::Recursive, move |event| {
+                if is_checkout_change(event) {
                     let _ = tx.send(());
                 }
-            });
-        match watcher {
-            Ok(mut watcher) => {
-                use notify::Watcher as _;
-                match watcher.watch(&target, notify::RecursiveMode::Recursive) {
-                    Ok(()) => watchers.push(watcher),
-                    Err(err) => {
-                        tracing::debug!(path = %target.display(), error = %err, "diff-sync: watch failed")
-                    }
-                }
-            }
-            Err(err) => tracing::debug!(error = %err, "diff-sync: watcher create failed"),
-        }
+            }),
+        );
     }
     watchers
 }
@@ -659,6 +836,13 @@ async fn entry_task(
         let (Some(inner), Some(entry)) = (inner.upgrade(), entry.upgrade()) else {
             return;
         };
+        // No chats (deleted / moved away; teardown pending the orphan grace):
+        // nobody consumes this checkout's diff, so skip the capture — repair
+        // ticks and fs churn included. Reconcile re-kicks if chats return.
+        if lock(&entry.orphaned_since).is_some() {
+            entry.skipped_while_orphaned.store(true, Ordering::Release);
+            continue;
+        }
         // The upgraded Arc would let a sync outlive shutdown — race the token
         // so an in-flight sidecar POST is dropped, not completed.
         tokio::select! {
@@ -789,6 +973,7 @@ fn publish_watch(inner: &Arc<DiffSyncInner>) {
 async fn diff_sync_task(
     inner: Weak<DiffSyncInner>,
     mut chats_rx: watch::Receiver<Vec<Chat>>,
+    interest_changed: Arc<Notify>,
     cancel: CancellationToken,
 ) {
     let mut repair = tokio::time::interval(REPAIR_INTERVAL);
@@ -807,6 +992,12 @@ async fn diff_sync_task(
                 // sync itself writes them) and must never fan out into git.
                 reconcile(&inner, chats, false).await;
             }
+            // An archived chat gained its first viewer or its interest lapsed.
+            _ = interest_changed.notified() => {
+                let Some(inner) = inner.upgrade() else { break };
+                let chats = chats_rx.borrow().clone();
+                reconcile(&inner, chats, false).await;
+            }
             _ = repair.tick() => {
                 let Some(inner) = inner.upgrade() else { break };
                 let chats = chats_rx.borrow().clone();
@@ -1891,8 +2082,14 @@ mod watch_budget_tests {
         let root = std::fs::canonicalize(tmp.path()).unwrap();
         std::fs::write(root.join("a.txt"), "one\n").unwrap();
         let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
-        let _watchers = super::build_watchers(&identity(&root, &root.join(".git")), &tx);
-        // Let registration settle and drop anything it raised.
+        let hub = crate::fs_watch::FsWatchHub::new();
+        let watchers = super::build_watchers(&hub, &identity(&root, &root.join(".git")), &tx);
+        // Install now (the batch worker would within ~100 ms) and expect the
+        // attach rescan's kick; then let registration settle and drop
+        // anything it raised.
+        hub.apply();
+        assert!(watchers.iter().all(super::FsWatch::is_live));
+        rx.try_recv().expect("going live kicks a sync");
         tokio::time::sleep(std::time::Duration::from_millis(300)).await;
         while rx.try_recv().is_ok() {}
 
diff --git a/crates/engine/src/doc_host_sync_tests.rs b/crates/engine/src/doc_host_sync_tests.rs
index 500ee1e4a9..34f87504ba 100644
--- a/crates/engine/src/doc_host_sync_tests.rs
+++ b/crates/engine/src/doc_host_sync_tests.rs
@@ -268,6 +268,7 @@ fn workspace(store: Arc<DocsStore>) -> WorkspaceHost {
             org_id: "test-org".into(),
             user_id: "test-user".into(),
             edge: None,
+            local_only: false,
         },
     )
     .unwrap()
diff --git a/crates/engine/src/fs_watch.rs b/crates/engine/src/fs_watch.rs
new file mode 100644
index 0000000000..33144e1bd8
--- /dev/null
+++ b/crates/engine/src/fs_watch.rs
@@ -0,0 +1,964 @@
+//! FsWatchHub — one `notify` watcher shared by every subsystem that live-watches
+//! folders (diff-sync checkouts, space folders).
+//!
+//! Every `notify::RecommendedWatcher` owns a dedicated OS thread (the FSEvents
+//! run loop on macOS, the inotify loop on Linux). One watcher per checkout and
+//! per space folder put ~25-30 idle threads on a normal device at boot. The hub
+//! instead installs every path on a single watcher and routes each event to
+//! the registrations whose path covers it, so the whole engine pays for one
+//! watcher thread. Exception: inotify/kqueue get one watcher per installed
+//! root (see [`SHARED_WATCHER`]); they still share the routing and batching.
+//!
+//! Semantics match a private watcher per registration:
+//!
+//! - a [`notify::RecursiveMode::NonRecursive`] registration only sees events for
+//!   its folder and that folder's direct children (notify's own rule);
+//! - pathless events (inotify queue overflow → rescan) reach every registration,
+//!   since an overflow loses events for all of them;
+//! - dropping the [`FsWatch`] handle stops delivery immediately and releases the
+//!   OS watch once no other registration needs it.
+//!
+//! Handlers also receive synthetic *rescan* events
+//! ([`notify::Event::need_rescan`]): once when the registration's watch goes
+//! live (anything before that was unobserved), and whenever events may have
+//! been lost (see below). Callers treat them like any change.
+//!
+//! **Batching.** Registration changes are coalesced on a short-lived worker
+//! thread ([`BATCH_QUIET`] of quiet, at most [`BATCH_MAX`]) and applied in one
+//! pass, so a boot or a burst of entries is one reconcile, not one per path.
+//!
+//! **Restart gaps.** notify 7's FSEvents backend stops the stream, joins its
+//! thread and starts a new stream (from "now" — the event id is not settable)
+//! on *every* `watch`/`unwatch`, so each change drops events for every other
+//! path for that moment. While a pass changes the main watcher, the hub runs
+//! a temporary *bridge* stream on the surviving paths' common ancestor, started
+//! before the first restart and stopped after the last: the surviving paths
+//! stay covered throughout and nothing needs re-capturing. If the bridge cannot
+//! be opened, the pass ends by sending a rescan to every registration that was
+//! live across it (one per registration per pass; callers debounce). inotify
+//! and Windows watches are per path and never restart, so neither applies.
+//!
+//! OS watches are the minimal cover of the registrations: identical paths are
+//! installed once (recursive if any registration wants recursion) and a path
+//! under a recursively watched ancestor is not installed separately. When the
+//! covering watch of a live registration is replaced (a nested path takes over
+//! from a dropped recursive ancestor, a mode change), the registration gets a
+//! rescan: the swap itself was unobserved.
+//!
+//! Watch failures (the folder vanished, inotify limits) are logged and the
+//! registration stays without a live watch, exactly like a private watcher
+//! whose `watch()` failed — callers keep their repair ticks for that case.
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex, MutexGuard, OnceLock, PoisonError};
+use std::time::{Duration, Instant};
+
+use notify::Watcher as _;
+
+/// A batch applies once registrations have been quiet this long…
+const BATCH_QUIET: Duration = Duration::from_millis(100);
+/// …or this long after its first change, whichever comes first.
+const BATCH_MAX: Duration = Duration::from_secs(1);
+/// Whether a watch change restarts the stream for every path (FSEvents).
+const STREAM_RESTARTS_ON_CHANGE: bool = cfg!(target_os = "macos");
+/// Whether every root can share one watcher. inotify (and kqueue) build a
+/// recursive watch by walking the tree *following symlinks*, so in a shared
+/// instance a checkout that symlinks into another checkout (`npm link`) would
+/// alias that checkout's watch descriptors: its events would be relabelled
+/// and unwatching either root would strip the other. Those backends get one
+/// watcher per installed root instead, exactly as before the hub.
+const SHARED_WATCHER: bool = cfg!(any(target_os = "macos", windows));
+
+type Handler = Arc<dyn Fn(&notify::Event) + Send + Sync>;
+
+fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
+    mutex.lock().unwrap_or_else(PoisonError::into_inner)
+}
+
+/// The synthetic "anything may have changed" signal.
+fn rescan_event() -> notify::Event {
+    notify::Event::new(notify::EventKind::Other).set_flag(notify::event::Flag::Rescan)
+}
+
+struct Registration {
+    /// Canonical path — what FSEvents/inotify report events under.
+    path: PathBuf,
+    recursive: bool,
+    handler: Handler,
+    /// Shared with the [`FsWatch`]: an installed OS watch covers `path`.
+    attached: Arc<AtomicBool>,
+}
+
+impl Registration {
+    fn covers(&self, path: &Path) -> bool {
+        path.starts_with(&self.path)
+            && (self.recursive || path == self.path || path.parent() == Some(self.path.as_path()))
+    }
+}
+
+#[derive(Default)]
+struct Routes {
+    next_id: u64,
+    regs: HashMap<u64, Registration>,
+}
+
+#[derive(Default)]
+struct OsState {
+    /// The shared watcher ([`SHARED_WATCHER`] backends). Created lazily on the
+    /// first install. On macOS an FSEvents watcher with no paths has no
+    /// run-loop thread at all.
+    watcher: Option<notify::RecommendedWatcher>,
+    /// One watcher per installed root on the other backends. Dropping one
+    /// closes its instance, releasing every OS watch it added — including
+    /// those a failed recursive `watch` left behind.
+    roots: HashMap<PathBuf, notify::RecommendedWatcher>,
+    /// Canonical path → recursive, as installed.
+    installed: HashMap<PathBuf, bool>,
+    /// Wanted paths whose watch failed. Not retried while still wanted (every
+    /// FSEvents watch/unwatch restarts the stream for *all* paths); forgotten
+    /// once nothing registers them, so a fresh registration retries.
+    failed: HashSet<PathBuf>,
+}
+
+#[derive(Default)]
+struct Batch {
+    /// Bumped on every registration change.
+    generation: u64,
+    /// A batch worker thread is pending or applying.
+    worker: bool,
+}
+
+#[derive(Default)]
+struct Stats {
+    /// Passes that changed the main watcher.
+    passes: AtomicUsize,
+    /// Bridge streams opened.
+    bridges: AtomicUsize,
+}
+
+pub(crate) struct FsWatchHub {
+    /// Shared with the watcher callbacks. Never held across a watcher call:
+    /// FSEvents `watch`/`unwatch`/drop stop and join the run-loop thread,
+    /// which may be inside the callback waiting on this lock.
+    routes: Arc<Mutex<Routes>>,
+    /// Serializes OS watch changes.
+    os: Mutex<OsState>,
+    batch: Mutex<Batch>,
+    restarts_on_change: bool,
+    /// [`SHARED_WATCHER`]; a field so tests can drive both modes.
+    shared_watcher: bool,
+    bridge_enabled: AtomicBool,
+    #[cfg_attr(not(test), allow(dead_code))]
+    stats: Stats,
+}
+
+/// A registration. Dropping it stops delivery and releases the OS watch.
+pub(crate) struct FsWatch {
+    hub: Arc<FsWatchHub>,
+    id: u64,
+    attached: Arc<AtomicBool>,
+}
+
+impl FsWatch {
+    /// Whether an installed OS watch currently covers the path. False until
+    /// the registration's batch applies, and for good if the watch failed.
+    pub(crate) fn is_live(&self) -> bool {
+        self.attached.load(Ordering::Acquire)
+    }
+}
+
+impl Drop for FsWatch {
+    fn drop(&mut self) {
+        if lock(&self.hub.routes).regs.remove(&self.id).is_some() {
+            self.hub.schedule();
+        }
+    }
+}
+
+/// Resets [`Batch::worker`] if a pass panics, so later changes still get a
+/// worker. A normal exit resets it in [`FsWatchHub::run_batches`] itself.
+struct WorkerGuard<'a>(&'a FsWatchHub);
+
+impl Drop for WorkerGuard<'_> {
+    fn drop(&mut self) {
+        if std::thread::panicking() {
+            lock(&self.0.batch).worker = false;
+        }
+    }
+}
+
+impl FsWatchHub {
+    pub(crate) fn new() -> Arc<Self> {
+        Arc::new(Self {
+            routes: Arc::new(Mutex::new(Routes::default())),
+            os: Mutex::new(OsState::default()),
+            batch: Mutex::new(Batch::default()),
+            restarts_on_change: STREAM_RESTARTS_ON_CHANGE,
+            shared_watcher: SHARED_WATCHER,
+            bridge_enabled: AtomicBool::new(true),
+            stats: Stats::default(),
+        })
+    }
+
+    /// The process-wide hub.
+    pub(crate) fn global() -> Arc<Self> {
+        static HUB: OnceLock<Arc<FsWatchHub>> = OnceLock::new();
+        HUB.get_or_init(Self::new).clone()
+    }
+
+    /// Route events under `path` to `handler` until the returned handle drops.
+    /// Returns at once; the OS watch is installed by the next batch, which
+    /// then sends `handler` a rescan event. Canonicalizes `path` (a blocking
+    /// stat) — call from the blocking pool.
+    pub(crate) fn watch(
+        self: &Arc<Self>,
+        path: &Path,
+        mode: notify::RecursiveMode,
+        handler: impl Fn(&notify::Event) + Send + Sync + 'static,
+    ) -> FsWatch {
+        let path = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
+        let attached = Arc::new(AtomicBool::new(false));
+        let id = {
+            let mut routes = lock(&self.routes);
+            routes.next_id += 1;
+            let id = routes.next_id;
+            routes.regs.insert(
+                id,
+                Registration {
+                    path,
+                    recursive: matches!(mode, notify::RecursiveMode::Recursive),
+                    handler: Arc::new(handler),
+                    attached: attached.clone(),
+                },
+            );
+            id
+        };
+        self.schedule();
+        FsWatch {
+            hub: self.clone(),
+            id,
+            attached,
+        }
+    }
+
+    /// Note a registration change; start a batch worker unless one is pending.
+    /// The worker is a short-lived plain thread (not the tokio blocking pool):
+    /// a task queued on a runtime that shuts down before running it would
+    /// leave `worker` set and wedge the hub for the rest of the process.
+    fn schedule(self: &Arc<Self>) {
+        {
+            let mut batch = lock(&self.batch);
+            batch.generation += 1;
+            if batch.worker {
+                return;
+            }
+            batch.worker = true;
+        }
+        let hub = self.clone();
+        let spawned = std::thread::Builder::new()
+            .name("fs-watch batch".into())
+            .spawn(move || hub.run_batches());
+        if let Err(err) = spawned {
+            tracing::debug!(error = %err, "fs-watch: batch worker spawn failed; applying inline");
+            lock(&self.batch).worker = false;
+            self.apply();
+        }
+    }
+
+    fn run_batches(&self) {
+        let _guard = WorkerGuard(self);
+        loop {
+            let started = Instant::now();
+            let mut seen = lock(&self.batch).generation;
+            loop {
+                std::thread::sleep(BATCH_QUIET);
+                let now = lock(&self.batch).generation;
+                let quiet = now == seen;
+                seen = now;
+                if quiet || started.elapsed() >= BATCH_MAX {
+                    break;
+                }
+            }
+            self.apply();
+            // Changes that landed during the pass need another one. Release
+            // `worker` under the same lock as the check: a `schedule` between
+            // the two would see a worker that is about to exit and be lost.
+            let mut batch = lock(&self.batch);
+            if batch.generation == seen {
+                batch.worker = false;
+                return;
+            }
+        }
+    }
+
+    /// Bring the installed OS watches in line with the registrations and
+    /// deliver the resulting rescan signals. Blocking. Idempotent.
+    pub(crate) fn apply(&self) {
+        let rescans = {
+            let mut os = lock(&self.os);
+            self.reconcile_os(&mut os)
+        };
+        let event = rescan_event();
+        for handler in rescans {
+            handler(&event);
+        }
+    }
+
+    fn reconcile_os(&self, os: &mut OsState) -> Vec<Handler> {
+        // Wanted set: distinct paths, recursive if any registration recurses.
+        let mut wanted: HashMap<PathBuf, bool> = HashMap::new();
+        for reg in lock(&self.routes).regs.values() {
+            *wanted.entry(reg.path.clone()).or_default() |= reg.recursive;
+        }
+        os.failed.retain(|path| wanted.contains_key(path));
+        let before = os.installed.clone();
+        let mut bridge: Option<notify::RecommendedWatcher> = None;
+        let mut bridge_tried = false;
+        let mut touched = false;
+        // A failed install may uncover paths it would have covered — iterate
+        // until a pass adds no new failures (bounded: `failed` only grows).
+        loop {
+            let desired = minimal_cover(&wanted, &os.failed);
+            if desired == os.installed {
+                break;
+            }
+            if self.restarts_on_change && !bridge_tried {
+                bridge_tried = true;
+                bridge = self.open_bridge(&os.installed, &desired);
+            }
+            // Removals before additions, so an outgoing watch never overlaps an
+            // incoming one on the same watcher.
+            let stale: Vec<PathBuf> = os
+                .installed
+                .iter()
+                .filter(|(path, recursive)| desired.get(*path) != Some(*recursive))
+                .map(|(path, _)| path.clone())
+                .collect();
+            for path in stale {
+                os.installed.remove(&path);
+                if os.roots.remove(&path).is_some() {
+                    touched = true;
+                } else if let Some(watcher) = os.watcher.as_mut() {
+                    touched = true;
+                    if let Err(err) = watcher.unwatch(&path) {
+                        tracing::debug!(path = %path.display(), error = %err, "fs-watch: unwatch failed");
+                    }
+                }
+            }
+            let mut new_failure = false;
+            for (path, recursive) in desired {
+                if os.installed.get(&path) == Some(&recursive) {
+                    continue;
+                }
+                match install(
+                    os,
+                    &self.routes,
+                    self.shared_watcher,
+                    &path,
+                    recursive,
+                    &mut touched,
+                ) {
+                    Ok(()) => {
+                        os.installed.insert(path, recursive);
+                    }
+                    Err(err) => {
+                        tracing::debug!(path = %path.display(), error = %err, "fs-watch: watch failed");
+                        os.failed.insert(path);
+                        new_failure = true;
+                    }
+                }
+            }
+            if !new_failure {
+                break;
+            }
+        }
+        if touched {
+            self.stats.passes.fetch_add(1, Ordering::Relaxed);
+        }
+        // Only now — the main stream is back up — may the bridge stop.
+        let bridged = bridge.is_some();
+        drop(bridge);
+        let gap = self.restarts_on_change && touched && !bridged;
+
+        let routes = lock(&self.routes);
+        let mut rescans = Vec::new();
+        for reg in routes.regs.values() {
+            if !is_covered(&reg.path, &os.installed) {
+                reg.attached.store(false, Ordering::Release);
+                continue;
+            }
+            let was_attached = reg.attached.swap(true, Ordering::AcqRel);
+            // New: everything before the watch went live was unobserved.
+            // Gap: events may have been dropped while the stream restarted.
+            // Moved: the OS watch covering it was replaced (a recursive root
+            // dropped for a nested one, a mode change) — the bridge only spans
+            // unchanged roots, so the swap itself was unobserved.
+            let moved =
+                covering_roots(&reg.path, &before) != covering_roots(&reg.path, &os.installed);
+            if !was_attached || moved || (gap && is_covered(&reg.path, &before)) {
+                rescans.push(reg.handler.clone());
+            }
+        }
+        rescans
+    }
+
+    /// Start a stream covering every installed path that survives this pass,
+    /// so the main stream's restarts drop nothing for them. One recursive
+    /// watch on their common ancestor: FSEvents filters a volume-wide journal
+    /// by path prefix, so a broad path costs no per-directory watches — only
+    /// unrelated events to filter in [`dispatch`] for the bridge's short life.
+    fn open_bridge(
+        &self,
+        installed: &HashMap<PathBuf, bool>,
+        desired: &HashMap<PathBuf, bool>,
+    ) -> Option<notify::RecommendedWatcher> {
+        if !self.bridge_enabled.load(Ordering::Relaxed) {
+            return None;
+        }
+        let survivors: Vec<&PathBuf> = installed
+            .iter()
+            .filter(|(path, recursive)| desired.get(*path) == Some(*recursive))
+            .map(|(path, _)| path)
+            .collect();
+        let ancestor = common_ancestor(&survivors)?;
+        let routes = self.routes.clone();
+        let opened = notify::recommended_watcher(move |event: notify::Result<notify::Event>| {
+            if let Ok(event) = event {
+                dispatch(&routes, &event);
+            }
+        })
+        .and_then(|mut watcher| {
+            watcher
+                .watch(&ancestor, notify::RecursiveMode::Recursive)
+                .map(|()| watcher)
+        });
+        match opened {
+            Ok(watcher) => {
+                self.stats.bridges.fetch_add(1, Ordering::Relaxed);
+                Some(watcher)
+            }
+            Err(err) => {
+                tracing::debug!(path = %ancestor.display(), error = %err,
+                    "fs-watch: bridge failed; surviving watches get a rescan");
+                None
+            }
+        }
+    }
+
+    #[cfg(test)]
+    fn installed(&self) -> HashMap<PathBuf, bool> {
+        lock(&self.os).installed.clone()
+    }
+}
+
+fn install(
+    os: &mut OsState,
+    routes: &Arc<Mutex<Routes>>,
+    shared: bool,
+    path: &Path,
+    recursive: bool,
+    touched: &mut bool,
+) -> Result<(), notify::Error> {
+    // FSEvents restarts the stream for every path even when `watch` fails —
+    // skip the obvious failure without touching the watcher.
+    if !path.exists() {
+        return Err(notify::Error::path_not_found().add_path(path.to_path_buf()));
+    }
+    let new_watcher = || {
+        let routes = routes.clone();
+        notify::recommended_watcher(move |event: notify::Result<notify::Event>| match event {
+            Ok(event) => dispatch(&routes, &event),
+            Err(err) => tracing::debug!(error = %err, "fs-watch: watcher error"),
+        })
+    };
+    let mode = if recursive {
+        notify::RecursiveMode::Recursive
+    } else {
+        notify::RecursiveMode::NonRecursive
+    };
+    if !shared {
+        // On failure the watcher drops here, with any partial watches.
+        let mut watcher = new_watcher()?;
+        *touched = true;
+        watcher.watch(path, mode)?;
+        os.roots.insert(path.to_path_buf(), watcher);
+        return Ok(());
+    }
+    if os.watcher.is_none() {
+        os.watcher = Some(new_watcher()?);
+    }
+    *touched = true;
+    os.watcher
+        .as_mut()
+        .expect("watcher just created")
+        .watch(path, mode)
+}
+
+fn root_covers(root: &Path, recursive: bool, path: &Path) -> bool {
+    path == root || (recursive && path.starts_with(root))
+}
+
+fn is_covered(path: &Path, installed: &HashMap<PathBuf, bool>) -> bool {
+    installed
+        .iter()
+        .any(|(root, recursive)| root_covers(root, *recursive, path))
+}
+
+fn covering_roots<'a>(
+    path: &Path,
+    installed: &'a HashMap<PathBuf, bool>,
+) -> std::collections::BTreeSet<(&'a PathBuf, bool)> {
+    installed
+        .iter()
+        .filter(|(root, recursive)| root_covers(root, **recursive, path))
+        .map(|(root, recursive)| (root, *recursive))
+        .collect()
+}
+
+fn common_ancestor(paths: &[&PathBuf]) -> Option<PathBuf> {
+    let (first, rest) = paths.split_first()?;
+    let mut ancestor: &Path = first;
+    for path in rest {
+        while !path.starts_with(ancestor) {
+            ancestor = ancestor.parent()?;
+        }
+    }
+    Some(ancestor.to_path_buf())
+}
+
+/// Paths to install: every wanted, non-failed path not already inside another
+/// installable recursive path.
+fn minimal_cover(
+    wanted: &HashMap<PathBuf, bool>,
+    failed: &HashSet<PathBuf>,
+) -> HashMap<PathBuf, bool> {
+    let candidates: Vec<(&PathBuf, bool)> = wanted
+        .iter()
+        .filter(|(path, _)| !failed.contains(*path))
+        .map(|(path, recursive)| (path, *recursive))
+        .collect();
+    candidates
+        .iter()
+        .filter(|(path, _)| {
+            !candidates
+                .iter()
+                .any(|(other, recursive)| *recursive && other != path && path.starts_with(other))
+        })
+        .map(|(path, recursive)| ((*path).clone(), *recursive))
+        .collect()
+}
+
+fn dispatch(routes: &Mutex<Routes>, event: &notify::Event) {
+    // Collect under the lock, call outside it: a handler must never be able to
+    // stall registration bookkeeping.
+    let handlers: Vec<Handler> = lock(routes)
+        .regs
+        .values()
+        .filter(|reg| event.paths.is_empty() || event.paths.iter().any(|path| reg.covers(path)))
+        .map(|reg| reg.handler.clone())
+        .collect();
+    for handler in handlers {
+        handler(event);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel};
+
+    fn reg(path: &str, recursive: bool) -> Registration {
+        Registration {
+            path: PathBuf::from(path),
+            recursive,
+            handler: Arc::new(|_| {}),
+            attached: Arc::default(),
+        }
+    }
+
+    /// Kind of signal a test handler saw.
+    #[derive(Debug, PartialEq)]
+    enum Seen {
+        Event,
+        Rescan,
+    }
+
+    fn recorder() -> (
+        impl Fn(&notify::Event) + Send + Sync + 'static,
+        UnboundedReceiver<Seen>,
+    ) {
+        let (tx, rx): (UnboundedSender<Seen>, _) = unbounded_channel();
+        let handler = move |event: &notify::Event| {
+            let _ = tx.send(if event.need_rescan() {
+                Seen::Rescan
+            } else {
+                Seen::Event
+            });
+        };
+        (handler, rx)
+    }
+
+    fn drain(rx: &mut UnboundedReceiver<Seen>) -> Vec<Seen> {
+        let mut seen = Vec::new();
+        while let Ok(signal) = rx.try_recv() {
+            seen.push(signal);
+        }
+        seen
+    }
+
+    async fn expect(rx: &mut UnboundedReceiver<Seen>, want: Seen) {
+        let deadline = tokio::time::Instant::now() + Duration::from_secs(5);
+        loop {
+            let got = tokio::time::timeout_at(deadline, rx.recv())
+                .await
+                .unwrap_or_else(|_| panic!("{want:?} delivered before timeout"))
+                .expect("channel open");
+            if got == want {
+                return;
+            }
+        }
+    }
+
+    /// Wait for the batch worker, then FSEvents' first deliveries, to settle.
+    async fn settle(hub: &FsWatchHub) {
+        let deadline = Instant::now() + Duration::from_secs(10);
+        while lock(&hub.batch).worker {
+            assert!(Instant::now() < deadline, "batch worker idles");
+            tokio::time::sleep(Duration::from_millis(20)).await;
+        }
+        tokio::time::sleep(Duration::from_millis(300)).await;
+    }
+
+    fn tree() -> (tempfile::TempDir, PathBuf) {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = std::fs::canonicalize(tmp.path()).unwrap();
+        (tmp, root)
+    }
+
+    #[test]
+    fn non_recursive_registration_sees_only_direct_children() {
+        let flat = reg("/r/space", false);
+        assert!(flat.covers(Path::new("/r/space")));
+        assert!(flat.covers(Path::new("/r/space/.git")));
+        assert!(!flat.covers(Path::new("/r/space/src/main.rs")));
+        assert!(!flat.covers(Path::new("/r/spaceship")));
+        let deep = reg("/r/space", true);
+        assert!(deep.covers(Path::new("/r/space/src/main.rs")));
+        assert!(!deep.covers(Path::new("/r/other/x")));
+    }
+
+    #[test]
+    fn cover_dedupes_merges_modes_and_skips_nested_paths() {
+        let wanted: HashMap<PathBuf, bool> = [
+            ("/r/main", true),
+            ("/r/main/.git/worktrees/wt", true), // inside a recursive watch
+            ("/r/flat", false),
+            ("/r/flat/sub", true), // a non-recursive parent covers nothing
+        ]
+        .into_iter()
+        .map(|(p, r)| (PathBuf::from(p), r))
+        .collect();
+        let cover = minimal_cover(&wanted, &HashSet::new());
+        let mut paths: Vec<_> = cover.keys().cloned().collect();
+        paths.sort();
+        assert_eq!(
+            paths,
+            ["/r/flat", "/r/flat/sub", "/r/main"]
+                .map(PathBuf::from)
+                .to_vec()
+        );
+        // A failed ancestor no longer covers its descendants.
+        let failed: HashSet<PathBuf> = [PathBuf::from("/r/main")].into();
+        assert!(
+            minimal_cover(&wanted, &failed).contains_key(Path::new("/r/main/.git/worktrees/wt"))
+        );
+    }
+
+    #[test]
+    fn common_ancestor_of_survivors() {
+        let a = PathBuf::from("/u/me/projects/a");
+        let b = PathBuf::from("/u/me/projects/b/.git");
+        let c = PathBuf::from("/u/me/.zeron/wt");
+        assert_eq!(common_ancestor(&[&a]), Some(a.clone()));
+        assert_eq!(
+            common_ancestor(&[&a, &b]),
+            Some(PathBuf::from("/u/me/projects"))
+        );
+        assert_eq!(common_ancestor(&[&a, &b, &c]), Some(PathBuf::from("/u/me")));
+        assert_eq!(common_ancestor(&[]), None);
+    }
+
+    #[test]
+    fn events_route_by_path_and_pathless_events_broadcast() {
+        let routes = Mutex::new(Routes::default());
+        let hits = Arc::new(Mutex::new(Vec::<&'static str>::new()));
+        for (id, (name, path, recursive)) in [
+            ("a", "/r/a", true),
+            ("b", "/r/b", true),
+            ("flat", "/r", false),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let hits = hits.clone();
+            lock(&routes).regs.insert(
+                id as u64,
+                Registration {
+                    path: PathBuf::from(path),
+                    recursive,
+                    handler: Arc::new(move |_| lock(&hits).push(name)),
+                    attached: Arc::default(),
+                },
+            );
+        }
+        let event =
+            |path: &str| notify::Event::new(notify::EventKind::Any).add_path(PathBuf::from(path));
+        dispatch(&routes, &event("/r/a/src/x.rs"));
+        assert_eq!(std::mem::take(&mut *lock(&hits)), vec!["a"]);
+        dispatch(&routes, &event("/r/b"));
+        let mut got = std::mem::take(&mut *lock(&hits));
+        got.sort();
+        assert_eq!(got, vec!["b", "flat"]); // `/r/b` is a direct child of `/r`
+        dispatch(&routes, &notify::Event::new(notify::EventKind::Other));
+        assert_eq!(lock(&hits).len(), 3, "a rescan reaches every registration");
+    }
+
+    /// End to end through one real watcher: two folders, each event reaches
+    /// only its own registration, each gets one rescan when it goes live, and
+    /// a dropped handle unwatches.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn shared_watcher_routes_events_and_unwatches_on_drop() {
+        let (_tmp, root) = tree();
+        let (a, b) = (root.join("a"), root.join("b"));
+        std::fs::create_dir_all(a.join("deep")).unwrap();
+        std::fs::create_dir_all(&b).unwrap();
+
+        let hub = FsWatchHub::new();
+        let (on_a, mut a_rx) = recorder();
+        let (on_b, mut b_rx) = recorder();
+        let watch_a = hub.watch(&a, notify::RecursiveMode::Recursive, on_a);
+        let watch_b = hub.watch(&b, notify::RecursiveMode::NonRecursive, on_b);
+        expect(&mut a_rx, Seen::Rescan).await;
+        expect(&mut b_rx, Seen::Rescan).await;
+        assert!(watch_a.is_live() && watch_b.is_live());
+        assert_eq!(hub.installed().len(), 2);
+        settle(&hub).await;
+        drain(&mut a_rx);
+        drain(&mut b_rx);
+
+        std::fs::write(a.join("deep/x.txt"), "x").unwrap();
+        expect(&mut a_rx, Seen::Event).await;
+        tokio::time::sleep(Duration::from_millis(300)).await;
+        assert!(drain(&mut b_rx).is_empty(), "a's event must not reach b");
+
+        std::fs::write(b.join("y.txt"), "y").unwrap();
+        expect(&mut b_rx, Seen::Event).await;
+        settle(&hub).await;
+        drain(&mut a_rx);
+
+        drop(watch_a);
+        settle(&hub).await;
+        assert_eq!(hub.installed().len(), 1, "dropped path unwatched");
+        std::fs::write(a.join("deep/x.txt"), "xx").unwrap();
+        tokio::time::sleep(Duration::from_millis(500)).await;
+        assert!(
+            drain(&mut a_rx).is_empty(),
+            "a dropped handle receives nothing"
+        );
+        drop(watch_b);
+    }
+
+    /// A burst of registrations is one pass over the OS watcher (one stream
+    /// restart on FSEvents), not one per path.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn registration_burst_applies_in_one_pass() {
+        let (_tmp, root) = tree();
+        let hub = FsWatchHub::new();
+        let mut watches = Vec::new();
+        for i in 0..8 {
+            let dir = root.join(format!("d{i}"));
+            std::fs::create_dir(&dir).unwrap();
+            watches.push(hub.watch(&dir, notify::RecursiveMode::Recursive, |_| {}));
+        }
+        settle(&hub).await;
+        assert!(watches.iter().all(FsWatch::is_live));
+        assert_eq!(hub.installed().len(), 8);
+        assert_eq!(hub.stats.passes.load(Ordering::Relaxed), 1);
+        watches.clear();
+        settle(&hub).await;
+        assert!(hub.installed().is_empty());
+        assert_eq!(
+            hub.stats.passes.load(Ordering::Relaxed),
+            2,
+            "one pass for the drops"
+        );
+    }
+
+    /// Changing the watch set restarts the FSEvents stream. With the bridge,
+    /// surviving registrations stay covered and get no rescan; without it
+    /// (bridge unavailable) each gets exactly one rescan per pass.
+    #[cfg(target_os = "macos")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn restart_gap_is_bridged_or_compensated() {
+        let (_tmp, root) = tree();
+        let (a, b, c) = (root.join("a"), root.join("b"), root.join("c"));
+        for dir in [&a, &b, &c] {
+            std::fs::create_dir(dir).unwrap();
+        }
+        let hub = FsWatchHub::new();
+        let (on_a, mut a_rx) = recorder();
+        let _watch_a = hub.watch(&a, notify::RecursiveMode::Recursive, on_a);
+        expect(&mut a_rx, Seen::Rescan).await;
+        settle(&hub).await;
+        drain(&mut a_rx);
+
+        let watch_b = hub.watch(&b, notify::RecursiveMode::Recursive, |_| {});
+        settle(&hub).await;
+        assert!(watch_b.is_live());
+        assert_eq!(
+            hub.stats.bridges.load(Ordering::Relaxed),
+            1,
+            "bridge opened"
+        );
+        assert!(
+            !drain(&mut a_rx).contains(&Seen::Rescan),
+            "a bridged restart needs no rescan"
+        );
+        std::fs::write(a.join("x"), "x").unwrap();
+        expect(&mut a_rx, Seen::Event).await;
+        settle(&hub).await;
+        drain(&mut a_rx);
+
+        hub.bridge_enabled.store(false, Ordering::Relaxed);
+        let _watch_c = hub.watch(&c, notify::RecursiveMode::Recursive, |_| {});
+        drop(watch_b);
+        settle(&hub).await;
+        let seen = drain(&mut a_rx);
+        assert_eq!(
+            seen.iter().filter(|s| **s == Seen::Rescan).count(),
+            1,
+            "one compensating rescan per pass: {seen:?}"
+        );
+    }
+
+    #[test]
+    fn missing_path_is_not_live_and_does_not_block_others() {
+        let (_tmp, root) = tree();
+        let hub = FsWatchHub::new();
+        let (on_gone, mut gone_rx) = recorder();
+        let gone = hub.watch(
+            &root.join("gone"),
+            notify::RecursiveMode::Recursive,
+            on_gone,
+        );
+        let here = hub.watch(&root, notify::RecursiveMode::NonRecursive, |_| {});
+        hub.apply();
+        assert!(!gone.is_live());
+        assert!(
+            drain(&mut gone_rx).is_empty(),
+            "a failed watch never attaches"
+        );
+        assert!(here.is_live());
+        assert_eq!(hub.installed().keys().collect::<Vec<_>>(), vec![&root]);
+        drop(here);
+        drop(gone);
+        hub.apply();
+        assert!(hub.installed().is_empty());
+    }
+
+    #[test]
+    fn overlapping_registrations_share_one_install_until_the_last_drops() {
+        let (_tmp, root) = tree();
+        std::fs::create_dir_all(root.join("nested")).unwrap();
+        let hub = FsWatchHub::new();
+        let flat = hub.watch(&root, notify::RecursiveMode::NonRecursive, |_| {});
+        let nested = hub.watch(
+            &root.join("nested"),
+            notify::RecursiveMode::Recursive,
+            |_| {},
+        );
+        let deep = hub.watch(&root, notify::RecursiveMode::Recursive, |_| {});
+        hub.apply();
+        // Same path merges to recursive; the nested path rides along inside it.
+        assert_eq!(hub.installed(), HashMap::from([(root.clone(), true)]));
+        assert!(nested.is_live());
+        drop(deep);
+        hub.apply();
+        assert_eq!(
+            hub.installed(),
+            HashMap::from([(root.clone(), false), (root.join("nested"), true)])
+        );
+        drop(flat);
+        drop(nested);
+        hub.apply();
+        assert!(hub.installed().is_empty());
+    }
+
+    /// A hub configured like inotify's: a watcher per root, no restarts.
+    fn per_root_hub() -> Arc<FsWatchHub> {
+        let hub = Arc::into_inner(FsWatchHub::new()).expect("fresh hub");
+        Arc::new(FsWatchHub {
+            shared_watcher: false,
+            restarts_on_change: false,
+            ..hub
+        })
+    }
+
+    #[test]
+    fn replaced_cover_rescans_the_registration() {
+        let (_tmp, root) = tree();
+        std::fs::create_dir_all(root.join("nested")).unwrap();
+        for hub in [FsWatchHub::new(), per_root_hub()] {
+            let (on_nested, mut nested_rx) = recorder();
+            let _nested = hub.watch(
+                &root.join("nested"),
+                notify::RecursiveMode::Recursive,
+                on_nested,
+            );
+            let deep = hub.watch(&root, notify::RecursiveMode::Recursive, |_| {});
+            hub.apply();
+            drain(&mut nested_rx);
+            // `nested` rode inside `root`'s watch; it now gets its own, and
+            // nothing observed the swap.
+            drop(deep);
+            hub.apply();
+            assert_eq!(
+                hub.installed(),
+                HashMap::from([(root.join("nested"), true)])
+            );
+            assert!(drain(&mut nested_rx).contains(&Seen::Rescan));
+            // A pass that leaves its cover alone sends nothing.
+            let _other = hub.watch(&root, notify::RecursiveMode::NonRecursive, |_| {});
+            hub.apply();
+            assert!(!drain(&mut nested_rx).contains(&Seen::Rescan));
+        }
+    }
+
+    #[tokio::test]
+    async fn per_root_watchers_route_events_and_close_on_drop() {
+        let (_tmp, root) = tree();
+        let (a, b) = (root.join("a"), root.join("b"));
+        for dir in [&a, &b] {
+            std::fs::create_dir(dir).unwrap();
+        }
+        let hub = per_root_hub();
+        let (on_a, mut a_rx) = recorder();
+        let watch_a = hub.watch(&a, notify::RecursiveMode::Recursive, on_a);
+        let (on_b, mut b_rx) = recorder();
+        let _watch_b = hub.watch(&b, notify::RecursiveMode::Recursive, on_b);
+        hub.apply();
+        assert_eq!(lock(&hub.os).roots.len(), 2);
+        assert!(lock(&hub.os).watcher.is_none());
+        settle(&hub).await;
+        drain(&mut a_rx);
+        drain(&mut b_rx);
+        std::fs::write(b.join("x"), "x").unwrap();
+        expect(&mut b_rx, Seen::Event).await;
+        assert!(!drain(&mut a_rx).contains(&Seen::Event));
+        drop(watch_a);
+        hub.apply();
+        assert_eq!(lock(&hub.os).roots.keys().collect::<Vec<_>>(), [&b]);
+    }
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 23da6a3804..292d8eddea 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -22,6 +22,7 @@ pub mod chat2_host;
 mod chat_persistence;
 pub mod diff_sync;
 pub mod doc_host;
+mod fs_watch;
 pub mod harness_updates;
 mod http_error;
 pub mod instance_lock;
@@ -242,6 +243,7 @@ impl EngineCore {
                 org_id: profile.org_id().to_string(),
                 user_id: profile.user_id().to_string(),
                 edge: edge.clone(),
+                local_only: matches!(profile.scope(), WorkspaceScope::Local),
             },
         )?;
         doc_host.set_workspace(workspace.clone());
diff --git a/crates/engine/src/rpc.rs b/crates/engine/src/rpc.rs
index 4ddbcbc6c5..0ee6078d19 100644
--- a/crates/engine/src/rpc.rs
+++ b/crates/engine/src/rpc.rs
@@ -2069,19 +2069,27 @@ impl RpcService for EngineRpc {
                     .and_then(|v| v.as_bool())
                     .unwrap_or(false);
                 let p: ChatParams = parse_params(params)?;
-                if opening_tail {
-                    return Ok(RpcReply::Stream(
-                        opening_doc_messages_stream(self.doc_host.clone(), p.chat_id).await?,
-                    ));
-                }
-                let handle = self
-                    .doc_host
-                    .open(&p.chat_id)
-                    .map_err(|e| RpcError::Failed(e.to_string()))?;
-                Ok(RpcReply::Stream(doc_messages_stream(
-                    handle.watch_messages(),
-                    handle.doc_arc(),
-                )))
+                // An open transcript keeps its chat's checkout diff live (and
+                // discardable) even when the chat is archived; the guard lives
+                // exactly as long as the stream.
+                let interest = self.diff_sync.retain_chat(&p.chat_id);
+                let stream = if opening_tail {
+                    opening_doc_messages_stream(self.doc_host.clone(), p.chat_id).await?
+                } else {
+                    let handle = self
+                        .doc_host
+                        .open(&p.chat_id)
+                        .map_err(|e| RpcError::Failed(e.to_string()))?;
+                    doc_messages_stream(handle.watch_messages(), handle.doc_arc())
+                };
+                Ok(RpcReply::Stream(
+                    stream
+                        .map(move |frame| {
+                            let _held = &interest;
+                            frame
+                        })
+                        .boxed(),
+                ))
             }
             methods::WATCH_QUEUE => {
                 let p: ChatParams = parse_params(params)?;
@@ -2678,7 +2686,7 @@ impl RpcService for EngineRpc {
 
                     let snapshot = self
                         .diff_sync
-                        .discard_working_tree(&identity.id, &p.expected_checksum)
+                        .discard_working_tree(&identity, &p.expected_checksum)
                         .await
                         .map_err(|e| RpcError::Failed(e.to_string()))?;
                     RpcReply::value(&serde_json::json!({
diff --git a/crates/engine/src/run_journal.rs b/crates/engine/src/run_journal.rs
index 6295de16a1..a4110bdce0 100644
--- a/crates/engine/src/run_journal.rs
+++ b/crates/engine/src/run_journal.rs
@@ -12,7 +12,7 @@
 
 use std::collections::HashMap;
 use std::fs::{File, OpenOptions};
-use std::io::{BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
 use std::sync::{Mutex, MutexGuard, PoisonError};
 
@@ -163,11 +163,17 @@ impl RunJournal {
 
     /// The last event in a chat's journal, if any (ignores a torn tail line).
     pub fn last_event(&self, chat_id: &str) -> Result<Option<(u64, AgentEvent)>, JournalError> {
-        let path = self.path_for(chat_id);
-        if !path.exists() {
-            return Ok(None);
-        }
-        Ok(read_lines(&path)?.into_iter().next_back())
+        last_valid_line(&self.path_for(chat_id))
+    }
+
+    /// Valid events newest-first, read backwards from the end of the file — for
+    /// callers that want the most recent match and can stop early instead of
+    /// materialising the whole journal like `replay` does.
+    pub fn events_rev(
+        &self,
+        chat_id: &str,
+    ) -> Result<impl Iterator<Item = Result<(u64, AgentEvent), JournalError>>, JournalError> {
+        RevEvents::open(&self.path_for(chat_id))
     }
 
     /// Crash-recovery scan: chat ids whose journal's last event is NOT a `Done` — their
@@ -183,8 +189,8 @@ impl RunJournal {
             let Some(chat_id) = path.file_stem().and_then(|s| s.to_str()) else {
                 continue;
             };
-            let last = read_lines(&path)?.into_iter().next_back();
-            match last {
+            // Tail read only: journals reach tens of MB and boot scans every one.
+            match last_valid_line(&path)? {
                 Some((_, AgentEvent::Done { .. })) | None => {}
                 Some(_) => stale.push(chat_id.to_string()),
             }
@@ -213,35 +219,172 @@ fn read_lines(path: &Path) -> Result<Vec<(u64, AgentEvent)>, JournalError> {
     };
     let mut out = Vec::new();
     for line in BufReader::new(file).lines() {
-        let line = line?;
-        if line.trim().is_empty() {
-            continue;
-        }
-        match serde_json::from_str::<JournalLine>(&line) {
-            Ok(parsed) => out.push((parsed.seq, parsed.event)),
-            Err(err) => {
-                tracing::warn!(path = %path.display(), error = %err, "journal: skipping malformed line");
-            }
+        if let Some(parsed) = parse_line(path, &line?) {
+            out.push(parsed);
         }
     }
     Ok(out)
 }
 
+/// One journal line → `(seq, event)`; blank lines are skipped silently, malformed
+/// ones (torn tail writes) with a warning.
+fn parse_line(path: &Path, line: &str) -> Option<(u64, AgentEvent)> {
+    if line.trim().is_empty() {
+        return None;
+    }
+    match serde_json::from_str::<JournalLine>(line) {
+        Ok(parsed) => Some((parsed.seq, parsed.event)),
+        Err(err) => {
+            tracing::warn!(path = %path.display(), error = %err, "journal: skipping malformed line");
+            None
+        }
+    }
+}
+
+/// The last valid event in the file — what `read_lines(path).last()` returns, without
+/// reading more than the tail.
+fn last_valid_line(path: &Path) -> Result<Option<(u64, AgentEvent)>, JournalError> {
+    RevEvents::open(path)?.next().transpose()
+}
+
 /// Next seq (last valid seq + 1, starting at 1) and whether the file ends mid-line.
 fn scan_tail(path: &Path) -> Result<(u64, bool), JournalError> {
-    let bytes = match std::fs::read(path) {
-        Ok(b) => b,
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok((1, false)),
-        Err(e) => return Err(e.into()),
+    let Some(mut lines) = RevLines::open(path)? else {
+        return Ok((1, false));
     };
-    let needs_newline = bytes.last().is_some_and(|b| *b != b'\n');
-    let next_seq = read_lines(path)?
-        .last()
+    let needs_newline = lines.ends_mid_line()?;
+    let next_seq = RevEvents::from_lines(path, Some(lines))
+        .next()
+        .transpose()?
         .map(|(seq, _)| seq + 1)
         .unwrap_or(1);
     Ok((next_seq, needs_newline))
 }
 
+/// First tail-read size. Journal lines are usually far shorter; a longer line grows the
+/// read geometrically, so a multi-MB line costs O(len) rather than O(len²).
+const TAIL_CHUNK: usize = 64 * 1024;
+
+/// Raw lines of a file, last to first, read backwards in chunks — memory is bounded by
+/// the longest line rather than the file. `\n` separators are stripped (a preceding `\r`
+/// is left in place; JSON parsing treats it as whitespace), so a file ending in `\n`
+/// yields an empty line first, which callers skip like any blank line.
+struct RevLines {
+    file: File,
+    /// File offset of `buf[0]`; bytes before it have not been read yet.
+    pos: u64,
+    /// Read but not yet yielded: the file's bytes `[pos, pos + buf.len())`.
+    buf: Vec<u8>,
+    finished: bool,
+}
+
+impl RevLines {
+    /// `None` when the file does not exist (an empty journal, as `read_lines` treats it).
+    fn open(path: &Path) -> std::io::Result<Option<Self>> {
+        let file = match File::open(path) {
+            Ok(f) => f,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+            Err(e) => return Err(e),
+        };
+        let pos = file.metadata()?.len();
+        Ok(Some(Self {
+            file,
+            pos,
+            buf: Vec::new(),
+            finished: false,
+        }))
+    }
+
+    /// Prepend the previous chunk of the file to `buf` (at least as large as `buf`).
+    fn fill(&mut self) -> std::io::Result<()> {
+        let want = TAIL_CHUNK.max(self.buf.len()) as u64;
+        let n = want.min(self.pos);
+        self.pos -= n;
+        let mut chunk = vec![0u8; n as usize];
+        self.file.seek(SeekFrom::Start(self.pos))?;
+        self.file.read_exact(&mut chunk)?;
+        chunk.extend_from_slice(&self.buf);
+        self.buf = chunk;
+        Ok(())
+    }
+
+    /// True when the file is non-empty and its last byte is not `\n` (a torn write).
+    /// Call before the first `next_line`.
+    fn ends_mid_line(&mut self) -> std::io::Result<bool> {
+        if self.buf.is_empty() && self.pos > 0 {
+            self.fill()?;
+        }
+        Ok(self.buf.last().is_some_and(|b| *b != b'\n'))
+    }
+
+    fn next_line(&mut self) -> std::io::Result<Option<Vec<u8>>> {
+        loop {
+            if self.finished {
+                return Ok(None);
+            }
+            if let Some(i) = self.buf.iter().rposition(|b| *b == b'\n') {
+                let line = self.buf.split_off(i + 1);
+                self.buf.truncate(i);
+                return Ok(Some(line));
+            }
+            if self.pos == 0 {
+                self.finished = true;
+                return Ok(Some(std::mem::take(&mut self.buf)));
+            }
+            self.fill()?;
+        }
+    }
+}
+
+/// Valid journal events newest-first: `read_lines` in reverse, with the same
+/// blank/malformed-line skipping, reading only as far back as the caller iterates.
+struct RevEvents {
+    path: PathBuf,
+    /// `None` once exhausted, after an I/O error, or when the file does not exist.
+    lines: Option<RevLines>,
+}
+
+impl RevEvents {
+    fn open(path: &Path) -> Result<Self, JournalError> {
+        Ok(Self::from_lines(path, RevLines::open(path)?))
+    }
+
+    fn from_lines(path: &Path, lines: Option<RevLines>) -> Self {
+        Self {
+            path: path.to_path_buf(),
+            lines,
+        }
+    }
+}
+
+impl Iterator for RevEvents {
+    type Item = Result<(u64, AgentEvent), JournalError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let raw = match self.lines.as_mut()?.next_line() {
+                Ok(Some(raw)) => raw,
+                Ok(None) => {
+                    self.lines = None;
+                    return None;
+                }
+                Err(err) => {
+                    self.lines = None;
+                    return Some(Err(err.into()));
+                }
+            };
+            // A torn write can split a multi-byte char: treat it as malformed too.
+            let Ok(line) = std::str::from_utf8(&raw) else {
+                tracing::warn!(path = %self.path.display(), "journal: skipping non-UTF-8 line");
+                continue;
+            };
+            if let Some(parsed) = parse_line(&self.path, line) {
+                return Some(Ok(parsed));
+            }
+        }
+    }
+}
+
 /// Journal (`.jsonl`) and resume-budget (`.resume`) paths for `chat_id` under an
 /// arbitrary journals directory — profile import copies these files between
 /// profiles without opening a `RunJournal`.
@@ -348,4 +491,172 @@ mod tests {
         assert_eq!(all.len(), 2);
         assert_eq!(all[1].0, 2);
     }
+
+    fn line(seq: u64, event: AgentEvent) -> String {
+        serde_json::to_string(&JournalLine { seq, event }).unwrap()
+    }
+
+    fn rev_lines(path: &Path) -> Vec<Vec<u8>> {
+        let Some(mut lines) = RevLines::open(path).unwrap() else {
+            return Vec::new();
+        };
+        std::iter::from_fn(|| lines.next_line().unwrap()).collect()
+    }
+
+    /// Journal contents covering the tail reader's edge cases; each must read the same
+    /// backwards as the full forward parse did.
+    fn tail_cases() -> Vec<(&'static str, Vec<u8>)> {
+        let huge = "x".repeat(5 * TAIL_CHUNK + 123);
+        let a = line(1, text("a"));
+        let b = line(2, text("b"));
+        let big = line(3, text(&huge));
+        let fin = line(4, done());
+        vec![
+            ("empty", Vec::new()),
+            ("only-newlines", b"\n\n\r\n  \n".to_vec()),
+            ("trailing-newline", format!("{a}\n{b}\n").into_bytes()),
+            ("no-trailing-newline", format!("{a}\n{b}").into_bytes()),
+            ("crlf", format!("{a}\r\n{b}\r\n").into_bytes()),
+            (
+                "blank-lines-at-end",
+                format!("{a}\n{b}\n\n  \n").into_bytes(),
+            ),
+            (
+                "garbage-last-line",
+                format!("{a}\n{b}\n{{\"seq\":3,\"event\":{{\"type\":\"textD").into_bytes(),
+            ),
+            (
+                "garbage-then-newline",
+                format!("{a}\n{b}\nnot json\n\n").into_bytes(),
+            ),
+            ("all-garbage", b"nope\n{\"seq\":\nstill nope".to_vec()),
+            (
+                "multi-chunk-last-line",
+                format!("{a}\n{big}\n").into_bytes(),
+            ),
+            (
+                "multi-chunk-last-line-unterminated",
+                format!("{a}\n{big}").into_bytes(),
+            ),
+            (
+                "multi-chunk-middle-line",
+                format!("{a}\n{big}\n{fin}\n").into_bytes(),
+            ),
+            (
+                "multi-chunk-garbage-tail",
+                format!("{a}\n{b}\n{}", &big[..big.len() - 7]).into_bytes(),
+            ),
+            ("multi-chunk-only-line", big.clone().into_bytes()),
+        ]
+    }
+
+    #[test]
+    fn rev_lines_are_forward_lines_reversed() {
+        let dir = tempfile::tempdir().unwrap();
+        for (name, bytes) in tail_cases() {
+            let path = dir.path().join(format!("{name}.jsonl"));
+            std::fs::write(&path, &bytes).unwrap();
+            let mut expected: Vec<Vec<u8>> =
+                bytes.split(|b| *b == b'\n').map(<[u8]>::to_vec).collect();
+            expected.reverse();
+            assert_eq!(rev_lines(&path), expected, "{name}");
+        }
+        assert!(rev_lines(&dir.path().join("missing.jsonl")).is_empty());
+    }
+
+    #[test]
+    fn tail_reads_match_a_full_forward_parse() {
+        let dir = tempfile::tempdir().unwrap();
+        for (name, bytes) in tail_cases() {
+            let path = dir.path().join(format!("{name}.jsonl"));
+            std::fs::write(&path, &bytes).unwrap();
+            let all = read_lines(&path).unwrap();
+
+            // Every valid event, newest-first.
+            let mut expected = all.clone();
+            expected.reverse();
+            let rev: Vec<_> = RevEvents::open(&path)
+                .unwrap()
+                .collect::<Result<_, _>>()
+                .unwrap();
+            assert_eq!(rev, expected, "{name}");
+
+            assert_eq!(
+                last_valid_line(&path).unwrap(),
+                all.last().cloned(),
+                "{name}"
+            );
+            let old_scan_tail = (
+                all.last().map(|(seq, _)| seq + 1).unwrap_or(1),
+                bytes.last().is_some_and(|b| *b != b'\n'),
+            );
+            assert_eq!(scan_tail(&path).unwrap(), old_scan_tail, "{name}");
+        }
+        let missing = dir.path().join("missing.jsonl");
+        assert_eq!(last_valid_line(&missing).unwrap(), None);
+        assert_eq!(scan_tail(&missing).unwrap(), (1, false));
+    }
+
+    #[test]
+    fn stale_sessions_unchanged_by_tail_reads() {
+        let dir = tempfile::tempdir().unwrap();
+        for (name, bytes) in tail_cases() {
+            std::fs::write(dir.path().join(format!("{name}.jsonl")), bytes).unwrap();
+        }
+        std::fs::write(dir.path().join("ignored.resume"), "2").unwrap();
+        let journal = RunJournal::open(dir.path()).unwrap();
+
+        // The pre-tail-read implementation: full parse, inspect the last event.
+        let mut expected = Vec::new();
+        for entry in std::fs::read_dir(dir.path()).unwrap() {
+            let path = entry.unwrap().path();
+            if path.extension().and_then(|e| e.to_str()) != Some("jsonl") {
+                continue;
+            }
+            let last = read_lines(&path).unwrap().into_iter().next_back();
+            if matches!(last, Some((_, ref event)) if !matches!(event, AgentEvent::Done { .. })) {
+                expected.push(path.file_stem().unwrap().to_str().unwrap().to_string());
+            }
+        }
+        expected.sort();
+        assert_eq!(journal.stale_sessions().unwrap(), expected);
+        assert!(expected.contains(&"multi-chunk-garbage-tail".to_string()));
+        assert!(!expected.contains(&"multi-chunk-middle-line".to_string()));
+    }
+
+    #[test]
+    fn append_after_multi_chunk_torn_tail_isolates_it() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("chat-1.jsonl");
+        let big = line(7, text(&"y".repeat(3 * TAIL_CHUNK)));
+        std::fs::write(
+            &path,
+            format!("{}\n{}", line(6, text("a")), &big[..big.len() / 2]),
+        )
+        .unwrap();
+        let journal = RunJournal::open(dir.path()).unwrap();
+        assert_eq!(journal.append("chat-1", &text("b")).unwrap(), 7);
+        assert!(matches!(
+            journal.last_event("chat-1").unwrap(),
+            Some((7, AgentEvent::TextDelta { .. }))
+        ));
+        assert_eq!(journal.replay("chat-1", 0).unwrap().len(), 2);
+    }
+
+    #[test]
+    fn non_utf8_tail_line_is_skipped_as_malformed() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("chat-1.jsonl");
+        let mut bytes = format!("{}\n", line(1, done())).into_bytes();
+        // A torn write that split a multi-byte char.
+        bytes
+            .extend_from_slice(b"{\"seq\":2,\"event\":{\"type\":\"textDelta\",\"text\":\"\xE2\x82");
+        std::fs::write(&path, bytes).unwrap();
+        let journal = RunJournal::open(dir.path()).unwrap();
+        assert!(matches!(
+            journal.last_event("chat-1").unwrap(),
+            Some((1, AgentEvent::Done { .. }))
+        ));
+        assert!(journal.stale_sessions().unwrap().is_empty());
+    }
 }
diff --git a/crates/engine/src/sessions.rs b/crates/engine/src/sessions.rs
index 253e13f804..12c8d549fa 100644
--- a/crates/engine/src/sessions.rs
+++ b/crates/engine/src/sessions.rs
@@ -1413,36 +1413,55 @@ impl Inner {
     /// The last harness session id named anywhere in the chat's journal, with
     /// the cwd of the `SessionStarted` that governs it. `Done.session_id`
     /// inherits the cwd of the most recent `SessionStarted` (same run).
+    ///
+    /// Walks the journal newest-first and stops at the answer, so boot recovery
+    /// doesn't load whole multi-MB journals: the newest non-empty id wins, and a
+    /// `Done` id takes the cwd of the nearest earlier `SessionStarted` (any id).
     fn journal_harness_session(&self, chat_id: &str) -> Option<(String, String)> {
-        let events = match self.journal.replay(chat_id, 0) {
+        let warn = |err: crate::run_journal::JournalError| {
+            tracing::warn!(chat = %chat_id, error = %err, "journal scan for harness session failed");
+        };
+        let events = match self.journal.events_rev(chat_id) {
             Ok(events) => events,
             Err(err) => {
-                tracing::warn!(chat = %chat_id, error = %err, "journal scan for harness session failed");
+                warn(err);
                 return None;
             }
         };
-        let mut current_cwd = String::new();
-        let mut found: Option<(String, String)> = None;
-        for (_, event) in events {
+        // A `Done` id seen first, still waiting for its run's `SessionStarted` cwd.
+        let mut done_id: Option<String> = None;
+        for item in events {
+            let (seq, event) = match item {
+                Ok(item) => item,
+                Err(err) => {
+                    warn(err);
+                    return None;
+                }
+            };
+            if seq == 0 {
+                continue; // `replay(_, 0)` (the old full scan) never yielded seq 0
+            }
             match event {
                 AgentEvent::SessionStarted {
                     session_id, cwd, ..
                 } => {
-                    current_cwd = cwd;
+                    if let Some(id) = done_id {
+                        return Some((id, cwd));
+                    }
                     if !session_id.is_empty() {
-                        found = Some((session_id, current_cwd.clone()));
+                        return Some((session_id, cwd));
                     }
                 }
                 AgentEvent::Done {
                     session_id: Some(session_id),
                     ..
-                } if !session_id.is_empty() => {
-                    found = Some((session_id, current_cwd.clone()));
+                } if done_id.is_none() && !session_id.is_empty() => {
+                    done_id = Some(session_id);
                 }
                 _ => {}
             }
         }
-        found
+        done_id.map(|id| (id, String::new()))
     }
 
     fn remove_run(&self, chat_id: &str, run_id: &str) {
@@ -3243,6 +3262,148 @@ mod tests {
         assert!(!journal.contains("secret"));
     }
 
+    /// The backwards journal scan must answer exactly what the old full forward
+    /// replay did: newest non-empty id, cwd from the governing `SessionStarted`.
+    #[tokio::test]
+    async fn journal_harness_session_matches_forward_scan() {
+        fn started(id: &str, cwd: &str) -> AgentEvent {
+            AgentEvent::SessionStarted {
+                harness: zeron_proto::HarnessId::ClaudeCode,
+                model: "m".into(),
+                tools: Vec::new(),
+                cwd: cwd.into(),
+                session_id: id.into(),
+                assistant_message_id: "a".into(),
+            }
+        }
+        fn done(id: Option<&str>) -> AgentEvent {
+            AgentEvent::Done {
+                status: DoneStatus::Completed,
+                result: None,
+                error: None,
+                session_id: id.map(Into::into),
+            }
+        }
+        fn text() -> AgentEvent {
+            AgentEvent::TextDelta { text: "t".into() }
+        }
+        /// The pre-change implementation, verbatim, over a forward replay.
+        fn forward(events: Vec<(u64, AgentEvent)>) -> Option<(String, String)> {
+            let mut current_cwd = String::new();
+            let mut found: Option<(String, String)> = None;
+            for (_, event) in events {
+                match event {
+                    AgentEvent::SessionStarted {
+                        session_id, cwd, ..
+                    } => {
+                        current_cwd = cwd;
+                        if !session_id.is_empty() {
+                            found = Some((session_id, current_cwd.clone()));
+                        }
+                    }
+                    AgentEvent::Done {
+                        session_id: Some(session_id),
+                        ..
+                    } if !session_id.is_empty() => {
+                        found = Some((session_id, current_cwd.clone()));
+                    }
+                    _ => {}
+                }
+            }
+            found
+        }
+
+        /// (chat id, journaled events, expected `(session id, cwd)`).
+        type Case = (
+            &'static str,
+            Vec<AgentEvent>,
+            Option<(&'static str, &'static str)>,
+        );
+        let cases: Vec<Case> = vec![
+            ("empty", vec![], None),
+            ("no-ids", vec![text(), done(None), done(Some(""))], None),
+            (
+                "started-only",
+                vec![started("s1", "/a"), text()],
+                Some(("s1", "/a")),
+            ),
+            (
+                "done-inherits-run-cwd",
+                vec![started("s1", "/a"), text(), done(Some("s2"))],
+                Some(("s2", "/a")),
+            ),
+            (
+                "done-before-any-started",
+                vec![text(), done(Some("s1"))],
+                Some(("s1", "")),
+            ),
+            (
+                "empty-started-sets-cwd-for-later-done",
+                vec![started("s1", "/a"), started("", "/b"), done(Some("s2"))],
+                Some(("s2", "/b")),
+            ),
+            (
+                "later-empty-started-does-not-override",
+                vec![
+                    started("s1", "/a"),
+                    done(Some("s2")),
+                    started("", "/b"),
+                    text(),
+                ],
+                Some(("s2", "/a")),
+            ),
+            (
+                "newest-run-wins",
+                vec![
+                    started("s1", "/a"),
+                    done(Some("s1")),
+                    started("s3", "/c"),
+                    text(),
+                ],
+                Some(("s3", "/c")),
+            ),
+            (
+                "empty-done-ids-ignored",
+                vec![started("s1", "/a"), done(Some("")), done(None)],
+                Some(("s1", "/a")),
+            ),
+            (
+                "only-empty-started-then-done-from-older-run",
+                vec![
+                    started("s1", "/a"),
+                    done(Some("s9")),
+                    started("", "/b"),
+                    done(None),
+                ],
+                Some(("s9", "/a")),
+            ),
+        ];
+
+        let dir = tempfile::tempdir().unwrap();
+        let sessions = SessionsEngine::new(
+            "host".into(),
+            Arc::new(RunJournal::open(dir.path().join("journals")).unwrap()),
+            Arc::new(HarnessRegistry::new()),
+        );
+        for (chat, events, want) in cases {
+            for event in &events {
+                sessions.inner.journal.append(chat, event).unwrap();
+            }
+            let want = want.map(|(id, cwd)| (id.to_string(), cwd.to_string()));
+            let replayed = sessions.inner.journal.replay(chat, 0).unwrap();
+            assert_eq!(forward(replayed), want, "{chat}: reference");
+            assert_eq!(sessions.inner.journal_harness_session(chat), want, "{chat}");
+        }
+        // Torn tail: the last complete SessionStarted still governs.
+        let path = dir.path().join("journals").join("started-only.jsonl");
+        let mut f = std::fs::OpenOptions::new().append(true).open(path).unwrap();
+        std::io::Write::write_all(&mut f, b"{\"seq\":3,\"event\":{\"type\":\"done\"").unwrap();
+        assert_eq!(
+            sessions.inner.journal_harness_session("started-only"),
+            Some(("s1".into(), "/a".into()))
+        );
+    }
+
     fn request() -> RunRequest {
         RunRequest {
             mcp: None,
diff --git a/crates/engine/src/spaces.rs b/crates/engine/src/spaces.rs
index c41b654ff6..69f4d362f7 100644
--- a/crates/engine/src/spaces.rs
+++ b/crates/engine/src/spaces.rs
@@ -6,7 +6,8 @@
 //! and keeps their `gitDetected`/`checkoutId`/`repositoryId` stamps truthful:
 //!
 //! - recheck on boot / when a space row is first observed;
-//! - a non-recursive `notify` watcher on the space folder — `.git` appearing or
+//! - a non-recursive watch on the space folder (on the process-wide
+//!   [`FsWatchHub`], so spaces add no watcher threads) — `.git` appearing or
 //!   vanishing (git init / de-git) kicks a recheck;
 //! - a slow 2-minute repair tick (native watchers coalesce/drop events).
 //!
@@ -32,6 +33,7 @@ use tokio_util::sync::CancellationToken;
 
 use zeron_proto::Space;
 
+use crate::fs_watch::{FsWatch, FsWatchHub};
 use crate::repos::Repos;
 use crate::workspace_host::WorkspaceHost;
 
@@ -43,10 +45,10 @@ const REPAIR_INTERVAL: Duration = Duration::from_secs(120);
 struct SpaceEntry {
     path: PathBuf,
     kick_tx: mpsc::UnboundedSender<()>,
-    /// Keeps the folder watcher alive; dropped on entry close. Filled
-    /// asynchronously — FSEvents registration blocks, so [`reconcile`] builds
-    /// it off the runtime and attaches it here once ready.
-    folder_watch: Mutex<Option<notify::RecommendedWatcher>>,
+    /// Keeps the folder watch alive on the shared [`FsWatchHub`]; dropped on
+    /// entry close. Filled asynchronously — FSEvents registration blocks, so
+    /// [`reconcile`] builds it off the runtime and attaches it here once ready.
+    folder_watch: Mutex<Option<FsWatch>>,
 }
 
 struct SpacesSyncInner {
@@ -141,51 +143,45 @@ fn reconcile(inner: &Arc<SpacesSyncInner>, spaces: &[Space]) {
         ));
         let _ = kick_tx.send(()); // initial check (boot / first observed)
 
-        // Non-recursive watcher on the space folder: `.git` appearing/vanishing
+        // Non-recursive watch on the space folder: `.git` appearing/vanishing
         // among the direct children is exactly the signal we need. Watch
         // failures are fine — the repair tick still converges. Built off the
-        // runtime: FSEvents registration blocks, and reconcile runs on the
-        // spaces-watch task.
+        // runtime (canonicalizing the path stats it), and reconcile runs on
+        // the spaces-watch task.
         let weak = Arc::downgrade(&entry);
         tokio::task::spawn_blocking(move || {
             let Some(entry) = weak.upgrade() else {
                 return; // entry removed before the watcher was ready
             };
-            let tx = entry.kick_tx.clone();
-            let result =
-                notify::recommended_watcher(move |event: Result<notify::Event, notify::Error>| {
-                    let Ok(event) = event else { return };
-                    if event
-                        .paths
-                        .iter()
-                        .any(|p| p.file_name().is_some_and(|n| n == ".git"))
-                    {
-                        let _ = tx.send(());
-                    }
-                });
-            match result {
-                Ok(mut watcher) => {
-                    use notify::Watcher as _;
-                    match watcher.watch(&entry.path, notify::RecursiveMode::NonRecursive) {
-                        Ok(()) => {
-                            *lock(&entry.folder_watch) = Some(watcher);
-                            // Close the check→attach gap: a `.git` change while
-                            // unwatched gets caught by this recheck.
-                            let _ = entry.kick_tx.send(());
-                        }
-                        Err(err) => {
-                            tracing::debug!(path = %entry.path.display(), error = %err, "spaces: watch failed");
-                        }
-                    }
-                }
-                Err(err) => {
-                    tracing::debug!(error = %err, "spaces: watcher create failed");
-                }
-            }
+            let watch = watch_folder(&FsWatchHub::global(), &entry);
+            *lock(&entry.folder_watch) = Some(watch);
         });
     }
 }
 
+/// Register the space folder on the shared [`FsWatchHub`] — one watcher thread
+/// for every space instead of one each. A hub rescan (the watch went live,
+/// closing the check→attach gap; or events may have been lost) rechecks like
+/// a `.git` change. A failed watch (logged by the hub) never signals; the
+/// repair tick covers it. Blocking — call from the blocking pool.
+fn watch_folder(hub: &Arc<FsWatchHub>, entry: &SpaceEntry) -> FsWatch {
+    let tx = entry.kick_tx.clone();
+    hub.watch(
+        &entry.path,
+        notify::RecursiveMode::NonRecursive,
+        move |event| {
+            if event.need_rescan()
+                || event
+                    .paths
+                    .iter()
+                    .any(|p| p.file_name().is_some_and(|n| n == ".git"))
+            {
+                let _ = tx.send(());
+            }
+        },
+    )
+}
+
 /// Per-space task: trailing-debounce kicks, then recheck git presence.
 async fn entry_task(
     inner: Weak<SpacesSyncInner>,
@@ -333,3 +329,69 @@ async fn spaces_task(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The folder watch rides the shared hub: going live sends one recheck
+    /// (the check→attach gap), `.git` appearing among the direct children
+    /// kicks, deeper churn does not (non-recursive), and a vanished folder
+    /// has no live watch and never signals.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn folder_watch_kicks_on_attach_and_git_only() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = std::fs::canonicalize(tmp.path()).unwrap();
+        std::fs::create_dir_all(root.join("src")).unwrap();
+        let (kick_tx, mut kick_rx) = mpsc::unbounded_channel();
+        let entry = Arc::new(SpaceEntry {
+            path: root.clone(),
+            kick_tx,
+            folder_watch: Mutex::new(None),
+        });
+        let hub = FsWatchHub::new();
+        let watch = {
+            let (hub, entry) = (hub.clone(), entry.clone());
+            tokio::task::spawn_blocking(move || watch_folder(&hub, &entry))
+                .await
+                .unwrap()
+        };
+        tokio::time::timeout(Duration::from_secs(5), kick_rx.recv())
+            .await
+            .expect("going live kicks a recheck")
+            .expect("kick channel open");
+        assert!(watch.is_live());
+        *lock(&entry.folder_watch) = Some(watch);
+        tokio::time::sleep(Duration::from_millis(300)).await;
+        while kick_rx.try_recv().is_ok() {}
+
+        std::fs::write(root.join("src/main.rs"), "fn main() {}").unwrap();
+        tokio::time::sleep(Duration::from_millis(500)).await;
+        assert!(kick_rx.try_recv().is_err(), "nested churn must not kick");
+
+        std::fs::create_dir(root.join(".git")).unwrap();
+        tokio::time::timeout(Duration::from_secs(5), kick_rx.recv())
+            .await
+            .expect("`.git` appearing kicks a recheck")
+            .expect("kick channel open");
+
+        let (missing_tx, mut missing_rx) = mpsc::unbounded_channel();
+        let missing = Arc::new(SpaceEntry {
+            path: root.join("gone"),
+            kick_tx: missing_tx,
+            folder_watch: Mutex::new(None),
+        });
+        let failed = {
+            let hub = hub.clone();
+            tokio::task::spawn_blocking(move || {
+                let watch = watch_folder(&hub, &missing);
+                hub.apply();
+                watch
+            })
+            .await
+            .unwrap()
+        };
+        assert!(!failed.is_live(), "a vanished folder has no live watch");
+        assert!(missing_rx.try_recv().is_err(), "and never signals");
+    }
+}
diff --git a/crates/engine/src/workspace_host.rs b/crates/engine/src/workspace_host.rs
index b272750b75..2051a1cea4 100644
--- a/crates/engine/src/workspace_host.rs
+++ b/crates/engine/src/workspace_host.rs
@@ -71,6 +71,7 @@ const RELAY_PROBE_INTERVAL_MS: u64 = 30_000;
 const RELAY_PROBE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
 /// Debounce window for local snapshot saves after a change.
 const SNAPSHOT_DEBOUNCE_MS: u64 = 1_000;
+
 /// Initial-join retry backoff (base, cap). A first registry-room join that
 /// fails must not strand the device offline until an app restart — retry until
 /// it lands. Jittered so N devices restarting together don't resynchronize
@@ -150,6 +151,12 @@ pub struct WorkspaceHostConfig {
     /// When present, the host joins `/registry/{orgId}/ws`. `None` = fully offline
     /// (local snapshots only; the registry still drives everything device-side).
     pub edge: Option<EdgeConfig>,
+    /// The profile can never attach an edge (`WorkspaceScope::Local`), so
+    /// registry writes fold straight into the local rows instead of queueing
+    /// for acks that will never come. Only then: a replica that may attach
+    /// later must keep its writes as ops — re-seeding folded rows as full
+    /// upserts would revive rows another device deleted meanwhile.
+    pub local_only: bool,
 }
 
 struct WorkspaceHostInner {
@@ -199,7 +206,8 @@ impl WorkspaceHost {
     /// Load (or migrate, or init) the registry, upsert this device's row, start
     /// the change-driven task, and join the edge registry room when configured.
     pub fn open(store: Arc<DocsStore>, config: WorkspaceHostConfig) -> Result<Self, EngineError> {
-        let mut doc = match store.load_snapshot(REGISTRY_DOC_ID)? {
+        let stored = store.load_snapshot(REGISTRY_DOC_ID)?;
+        let mut doc = match stored {
             Some(bytes) => RegistryDoc::from_bytes(&bytes, &config.device_id)
                 .map_err(|e| EngineError::Other(format!("registry snapshot load failed: {e}")))?,
             None => {
@@ -246,6 +254,12 @@ impl WorkspaceHost {
                 doc
             }
         };
+        // A Local profile never has an edge to ack a pending batch: fold the
+        // queue (a pre-fix snapshot's 178k never-acked batches, or this
+        // boot's migration seeds) into the local rows and keep folding every
+        // write. Otherwise this re-seeds once if local-only writes exist that
+        // no server has seen. The boot save below persists the result.
+        doc.set_local_only(config.local_only);
         // Destructive-break hygiene: the pre-spaces row stays unreachable.
         store.delete_snapshot(LEGACY_WORKSPACE_DOC_ID).ok();
 
@@ -316,7 +330,14 @@ impl WorkspaceHost {
         // Persist immediately: after this boot the migration source is never
         // read again, so the registry snapshot must exist even if the process
         // dies before the first debounced save.
-        host.inner.save_snapshot();
+        if let Err(error) = host.inner.persist_snapshot() {
+            tracing::warn!(%error, "registry snapshot save failed");
+        }
+        // Reclaim free pages (a bloated store, or the pages a one-time
+        // registry compaction just freed) off the boot path. The store gates
+        // the VACUUM on its own thresholds, so ordinary boots only checkpoint.
+        let store = host.inner.store.clone();
+        tokio::task::spawn_blocking(move || store.reclaim_free_space());
         host.join_room();
         tokio::spawn(workspace_task(Arc::downgrade(&host.inner), changed_rx));
         if host.inner.config.edge.is_some() {
@@ -350,6 +371,9 @@ impl WorkspaceHost {
         mut token_changes: Option<tokio::sync::watch::Receiver<u64>>,
         token: Option<Arc<dyn zeron_rpc::TokenSource>>,
     ) {
+        // A room will ack from here on (the test seam joins edge-less
+        // hosts): queue writes again, re-seeding any folded local-only ones.
+        self.mutate(|doc| doc.set_local_only(false));
         let org_id = self.inner.config.org_id.clone();
         let reg = self.inner.reg.clone();
         let device_id = self.inner.config.device_id.clone();
@@ -1362,14 +1386,18 @@ impl WorkspaceHostInner {
         }
     }
 
-    fn persist_snapshot(&self) -> Result<(), EngineError> {
+    /// Returns the snapshot's size in bytes.
+    fn persist_snapshot(&self) -> Result<usize, EngineError> {
         // Keep export and disk write serialized: an older background snapshot
         // must not overwrite an acknowledged migration's durable snapshot.
         let doc = lock(&self.reg);
         let bytes = doc.to_bytes()?;
         self.store
             .save_snapshot(REGISTRY_DOC_ID, &bytes)
-            .map_err(|error| EngineError::Other(format!("registry snapshot save failed: {error}")))
+            .map_err(|error| {
+                EngineError::Other(format!("registry snapshot save failed: {error}"))
+            })?;
+        Ok(bytes.len())
     }
 
     /// Presence heartbeat — a memory-only frame on the room, never a row write.
@@ -1731,6 +1759,7 @@ mod tests {
                 org_id: "test-org".into(),
                 user_id: "test-user".into(),
                 edge: None,
+                local_only: false,
             },
         )
         .unwrap();
@@ -1787,6 +1816,7 @@ mod tests {
                 org_id: "test-org".into(),
                 user_id: "test-user".into(),
                 edge: None,
+                local_only: false,
             },
         )
         .unwrap();
@@ -1846,6 +1876,174 @@ mod tests {
         assert_eq!(*preferences.borrow(), collapsed);
     }
 
+    /// A pre-fix `registry1` snapshot: one never-acked batch per session-row
+    /// touch. Marking each batch in flight as it is written stops the doc
+    /// coalescing; `in_flight` is not persisted, so it reloads all-unsent.
+    fn save_bloated_registry(store: &zeron_sync::DocsStore, touches: usize) -> usize {
+        use super::*;
+
+        let mut doc = RegistryDoc::new("test-device");
+        for i in 0..touches {
+            doc.upsert_session(&running_session(
+                Utc::now() + chrono::Duration::milliseconds(i as i64),
+            ))
+            .unwrap();
+            doc.take_pushable();
+        }
+        assert_eq!(doc.pending_len(), touches);
+        let bytes = doc.to_bytes().unwrap();
+        store.save_snapshot(REGISTRY_DOC_ID, &bytes).unwrap();
+        bytes.len()
+    }
+
+    fn running_session(at: chrono::DateTime<chrono::Utc>) -> zeron_proto::Session {
+        zeron_proto::Session {
+            chat_id: "chat-1".into(),
+            device_id: "test-device".into(),
+            status: zeron_proto::SessionStatus::Working,
+            last_completed_turn: None,
+            started_at: None,
+            updated_at: at,
+        }
+    }
+
+    #[tokio::test]
+    async fn local_profile_compacts_a_bloated_registry_and_never_queues() {
+        use super::*;
+
+        let dir = tempfile::tempdir().unwrap();
+        let store = Arc::new(DocsStore::open(dir.path()).unwrap());
+        let bloated = save_bloated_registry(&store, 5_000);
+        let host = WorkspaceHost::open(
+            store.clone(),
+            WorkspaceHostConfig {
+                device_id: "test-device".into(),
+                device_name: "Test device".into(),
+                platform: "macos".into(),
+                org_id: "test-org".into(),
+                user_id: "test-user".into(),
+                edge: None,
+                local_only: true,
+            },
+        )
+        .unwrap();
+        assert_eq!(host.read(|doc| doc.pending_len()), 0);
+        assert_eq!(host.read_sessions().unwrap().len(), 1);
+        // The boot save already persisted the compacted snapshot.
+        let saved = store.load_snapshot(REGISTRY_DOC_ID).unwrap().unwrap();
+        assert!(saved.len() * 100 < bloated, "{} vs {bloated}", saved.len());
+        assert_eq!(
+            RegistryDoc::from_bytes(&saved, "test-device")
+                .unwrap()
+                .pending_len(),
+            0
+        );
+
+        // The 10 s running-chat heartbeat no longer accumulates anything.
+        for i in 0..100 {
+            host.record_session(&running_session(Utc::now() + chrono::Duration::seconds(i)));
+        }
+        assert_eq!(host.read(|doc| doc.pending_len()), 0);
+    }
+
+    #[tokio::test]
+    async fn synced_profile_coalesces_a_bloated_registry() {
+        use super::*;
+
+        let dir = tempfile::tempdir().unwrap();
+        let store = Arc::new(DocsStore::open(dir.path()).unwrap());
+        save_bloated_registry(&store, 5_000);
+        let host = WorkspaceHost::open(
+            store.clone(),
+            WorkspaceHostConfig {
+                device_id: "test-device".into(),
+                device_name: "Test device".into(),
+                platform: "macos".into(),
+                org_id: "test-org".into(),
+                user_id: "test-user".into(),
+                // Unreachable edge: writes queue (and retry) without acks.
+                edge: Some(EdgeConfig::with_static_token("http://127.0.0.1:1", "test")),
+                local_only: false,
+            },
+        )
+        .unwrap();
+        // The session row and this boot's device row: in flight at most once
+        // plus one coalesced unsent op each.
+        assert!(host.read(|doc| doc.pending_ops_len()) <= 4);
+        for i in 0..100 {
+            host.record_session(&running_session(Utc::now() + chrono::Duration::seconds(i)));
+        }
+        assert!(host.read(|doc| doc.pending_ops_len()) <= 4);
+        let saved = store.load_snapshot(REGISTRY_DOC_ID).unwrap().unwrap();
+        assert!(
+            RegistryDoc::from_bytes(&saved, "test-device")
+                .unwrap()
+                .pending_ops_len()
+                <= 4
+        );
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn boot_compaction_reclaims_the_freed_store_pages() {
+        use super::*;
+
+        let dir = tempfile::tempdir().unwrap();
+        let on_disk = || {
+            ["docs.sqlite3", "docs.sqlite3-wal"]
+                .iter()
+                .map(|f| std::fs::metadata(dir.path().join(f)).map_or(0, |m| m.len()))
+                .sum::<u64>()
+        };
+        // The store opens (and runs its own maintenance) BEFORE the registry
+        // shrinks, exactly as at boot.
+        let store = Arc::new(DocsStore::open(dir.path()).unwrap());
+        // ~40 MiB of never-acked writes, built as raw snapshot JSON.
+        let mut snapshot: serde_json::Value =
+            serde_json::from_slice(&RegistryDoc::new("test-device").to_bytes().unwrap()).unwrap();
+        let preview = "x".repeat(8 * 1024);
+        snapshot["pending"] = (0..5_000)
+            .map(|i| {
+                serde_json::json!({
+                    "batch": format!("b-{i}"),
+                    "ops": [{
+                        "kind": "chats",
+                        "id": "chat-1",
+                        "op": "update",
+                        "set": { "lastMessagePreview": preview },
+                        "hlc": format!("{:013}-000000-test-device", i + 1),
+                    }],
+                })
+            })
+            .collect();
+        store
+            .save_snapshot(REGISTRY_DOC_ID, &serde_json::to_vec(&snapshot).unwrap())
+            .unwrap();
+        let bloated = on_disk();
+        assert!(bloated > 40 * 1024 * 1024, "{bloated}");
+
+        let _host = WorkspaceHost::open(
+            store.clone(),
+            WorkspaceHostConfig {
+                device_id: "test-device".into(),
+                device_name: "Test device".into(),
+                platform: "macos".into(),
+                org_id: "test-org".into(),
+                user_id: "test-user".into(),
+                edge: None,
+                local_only: true,
+            },
+        )
+        .unwrap();
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
+        while on_disk() * 4 > bloated {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "store not reclaimed after the boot compaction"
+            );
+            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+        }
+    }
+
     #[test]
     fn boot_repairs_the_legacy_unknown_device_sentinel() {
         assert_eq!(
diff --git a/crates/engine/tests/diff_sync_churn.rs b/crates/engine/tests/diff_sync_churn.rs
index 658b79aabd..a5af10bb96 100644
--- a/crates/engine/tests/diff_sync_churn.rs
+++ b/crates/engine/tests/diff_sync_churn.rs
@@ -285,3 +285,333 @@ async fn deleted_checkout_is_evicted_after_grace() {
     );
     core.shutdown().await;
 }
+
+/// Block until the chat watch shows `chat_id` with the given archived flag.
+async fn wait_chat_archived(core: &EngineCore, chat_id: &str, archived: bool) {
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(60);
+    loop {
+        let settled = core
+            .workspace
+            .watch_chats()
+            .borrow()
+            .iter()
+            .any(|c| c.id == chat_id && c.archived == archived);
+        if settled {
+            return;
+        }
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "chat archive state settled before timeout"
+        );
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
+/// Poll until the checkout under `root` is tracked with at least one live
+/// fs watch (watches attach on the blocking pool after the entry is added).
+async fn wait_watched(sync: &CheckoutDiffSync, root: &Path) {
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(60);
+    loop {
+        if sync
+            .tracked_checkouts()
+            .iter()
+            .any(|(tracked, watches)| tracked == root && *watches > 0)
+        {
+            return;
+        }
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "checkout watched before timeout"
+        );
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
+/// Archived chats cost nothing: no entry, no watch, no capture. Unarchiving
+/// tracks the checkout again, and re-archiving drops it at once — archiving is
+/// a deliberate state change, not a row flap, so it skips the orphan grace.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn archived_chats_get_no_entry_and_archiving_drops_it() {
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let live_dir = tmp.path().join("live");
+    let archived_dir = tmp.path().join("archived");
+    init_dirty_repo(&live_dir).await;
+    init_dirty_repo(&archived_dir).await;
+    let live_root = std::fs::canonicalize(&live_dir).unwrap();
+    let archived_root = std::fs::canonicalize(&archived_dir).unwrap();
+
+    let core = assemble(&tmp.path().join("data"));
+    // A grace far beyond the test: any removal observed here is the
+    // archive fast path, not the orphan timeout.
+    let sync = CheckoutDiffSync::start_with_orphan_grace(
+        core.repos.clone(),
+        core.workspace.clone(),
+        &core.device_id,
+        None,
+        Duration::from_secs(3600),
+    );
+    for (space, dir) in [("space-live", &live_dir), ("space-arch", &archived_dir)] {
+        core.workspace
+            .create_space(space, &core.device_id, &dir.to_string_lossy(), None, true)
+            .expect("space row");
+    }
+    core.workspace
+        .create_chat("chat-live", Some("space-live"), None, None, None)
+        .expect("live chat");
+    core.workspace
+        .create_chat("chat-arch", Some("space-arch"), None, None, None)
+        .expect("archived chat");
+    core.workspace
+        .set_chat_archived("chat-arch", true)
+        .expect("archive");
+    wait_chat_state(&core, "chat-live", true).await;
+    wait_chat_archived(&core, "chat-arch", true).await;
+
+    sync.repair_now().await;
+    wait_watched(&sync, &live_root).await;
+    let tracked: Vec<_> = sync
+        .tracked_checkouts()
+        .into_iter()
+        .map(|(root, _)| root)
+        .collect();
+    assert_eq!(
+        tracked,
+        vec![live_root.clone()],
+        "archived chat's checkout is not tracked"
+    );
+    wait_for_diff(&sync).await;
+    assert!(
+        current_diffs(&sync)
+            .iter()
+            .all(|diff| Path::new(&diff.cwd) == live_root),
+        "no capture is published for an archived chat's checkout"
+    );
+
+    // Unarchive: the checkout is tracked and watched again.
+    core.workspace
+        .set_chat_archived("chat-arch", false)
+        .expect("unarchive");
+    wait_chat_archived(&core, "chat-arch", false).await;
+    sync.reconcile_now().await;
+    wait_watched(&sync, &archived_root).await;
+
+    // Re-archive: the entry (watches, published diff) goes on this pass.
+    core.workspace
+        .set_chat_archived("chat-arch", true)
+        .expect("re-archive");
+    wait_chat_archived(&core, "chat-arch", true).await;
+    sync.reconcile_now().await;
+    let tracked: Vec<_> = sync
+        .tracked_checkouts()
+        .into_iter()
+        .map(|(root, _)| root)
+        .collect();
+    assert_eq!(
+        tracked,
+        vec![live_root.clone()],
+        "archiving drops the entry at once"
+    );
+    assert!(
+        current_diffs(&sync)
+            .iter()
+            .all(|diff| Path::new(&diff.cwd) == live_root),
+        "archiving drops the checkout's published diff"
+    );
+    core.shutdown().await;
+}
+
+fn chat_row(core: &EngineCore, chat_id: &str) -> zeron_proto::Chat {
+    core.workspace
+        .watch_chats()
+        .borrow()
+        .iter()
+        .find(|c| c.id == chat_id)
+        .cloned()
+        .expect("chat row")
+}
+
+/// Poll until `check` holds or panic with `what`.
+async fn eventually(what: &str, mut check: impl FnMut() -> bool) {
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(60);
+    while !check() {
+        assert!(tokio::time::Instant::now() < deadline, "{what}");
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
+/// An archived chat someone has open (an engine-held interest guard — one
+/// per transcript stream) keeps full functionality: its checkout is tracked
+/// and watched, the live diff is published, and its `checkoutId` is stamped
+/// even though it was archived before it ever was a checkout. Once the last
+/// viewer leaves and the linger lapses, the checkout is released again.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn open_archived_chat_is_tracked_until_interest_lapses() {
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let dir = tmp.path().join("folder");
+    std::fs::create_dir_all(&dir).unwrap();
+
+    let core = assemble(&tmp.path().join("data"));
+    let sync = CheckoutDiffSync::start_with_timings(
+        core.repos.clone(),
+        core.workspace.clone(),
+        &core.device_id,
+        None,
+        Duration::from_secs(3600),
+        Duration::from_millis(300),
+    );
+    core.workspace
+        .create_space(
+            "space-1",
+            &core.device_id,
+            &dir.to_string_lossy(),
+            None,
+            true,
+        )
+        .expect("space row");
+    core.workspace
+        .create_chat("chat-1", Some("space-1"), None, None, None)
+        .expect("chat row");
+    core.workspace
+        .set_chat_archived("chat-1", true)
+        .expect("archive");
+    wait_chat_archived(&core, "chat-1", true).await;
+    // Only now does the folder become a checkout: the archived chat has never
+    // been grouped, so nothing has stamped its checkoutId.
+    init_dirty_repo(&dir).await;
+    let root = std::fs::canonicalize(&dir).unwrap();
+    sync.repair_now().await;
+    assert!(
+        sync.tracked_checkouts().is_empty(),
+        "archived and unopened: free"
+    );
+    assert_eq!(chat_row(&core, "chat-1").checkout_id, None);
+
+    let interest = sync.retain_chat("chat-1");
+    wait_watched(&sync, &root).await;
+    let diff = wait_for_diff(&sync).await;
+    assert_eq!(
+        Path::new(&diff.cwd),
+        root,
+        "the open chat's live diff is published"
+    );
+    eventually("checkoutId stamped for the open archived chat", || {
+        chat_row(&core, "chat-1").checkout_id.as_deref() == Some(diff.checkout_id.as_str())
+    })
+    .await;
+
+    // Edits while open still flow through the live watch.
+    std::fs::write(dir.join("a.txt"), "changed while open\n").unwrap();
+    eventually("live diff follows edits", || {
+        current_diffs(&sync)
+            .first()
+            .is_some_and(|d| d.checksum != diff.checksum)
+    })
+    .await;
+
+    drop(interest);
+    eventually("released once the linger lapses", || {
+        sync.tracked_checkouts().is_empty() && current_diffs(&sync).is_empty()
+    })
+    .await;
+    core.shutdown().await;
+}
+
+/// Discard needs no entry: an archived chat's checkout (nobody watching) is
+/// discarded directly, still guarded by the snapshot checksum.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn discard_works_for_an_untracked_checkout() {
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let dir = tmp.path().join("repo");
+    init_dirty_repo(&dir).await;
+    let core = assemble(&tmp.path().join("data"));
+    let sync = CheckoutDiffSync::start_with_orphan_grace(
+        core.repos.clone(),
+        core.workspace.clone(),
+        &core.device_id,
+        None,
+        Duration::from_secs(3600),
+    );
+    let identity = core.repos.checkout_identity(&dir).await.expect("identity");
+    assert!(sync.tracked_checkouts().is_empty());
+
+    let stale = sync
+        .discard_working_tree(&identity, "not-the-checksum")
+        .await;
+    assert!(stale.is_err(), "a stale checksum is refused");
+    assert_eq!(
+        std::fs::read_to_string(dir.join("a.txt")).unwrap(),
+        "one\ntwo\nedited\n"
+    );
+
+    let snapshot = zeron_engine::capture_diff(&core.repos, &identity.root)
+        .await
+        .expect("capture");
+    sync.discard_working_tree(&identity, &snapshot.checksum)
+        .await
+        .expect("discard without an entry");
+    assert_eq!(
+        std::fs::read_to_string(dir.join("a.txt")).unwrap(),
+        "one\ntwo\n"
+    );
+    core.shutdown().await;
+}
+
+/// While a checkout's chats are gone (orphan grace pending), neither repair
+/// kicks nor fs churn re-capture it; if the chats come back, the skipped work
+/// is caught up at once.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn orphaned_entry_skips_captures_and_catches_up_on_return() {
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let dir = tmp.path().join("repo");
+    init_dirty_repo(&dir).await;
+    let core = assemble(&tmp.path().join("data"));
+    let sync = CheckoutDiffSync::start_with_orphan_grace(
+        core.repos.clone(),
+        core.workspace.clone(),
+        &core.device_id,
+        None,
+        Duration::from_secs(3600),
+    );
+    core.workspace
+        .create_space(
+            "space-1",
+            &core.device_id,
+            &dir.to_string_lossy(),
+            None,
+            true,
+        )
+        .expect("space row");
+    core.workspace
+        .create_chat("chat-1", Some("space-1"), None, None, None)
+        .expect("chat row");
+    wait_chat_state(&core, "chat-1", true).await;
+    sync.reconcile_now().await;
+    let root = std::fs::canonicalize(&dir).unwrap();
+    wait_watched(&sync, &root).await;
+    let before = wait_for_diff(&sync).await;
+
+    core.workspace.delete_chat("chat-1").expect("delete chat");
+    wait_chat_state(&core, "chat-1", false).await;
+    sync.reconcile_now().await; // marks orphaned
+    std::fs::write(dir.join("a.txt"), "edited while orphaned\n").unwrap();
+    sync.sync_all(); // a repair tick's kick
+    tokio::time::sleep(Duration::from_secs(3)).await;
+    assert_eq!(
+        current_diffs(&sync)[0].checksum,
+        before.checksum,
+        "no capture for a chat-less checkout"
+    );
+
+    core.workspace
+        .create_chat("chat-1", Some("space-1"), None, None, None)
+        .expect("chat row again");
+    wait_chat_state(&core, "chat-1", true).await;
+    sync.reconcile_now().await;
+    eventually("skipped capture caught up on return", || {
+        current_diffs(&sync)
+            .first()
+            .is_some_and(|d| d.checksum != before.checksum)
+    })
+    .await;
+    core.shutdown().await;
+}
diff --git a/crates/engine/tests/e2e.rs b/crates/engine/tests/e2e.rs
index 18ffb0c5cc..30b2232eb9 100644
--- a/crates/engine/tests/e2e.rs
+++ b/crates/engine/tests/e2e.rs
@@ -3117,7 +3117,9 @@ async fn generated_image_is_materialized_before_publication_and_survives_reopen(
         })
         .collect();
     assert_eq!(images.len(), 1);
-    assert!(std::path::Path::new(&images[0]).starts_with(uploads.dir()));
+    // Materialization canonicalizes the uploads dir; macOS temp dirs sit
+    // behind the /var -> /private/var symlink.
+    assert!(std::path::Path::new(&images[0]).starts_with(uploads.dir().canonicalize().unwrap()));
     let serialized = serde_json::to_string(&journal.replay(CHAT, 0).unwrap()).unwrap();
     assert!(!serialized.contains(source.to_str().unwrap()));
     assert!(!serialized.contains("BASE64_SENTINEL"));
diff --git a/crates/sync/src/store.rs b/crates/sync/src/store.rs
index 83ee6ebea1..d5ff71b1f1 100644
--- a/crates/sync/src/store.rs
+++ b/crates/sync/src/store.rs
@@ -5,7 +5,7 @@
 use std::collections::HashSet;
 use std::path::Path;
 use std::sync::{Mutex, MutexGuard, PoisonError};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use rusqlite::{Connection, OptionalExtension, params};
 
@@ -76,6 +76,26 @@ const MIGRATIONS: &[&str] = &[
     "ALTER TABLE chat_sync_jobs ADD COLUMN cursor TEXT NOT NULL DEFAULT '';",
 ];
 
+const STORE_BUSY_TIMEOUT: Duration = Duration::from_secs(5);
+
+/// WAL size retained after a checkpoint resets the log. SQLite's default (-1)
+/// keeps the file at its all-time high-water mark (observed: 400 MB). Steady
+/// state never reaches this — auto-checkpoint folds the log every ~4 MB
+/// (1000 pages) — so the cap only bites after a large burst (a multi-MB
+/// snapshot, a VACUUM). 64 MiB bounds idle disk use while sparing ordinary
+/// bursts a truncate/re-extend cycle on every write.
+const JOURNAL_SIZE_LIMIT_BYTES: i64 = 64 * 1024 * 1024;
+
+/// VACUUM ([`DocsStore::reclaim_free_space`]) only when free pages are BOTH a large share of the file
+/// and a meaningful absolute size: a healthy database never pays the rewrite.
+const VACUUM_MIN_FREE_BYTES: i64 = 32 * 1024 * 1024;
+/// `freelist_count / page_count` above which reclaiming is worth a rewrite.
+const VACUUM_MIN_FREE_DENOMINATOR: i64 = 4;
+
+/// Maintenance is skipped (and logged) rather than waited on when another
+/// connection holds a lock.
+const MAINTENANCE_BUSY_TIMEOUT: Duration = Duration::from_millis(250);
+
 /// SQLite-backed store under a data directory (`{data_dir}/docs.sqlite3`).
 ///
 /// Holds warm-open doc snapshots (the DO room is authoritative; these make
@@ -93,11 +113,20 @@ impl DocsStore {
     pub fn open(data_dir: impl AsRef<Path>) -> Result<Self, StoreError> {
         let data_dir = data_dir.as_ref();
         std::fs::create_dir_all(data_dir)?;
-        let mut conn = Connection::open(data_dir.join("docs.sqlite3"))?;
+        let path = data_dir.join("docs.sqlite3");
+        let mut conn = Connection::open(&path)?;
         conn.pragma_update(None, "journal_mode", "WAL")?;
         conn.pragma_update(None, "synchronous", "NORMAL")?;
-        conn.busy_timeout(std::time::Duration::from_secs(5))?;
+        conn.pragma_update(None, "journal_size_limit", JOURNAL_SIZE_LIMIT_BYTES)?;
+        conn.busy_timeout(STORE_BUSY_TIMEOUT)?;
         migrate(&mut conn)?;
+        // Best-effort hygiene must never stall boot behind another connection.
+        conn.busy_timeout(MAINTENANCE_BUSY_TIMEOUT)?;
+        // Only the cheap WAL truncate here: open sits on boot paths (engine
+        // assembly, the iOS client), and a VACUUM's cost is linear in the
+        // live size. Callers run `reclaim_free_space` off those paths.
+        checkpoint_truncate(&conn, &path, "open");
+        conn.busy_timeout(STORE_BUSY_TIMEOUT)?;
         Ok(Self {
             conn: Mutex::new(conn),
             failed_publications: Mutex::new(HashSet::new()),
@@ -562,6 +591,28 @@ impl DocsStore {
         Ok(())
     }
 
+    /// Reclaim free space: WAL truncate, then a VACUUM only past the
+    /// free-page thresholds, under a short busy timeout. Cheap when there is
+    /// nothing to reclaim. Blocking and holds the store for the VACUUM (it
+    /// rewrites the live database) — run it off any latency-sensitive path;
+    /// best-effort — problems are logged, never returned.
+    pub fn reclaim_free_space(&self) {
+        store_blocking(|| {
+            let conn = self.conn();
+            let Some(path) = conn.path().map(std::path::PathBuf::from) else {
+                return;
+            };
+            if let Err(err) = conn.busy_timeout(MAINTENANCE_BUSY_TIMEOUT) {
+                tracing::warn!(%err, "docs store: reclaim skipped");
+                return;
+            }
+            maintain(&conn, &path);
+            if let Err(err) = conn.busy_timeout(STORE_BUSY_TIMEOUT) {
+                tracing::warn!(%err, "docs store: busy timeout not restored after reclaim");
+            }
+        });
+    }
+
     pub(crate) fn conn(&self) -> MutexGuard<'_, Connection> {
         // A poisoned lock only means another thread panicked mid-query; the
         // connection itself is still usable.
@@ -597,6 +648,81 @@ fn migrate(conn: &mut Connection) -> Result<(), StoreError> {
     Ok(())
 }
 
+/// Fold and truncate a bloated WAL, then reclaim free pages if they dominate
+/// the file. Every step is best-effort — failures (including SQLITE_BUSY from
+/// another connection) are logged. Steady-state WAL growth is handled by
+/// SQLite's auto-checkpoint plus `journal_size_limit`, so there is no
+/// periodic pass.
+fn maintain(conn: &Connection, path: &Path) {
+    checkpoint_truncate(conn, path, "open");
+    match reclaim_free_pages(conn) {
+        // VACUUM in WAL mode writes the whole live database into the WAL.
+        Ok(true) => checkpoint_truncate(conn, path, "vacuum"),
+        Ok(false) => {}
+        Err(err) => tracing::warn!(%err, "docs store: VACUUM skipped"),
+    }
+}
+
+/// `PRAGMA wal_checkpoint(TRUNCATE)`; logs instead of failing.
+fn checkpoint_truncate(conn: &Connection, path: &Path, reason: &str) {
+    let wal_path = path.with_extension("sqlite3-wal");
+    let wal_bytes = || std::fs::metadata(&wal_path).map_or(0, |m| m.len());
+    let before = wal_bytes();
+    let result = conn.query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |row| {
+        Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?))
+    });
+    match result {
+        Ok((0, frames)) => {
+            if before > 0 {
+                tracing::info!(
+                    reason,
+                    frames,
+                    wal_bytes_before = before,
+                    wal_bytes_after = wal_bytes(),
+                    "docs store: WAL checkpointed and truncated"
+                );
+            }
+        }
+        Ok((_, frames)) => tracing::warn!(
+            reason,
+            frames,
+            wal_bytes = before,
+            "docs store: WAL checkpoint busy (another connection is active); left for later"
+        ),
+        Err(err) => tracing::warn!(reason, %err, "docs store: WAL checkpoint failed"),
+    }
+}
+
+/// VACUUM when free pages are both a large fraction of the file and above an
+/// absolute floor. Returns whether a VACUUM ran. Rewrite cost is linear in the
+/// LIVE size (~0.6 s for 150 MB live / 70 MB free on an M-series SSD, warm
+/// cache); healthy databases skip it entirely.
+fn reclaim_free_pages(conn: &Connection) -> rusqlite::Result<bool> {
+    let pragma = |name: &str| conn.pragma_query_value(None, name, |row| row.get::<_, i64>(0));
+    let page_size = pragma("page_size")?;
+    let page_count = pragma("page_count")?;
+    let freelist = pragma("freelist_count")?;
+    if !worth_vacuuming(page_size, page_count, freelist) {
+        return Ok(false);
+    }
+    let started = Instant::now();
+    conn.execute_batch("VACUUM")?;
+    let after = pragma("page_count")? * page_size;
+    tracing::info!(
+        bytes_before = page_count * page_size,
+        bytes_after = after,
+        free_bytes = freelist * page_size,
+        elapsed_ms = started.elapsed().as_millis() as u64,
+        "docs store: reclaimed free pages with VACUUM"
+    );
+    Ok(true)
+}
+
+fn worth_vacuuming(page_size: i64, page_count: i64, freelist: i64) -> bool {
+    freelist * page_size >= VACUUM_MIN_FREE_BYTES
+        && freelist * VACUUM_MIN_FREE_DENOMINATOR >= page_count
+}
+
 fn now_ms() -> i64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -847,3 +973,176 @@ mod publication_failure_tests {
         }
     }
 }
+
+#[cfg(test)]
+mod maintenance_tests {
+    use super::*;
+
+    const MIB: usize = 1024 * 1024;
+
+    fn pragma(conn: &Connection, name: &str) -> i64 {
+        conn.pragma_query_value(None, name, |row| row.get(0))
+            .unwrap()
+    }
+
+    fn file_len(path: &Path) -> u64 {
+        std::fs::metadata(path).map_or(0, |m| m.len())
+    }
+
+    /// 48 MiB of snapshots, 40 MiB of them deleted: well past both thresholds.
+    fn fragmented_store(dir: &Path) {
+        let store = DocsStore::open(dir).unwrap();
+        for i in 0..48 {
+            store
+                .save_snapshot(&format!("d{i}"), &vec![7; MIB])
+                .unwrap();
+        }
+        for i in 0..40 {
+            store.delete_snapshot(&format!("d{i}")).unwrap();
+        }
+        let conn = store.conn();
+        assert!(worth_vacuuming(
+            pragma(&conn, "page_size"),
+            pragma(&conn, "page_count"),
+            pragma(&conn, "freelist_count")
+        ));
+    }
+
+    #[test]
+    fn open_folds_and_truncates_a_bloated_wal() {
+        let dir = tempfile::tempdir().unwrap();
+        drop(DocsStore::open(dir.path()).unwrap());
+        let wal = dir.path().join("docs.sqlite3-wal");
+        // A live connection keeps the WAL from being cleaned up on close.
+        let other = Connection::open(dir.path().join("docs.sqlite3")).unwrap();
+        other.pragma_update(None, "wal_autocheckpoint", 0).unwrap();
+        for i in 0..8 {
+            other
+                .execute(
+                    "INSERT INTO snapshots(doc_id,bytes,saved_at) VALUES (?1,zeroblob(?2),0)",
+                    params![format!("d{i}"), MIB as i64],
+                )
+                .unwrap();
+        }
+        assert!(file_len(&wal) > 8 * MIB as u64);
+
+        let store = DocsStore::open(dir.path()).unwrap();
+        assert_eq!(file_len(&wal), 0, "boot checkpoint truncates the WAL");
+        assert!(store.has_snapshot("d7").unwrap(), "frames folded, not lost");
+        assert_eq!(
+            pragma(&store.conn(), "journal_size_limit"),
+            JOURNAL_SIZE_LIMIT_BYTES
+        );
+    }
+
+    #[test]
+    fn reclaim_vacuums_a_fragmented_database_once() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = dir.path().join("docs.sqlite3");
+        fragmented_store(dir.path());
+        let before = file_len(&db);
+
+        let store = DocsStore::open(dir.path()).unwrap();
+        // Open never pays for the rewrite; the reclaim pass does.
+        assert!(pragma(&store.conn(), "freelist_count") > 0);
+        store.reclaim_free_space();
+        assert_eq!(pragma(&store.conn(), "freelist_count"), 0);
+        assert!(file_len(&db) < before / 2, "file shrank");
+        assert_eq!(file_len(&dir.path().join("docs.sqlite3-wal")), 0);
+        assert_eq!(store.load_snapshot("d47").unwrap().unwrap().len(), MIB);
+        assert!(
+            !reclaim_free_pages(&store.conn()).unwrap(),
+            "a compacted database is not rewritten again"
+        );
+    }
+
+    #[test]
+    fn reclaim_after_a_post_open_shrink_vacuums_without_a_relaunch() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = dir.path().join("docs.sqlite3");
+        // Open-time maintenance finds nothing to do; the shrink happens after.
+        let store = DocsStore::open(dir.path()).unwrap();
+        store
+            .save_snapshot("registry1", &vec![7; 48 * MIB])
+            .unwrap();
+        store.save_snapshot("registry1", &vec![7; MIB]).unwrap();
+        assert!(pragma(&store.conn(), "freelist_count") > 0);
+        let before = file_len(&db);
+
+        store.reclaim_free_space();
+        assert_eq!(pragma(&store.conn(), "freelist_count"), 0);
+        assert!(file_len(&db) < before / 2, "file shrank");
+        assert_eq!(file_len(&dir.path().join("docs.sqlite3-wal")), 0);
+        assert_eq!(
+            store.load_snapshot("registry1").unwrap().unwrap().len(),
+            MIB
+        );
+        // The busy timeout is back at the store's normal wait.
+        let busy: i64 = pragma(&store.conn(), "busy_timeout");
+        assert_eq!(busy, STORE_BUSY_TIMEOUT.as_millis() as i64);
+        // Idempotent and cheap once compact.
+        store.reclaim_free_space();
+        assert_eq!(pragma(&store.conn(), "freelist_count"), 0);
+    }
+
+    #[test]
+    fn small_or_proportionally_minor_freelists_are_left_alone() {
+        let dir = tempfile::tempdir().unwrap();
+        let store = DocsStore::open(dir.path()).unwrap();
+        for i in 0..4 {
+            store
+                .save_snapshot(&format!("d{i}"), &vec![7; MIB])
+                .unwrap();
+        }
+        for i in 0..3 {
+            store.delete_snapshot(&format!("d{i}")).unwrap();
+        }
+        let freelist = pragma(&store.conn(), "freelist_count");
+        assert!(freelist > 0);
+        assert!(!reclaim_free_pages(&store.conn()).unwrap(), "below 32 MiB");
+        assert_eq!(pragma(&store.conn(), "freelist_count"), freelist);
+
+        let page = 4096;
+        let floor = VACUUM_MIN_FREE_BYTES / page;
+        assert!(worth_vacuuming(page, floor * 4, floor));
+        assert!(!worth_vacuuming(page, floor * 4 + 1, floor), "under 25%");
+        assert!(!worth_vacuuming(page, floor, floor - 1), "under the floor");
+    }
+
+    #[test]
+    fn maintenance_yields_to_a_connection_holding_the_database() {
+        // WAL lets VACUUM proceed beside a reader; a held write lock defers it.
+        for (lock, vacuumed) in [
+            ("BEGIN; SELECT count(*) FROM snapshots;", true),
+            ("BEGIN IMMEDIATE;", false),
+        ] {
+            let dir = tempfile::tempdir().unwrap();
+            fragmented_store(dir.path());
+            let other = Connection::open(dir.path().join("docs.sqlite3")).unwrap();
+            other.execute_batch(lock).unwrap();
+
+            let started = Instant::now();
+            let store = DocsStore::open(dir.path()).expect("maintenance never fails open");
+            store.reclaim_free_space();
+            assert!(
+                started.elapsed() < Duration::from_secs(3),
+                "{lock}: maintenance waited on the store busy timeout"
+            );
+            assert_eq!(store.load_snapshot("d47").unwrap().unwrap().len(), MIB);
+            assert_eq!(
+                pragma(&store.conn(), "freelist_count") == 0,
+                vacuumed,
+                "{lock}"
+            );
+
+            other.execute_batch("COMMIT").unwrap();
+            store.save_snapshot("after", b"ok").unwrap();
+            assert!(store.has_snapshot("after").unwrap());
+            drop(store);
+            // A deferred VACUUM simply runs on the next uncontended pass.
+            let store = DocsStore::open(dir.path()).unwrap();
+            store.reclaim_free_space();
+            assert_eq!(pragma(&store.conn(), "freelist_count"), 0, "{lock}");
+        }
+    }
+}
diff --git a/crates/ui/src/change_requests.rs b/crates/ui/src/change_requests.rs
index d660830994..ee81ed45cb 100644
--- a/crates/ui/src/change_requests.rs
+++ b/crates/ui/src/change_requests.rs
@@ -242,10 +242,33 @@ impl ChangeRequestClientState {
         true
     }
 
-    pub fn store(&mut self, key: ChangeRequestWatchKey, snapshot: CheckoutChangeRequestStatus) {
+    /// Returns whether the frame changes what any row can render. Snapshots
+    /// only surface through their `change_request` (re-validated against the
+    /// identity fields), so a first "no PR" frame or a bare `updated_at` bump
+    /// stores silently.
+    pub fn store(
+        &mut self,
+        key: ChangeRequestWatchKey,
+        snapshot: CheckoutChangeRequestStatus,
+    ) -> bool {
+        fn visible(
+            snapshot: &CheckoutChangeRequestStatus,
+        ) -> Option<(&str, &str, &str, &str, &ChangeRequestSummary)> {
+            snapshot.change_request.as_ref().map(|summary| {
+                (
+                    snapshot.device_id.as_str(),
+                    snapshot.cwd.as_str(),
+                    snapshot.branch.as_str(),
+                    snapshot.checkout_id.as_str(),
+                    summary,
+                )
+            })
+        }
+        let changed = self.snapshots.get(&key).and_then(visible) != visible(&snapshot);
         // A new frame replaces the old branch/checkout context for this path.
         // Rendering validates the complete identity again before exposing it.
         self.snapshots.insert(key, snapshot);
+        changed
     }
 
     pub fn retain_targets(&mut self, targets: &HashSet<ChangeRequestWatchKey>) {
@@ -596,6 +619,30 @@ mod tests {
         assert!(state.change_request_for_chat(&chat, &[]).is_none());
     }
 
+    #[test]
+    fn store_reports_only_visible_changes() {
+        let key = ChangeRequestWatchKey {
+            device_id: "local".into(),
+            cwd: "/repo".into(),
+            branch: "feature/pr".into(),
+            checkout_id: Some("checkout".into()),
+        };
+        let mut none = snapshot("local", "/repo", "checkout");
+        none.change_request = None;
+        let mut state = ChangeRequestClientState::default();
+        // A first "no PR" frame renders nothing new.
+        assert!(!state.store(key.clone(), none.clone()));
+        assert!(state.store(key.clone(), snapshot("local", "/repo", "checkout")));
+        // The host re-polls: identical PR, fresher timestamp.
+        let mut refreshed = snapshot("local", "/repo", "checkout");
+        refreshed.updated_at = Utc.timestamp_opt(60, 0).unwrap();
+        assert!(!state.store(key.clone(), refreshed.clone()));
+        let mut merged = refreshed;
+        merged.change_request.as_mut().unwrap().state = ChangeRequestState::Merged;
+        assert!(state.store(key.clone(), merged));
+        assert!(state.store(key, none));
+    }
+
     #[test]
     fn local_and_remote_watch_params_route_to_the_checkout_host() {
         let target = ChangeRequestWatchKey {
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 16a5c3191d..24b76c82e4 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -8365,7 +8365,9 @@ impl Composer {
     fn on_state_changed(&mut self, cx: &mut Context<Self>) {
         {
             let state = self.state.read(cx);
-            let now = chrono::Utc::now();
+            // AppState also notifies at clock-only transitions, so a run that
+            // goes stale drops its interrupt at the cutoff.
+            let now = crate::state::clock_now();
             retain_live_interrupts(&mut self.interrupting, |chat_id| {
                 matches!(
                     state.indicator_for(chat_id, now),
@@ -12545,6 +12547,47 @@ mod tests {
         assert!(server_in.try_recv().is_err());
     }
 
+    /// A run that goes stale purely by the clock (no state frame) drops its
+    /// pending interrupt at the staleness cutoff, not at some later
+    /// unrelated state change.
+    #[gpui::test]
+    fn interrupt_drops_when_its_run_goes_stale_by_clock_alone(cx: &mut gpui::TestAppContext) {
+        use chrono::TimeDelta;
+        let now = chrono::DateTime::parse_from_rfc3339("2026-07-19T12:00:00Z")
+            .unwrap()
+            .to_utc();
+        let clock = crate::state::TestClock::start(now);
+        let updated = now - TimeDelta::seconds(10);
+        let state = cx.new(|cx| {
+            let mut state = AppState::new();
+            state.sessions = vec![zeron_proto::Session {
+                last_completed_turn: None,
+                chat_id: "c".into(),
+                device_id: "remote".into(),
+                status: zeron_proto::SessionStatus::Working,
+                started_at: Some(updated),
+                updated_at: updated,
+            }];
+            state.selected_chat = Some("c".into());
+            state.watch_clock_transitions(cx);
+            state
+        });
+        let composer = cx.new(|cx| Composer::new(state, cx));
+        composer.update(cx, |composer, _| {
+            assert!(begin_interrupt(&mut composer.interrupting, "c"));
+        });
+        let cutoff = updated + TimeDelta::milliseconds(crate::state::SESSION_STALE_MS + 1);
+        let before = cutoff - TimeDelta::milliseconds(1);
+        clock.set(before);
+        cx.executor()
+            .advance_clock((before - now).to_std().unwrap());
+        assert!(composer.read_with(cx, |composer, _| composer.is_interrupting("c")));
+        clock.set(cutoff);
+        cx.executor()
+            .advance_clock(std::time::Duration::from_millis(1));
+        assert!(!composer.read_with(cx, |composer, _| composer.is_interrupting("c")));
+    }
+
     #[gpui::test]
     fn inline_reference_text_preserves_selection_and_ime(cx: &mut gpui::TestAppContext) {
         let (_dir, handle) = composer_focus_window(cx);
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index a5d06796b3..218eeccb7f 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -200,7 +200,11 @@ pub fn run_app(config: UiConfig) {
         app_update::AppUpdate::init(config.boot().edge_url, data_dir.clone(), cx);
         cx.register_url_scheme("zeron").detach();
 
-        let state = cx.new(|_| state::AppState::new());
+        let state = cx.new(|cx| {
+            let mut state = state::AppState::new();
+            state.watch_clock_transitions(cx);
+            state
+        });
         let url_state = state.clone();
         cx.spawn(async move |cx| {
             while let Some(url) = url_rx.next().await {
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index 9c0162a8fc..c2eb984c81 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -14,7 +14,7 @@
 use std::path::PathBuf;
 use std::time::Duration;
 
-use chrono::Utc;
+use chrono::{DateTime, Utc};
 use gpui::{
     Action, AnyElement, App, ClipboardItem, Context, Empty, Entity, FocusHandle, Focusable as _,
     IntoElement, KeyBinding, Keystroke, ModifiersChangedEvent, MouseButton, MouseDownEvent,
@@ -1511,6 +1511,63 @@ enum ShellEscapeOutcome {
     Ignored,
 }
 
+/// When the shell next has render-only clock pixels to repaint, as of `now`:
+/// every second while the selected chat is Working (the trailer's elapsed
+/// timer and its 7s flavour word), else the next wall-clock minute for
+/// relative "5m"/"2h" labels. State transitions (staleness, device presence,
+/// send grace) arrive as AppState notifications instead — see
+/// [`AppState::watch_clock_transitions`]. Nothing else ticks: AwaitingInput
+/// and Errored show no clock, and the connection pill has no countdown (its
+/// spinner animates itself).
+fn shell_clock_wake(state: &AppState, now: DateTime<Utc>) -> DateTime<Utc> {
+    let working = state
+        .selected_chat
+        .as_deref()
+        .is_some_and(|id| state.indicator_for(id, now) == Indicator::Working);
+    if working {
+        return now + chrono::TimeDelta::seconds(1);
+    }
+    DateTime::from_timestamp((now.timestamp().div_euclid(60) + 1) * 60, 0)
+        .unwrap_or(now + chrono::TimeDelta::minutes(1))
+}
+
+/// A one-shot redraw timer, re-armed on every render for the view's next
+/// clock-driven change. Idle views sleep until that deadline instead of
+/// polling.
+#[derive(Default)]
+struct ClockRedraw {
+    wake_at: Option<DateTime<Utc>>,
+    task: Option<Task<()>>,
+}
+
+impl ClockRedraw {
+    /// Notify the view at `wake` unless a redraw is already due no later.
+    /// `slot` finds this timer on the view so the firing task can clear it.
+    fn arm<V: 'static>(
+        &mut self,
+        wake: DateTime<Utc>,
+        now: DateTime<Utc>,
+        slot: fn(&mut V) -> &mut ClockRedraw,
+        cx: &mut Context<V>,
+    ) {
+        if self.task.is_some() && self.wake_at.is_some_and(|at| at <= wake) {
+            return;
+        }
+        let delay = (wake - now).to_std().unwrap_or_default();
+        self.wake_at = Some(wake);
+        self.task = Some(cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(delay).await;
+            this.update(cx, |view, cx| {
+                let clock = slot(view);
+                clock.wake_at = None;
+                clock.task = None;
+                cx.notify();
+            })
+            .ok();
+        }));
+    }
+}
+
 fn resolve_shell_escape(
     key: &str,
     blocking_overlay: bool,
@@ -2151,8 +2208,8 @@ pub struct Shell {
     /// Clears the jump hints when the window deactivates: a Cmd+Tab away
     /// swallows the key-up, so without this the chips stay on screen for good.
     activation_sub: Option<Subscription>,
-    /// 1s heartbeat re-rendering the working indicator (elapsed + flavour word).
-    _ticker: Task<()>,
+    /// Redraw scheduled for the next clock-driven change (see [`shell_clock_wake`]).
+    clock: ClockRedraw,
     _state_observation: Subscription,
     _composer_events: Subscription,
     /// The primary transcript's spawn-chip events (subagent tabs).
@@ -2250,43 +2307,10 @@ impl Shell {
         });
         // Spawn chips open their subagent's transcript as a right-pane tab.
         let transcript_events = cx.subscribe(&transcript, Self::on_transcript_event);
-        // Working-indicator heartbeat: notify once a second while a session is
-        // live so elapsed time and the flavour word stay fresh.
-        let ticker = cx.spawn(async move |this, cx| {
-            let mut displayed_minute = Utc::now().timestamp().div_euclid(60);
-            loop {
-                cx.background_executor().timer(Duration::from_secs(1)).await;
-                let minute = Utc::now().timestamp().div_euclid(60);
-                let minute_changed = minute != displayed_minute;
-                displayed_minute = minute;
-                let alive = this.update(cx, |shell: &mut Shell, cx| {
-                    let live = {
-                        let s = shell.state.read(cx);
-                        s.selected_chat
-                            .as_deref()
-                            .is_some_and(|id| s.indicator_for(id, Utc::now()) != Indicator::None)
-                            // The connection pill's retry countdown needs the
-                            // same per-second refresh while degraded.
-                            || matches!(
-                                s.connectivity.state,
-                                zeron_proto::ConnectivityState::Offline
-                                    | zeron_proto::ConnectivityState::Reconnecting
-                            )
-                    };
-                    // Relative sidebar times still advance when unchanged
-                    // presence heartbeats no longer invalidate the whole UI.
-                    if live || minute_changed {
-                        cx.notify();
-                    }
-                });
-                if alive.is_err() {
-                    break;
-                }
-            }
-        });
         let data_dir = boot.data_dir.clone();
         let mut settings = settings::current(cx);
         state.update(cx, |state, cx| {
+            state.watch_clock_transitions(cx);
             state.set_change_requests_visible(settings.sidebar_show_pull_request, cx)
         });
         crate::appshots::set_enabled(settings.appshots_enabled);
@@ -2542,7 +2566,7 @@ impl Shell {
             navigation_focus: navigation_focus::NavigationFocus::new(cx),
             unfocused: cx.focus_handle(),
             activation_sub: None,
-            _ticker: ticker,
+            clock: ClockRedraw::default(),
             _state_observation: observation,
             _composer_events: composer_events,
             _transcript_events: transcript_events,
@@ -12560,6 +12584,13 @@ fn header_icon_button_with(
 
 impl Render for Shell {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        // Every repaint (state frame, input, or the clock firing) reschedules
+        // the next clock-driven one; the sidebar and transcript follow this
+        // view's notifications.
+        let now = Utc::now();
+        let wake = shell_clock_wake(self.state.read(cx), now);
+        self.clock
+            .arm(wake, now, |shell: &mut Shell| &mut shell.clock, cx);
         let active_files_key = self.panel_key(cx);
         let hidden_explorers = self
             .files
@@ -13649,6 +13680,137 @@ mod tests {
         );
     }
 
+    /// A minute boundary.
+    fn clock_epoch() -> DateTime<Utc> {
+        DateTime::parse_from_rfc3339("2026-07-19T12:00:00Z")
+            .unwrap()
+            .to_utc()
+    }
+
+    fn clock_session(
+        chat_id: &str,
+        status: zeron_proto::SessionStatus,
+        updated_at: DateTime<Utc>,
+    ) -> zeron_proto::Session {
+        zeron_proto::Session {
+            last_completed_turn: None,
+            chat_id: chat_id.into(),
+            device_id: "remote".into(),
+            status,
+            started_at: Some(updated_at),
+            updated_at,
+        }
+    }
+
+    struct ClockProbe {
+        clock: ClockRedraw,
+    }
+
+    fn clock_probe(
+        cx: &mut gpui::TestAppContext,
+    ) -> (
+        gpui::Entity<ClockProbe>,
+        std::rc::Rc<std::cell::Cell<usize>>,
+        gpui::Subscription,
+    ) {
+        use gpui::AppContext as _;
+        let probe = cx.new(|_| ClockProbe {
+            clock: ClockRedraw::default(),
+        });
+        let redraws = std::rc::Rc::new(std::cell::Cell::new(0));
+        let counter = redraws.clone();
+        let subscription =
+            cx.update(|cx| cx.observe(&probe, move |_, _| counter.set(counter.get() + 1)));
+        (probe, redraws, subscription)
+    }
+
+    fn arm_probe(
+        cx: &mut gpui::TestAppContext,
+        probe: &gpui::Entity<ClockProbe>,
+        wake: DateTime<Utc>,
+        now: DateTime<Utc>,
+    ) {
+        probe.update(cx, |probe, cx| {
+            probe
+                .clock
+                .arm(wake, now, |probe: &mut ClockProbe| &mut probe.clock, cx)
+        });
+    }
+
+    /// Schedules the shell clock for `state` at `now` and proves the redraw
+    /// lands exactly at `expected` on the simulated clock — not a millisecond
+    /// earlier, and without any intermediate polling.
+    fn assert_redraw_at(
+        cx: &mut gpui::TestAppContext,
+        state: &AppState,
+        now: DateTime<Utc>,
+        expected: DateTime<Utc>,
+    ) {
+        let wake = shell_clock_wake(state, now);
+        assert_eq!(wake, expected);
+        let (probe, redraws, _subscription) = clock_probe(cx);
+        arm_probe(cx, &probe, wake, now);
+        let delay = (expected - now).to_std().unwrap();
+        cx.executor()
+            .advance_clock(delay - Duration::from_millis(1));
+        assert_eq!(redraws.get(), 0, "no redraw before the deadline");
+        cx.executor().advance_clock(Duration::from_millis(1));
+        assert_eq!(redraws.get(), 1, "one redraw at the deadline");
+    }
+
+    #[gpui::test]
+    fn idle_shell_sleeps_until_the_minute(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch() + chrono::TimeDelta::seconds(20);
+        let mut state = AppState::new();
+        // A failed run, a pending question and a reconnecting pill show no
+        // clock: only the relative-time minute remains.
+        state.sessions = vec![
+            clock_session("failed", zeron_proto::SessionStatus::Errored, now),
+            clock_session("idle", zeron_proto::SessionStatus::Idle, now),
+        ];
+        state.selected_chat = Some("failed".into());
+        state.connectivity.state = zeron_proto::ConnectivityState::Reconnecting;
+        assert_redraw_at(
+            cx,
+            &state,
+            now,
+            clock_epoch() + chrono::TimeDelta::minutes(1),
+        );
+    }
+
+    #[gpui::test]
+    fn selected_working_chat_redraws_every_second(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let mut state = AppState::new();
+        state.sessions = vec![clock_session(
+            "chat",
+            zeron_proto::SessionStatus::Working,
+            now,
+        )];
+        state.selected_chat = Some("chat".into());
+        assert_redraw_at(cx, &state, now, now + chrono::TimeDelta::seconds(1));
+        // Awaiting input shows no elapsed timer; its staleness cutoff is an
+        // AppState notification, not a shell tick.
+        state.sessions[0].status = zeron_proto::SessionStatus::AwaitingInput;
+        assert_redraw_at(cx, &state, now, now + chrono::TimeDelta::minutes(1));
+    }
+
+    #[gpui::test]
+    fn clock_redraw_keeps_the_earliest_deadline(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let (probe, redraws, _subscription) = clock_probe(cx);
+        arm_probe(cx, &probe, now + chrono::TimeDelta::seconds(10), now);
+        // An earlier deadline replaces the pending wake; a later one does not.
+        arm_probe(cx, &probe, now + chrono::TimeDelta::seconds(5), now);
+        arm_probe(cx, &probe, now + chrono::TimeDelta::seconds(30), now);
+        cx.executor().advance_clock(Duration::from_secs(5));
+        assert_eq!(redraws.get(), 1);
+        // Fired timers are one-shot: nothing else is pending.
+        cx.executor().advance_clock(Duration::from_secs(60));
+        assert_eq!(redraws.get(), 1);
+        assert!(probe.read_with(cx, |probe, _| probe.clock.task.is_none()));
+    }
+
     #[test]
     fn escape_ignores_non_live_or_ineligible_views() {
         assert_eq!(
diff --git a/crates/ui/src/state.rs b/crates/ui/src/state.rs
index c2e141fa96..916a6d2357 100644
--- a/crates/ui/src/state.rs
+++ b/crates/ui/src/state.rs
@@ -660,6 +660,56 @@ struct PendingSend {
 /// incident fell into.
 pub const UNDELIVERED_GRACE_MS: i64 = 120_000;
 
+/// The one-shot timer behind [`AppState::watch_clock_transitions`].
+#[derive(Default)]
+struct ClockTransitions {
+    /// Re-arms the timer after every notify.
+    observation: Option<gpui::Subscription>,
+    /// The last time observers saw current state (a notify or a wake).
+    checked_at: Option<DateTime<Utc>>,
+    wake_at: Option<DateTime<Utc>>,
+    task: Option<Task<()>>,
+}
+
+#[cfg(test)]
+thread_local! {
+    static TEST_CLOCK: std::cell::Cell<Option<DateTime<Utc>>> = const { std::cell::Cell::new(None) };
+}
+
+/// Wall-clock time for clock-driven state derivations. Tests pin it to the
+/// simulated executor's timeline with [`TestClock`].
+pub(crate) fn clock_now() -> DateTime<Utc> {
+    #[cfg(test)]
+    if let Some(now) = TEST_CLOCK.with(std::cell::Cell::get) {
+        return now;
+    }
+    Utc::now()
+}
+
+/// Pins [`clock_now`] on this test thread until dropped.
+#[cfg(test)]
+pub(crate) struct TestClock;
+
+#[cfg(test)]
+impl TestClock {
+    pub(crate) fn start(now: DateTime<Utc>) -> Self {
+        let clock = Self;
+        clock.set(now);
+        clock
+    }
+
+    pub(crate) fn set(&self, now: DateTime<Utc>) {
+        TEST_CLOCK.with(|clock| clock.set(Some(now)));
+    }
+}
+
+#[cfg(test)]
+impl Drop for TestClock {
+    fn drop(&mut self) {
+        TEST_CLOCK.with(|clock| clock.set(None));
+    }
+}
+
 /// A send's attachment-upload leg in flight. `done` is bumped by the upload
 /// task per completed chunk (binary bytes); the working label reads it every
 /// paint (the spinner already animates each frame), so no notify plumbing is
@@ -798,6 +848,8 @@ pub struct AppState {
     /// Data directory (`ui-settings.json`, `composer-defaults.json`); set at
     /// bootstrap so child views can persist small preference files.
     pub data_dir: Option<PathBuf>,
+    /// Notifies at clock-driven transitions (see [`Self::watch_clock_transitions`]).
+    clock: ClockTransitions,
     engine: Option<EngineHandle>,
     watch_tasks: Vec<Task<()>>,
     transcript_task: Option<Task<()>>,
@@ -830,6 +882,31 @@ fn is_text_append(frame: &TranscriptFrame) -> bool {
         if upsert.is_empty() && remove.is_empty() && !append.is_empty())
 }
 
+/// Each session's indicator at `now` (the lease-dependent part of a frame).
+fn session_presence_at(sessions: &[Session], now: DateTime<Utc>) -> Vec<Indicator> {
+    sessions
+        .iter()
+        .map(|session| effective_indicator(Some(session), now))
+        .collect()
+}
+
+/// Device rows as rendered at `now`: the heartbeat timestamp only through its
+/// online state and last-seen label.
+fn device_presentation_at(devices: &[Device], now: DateTime<Utc>) -> Vec<(Device, bool, String)> {
+    devices
+        .iter()
+        .map(|device| {
+            let mut metadata = device.clone();
+            metadata.last_seen_at = None;
+            (
+                metadata,
+                crate::settings::devices::device_online(device.last_seen_at, now),
+                crate::settings::devices::format_last_seen(device.last_seen_at, now),
+            )
+        })
+        .collect()
+}
+
 impl Default for AppState {
     fn default() -> Self {
         Self::new()
@@ -877,6 +954,7 @@ impl AppState {
             local_device_id: None,
             harness_updates: Vec::new(),
             data_dir: None,
+            clock: ClockTransitions::default(),
             engine: None,
             watch_tasks: Vec::new(),
             transcript_task: None,
@@ -1064,23 +1142,32 @@ impl AppState {
         true
     }
 
-    pub fn apply_chats(&mut self, mut chats: Vec<Chat>) {
+    /// Returns whether anything observable changed. The engine re-publishes
+    /// identical lists (presence and sync churn elsewhere in the doc), and
+    /// each notify re-renders the whole shell.
+    pub fn apply_chats(&mut self, mut chats: Vec<Chat>) -> bool {
+        let mut changed = false;
         if let Some(pending) = &self.pending_side_chat {
             if chats.iter().any(|chat| chat.id == pending.id) {
                 self.pending_side_chat = None;
+                changed = true;
             } else {
                 chats.push(pending.clone());
             }
         }
         sort_chats(&mut chats);
-        self.chats = chats;
-        self.link_roots_revision = self.link_roots_revision.wrapping_add(1);
-        self.chats_synced = true;
-        self.transcript_cache
-            .retain(|cached| self.chats.iter().any(|c| c.id == cached.chat_id));
+        if !self.chats_synced || self.chats != chats {
+            changed = true;
+            self.chats = chats;
+            self.link_roots_revision = self.link_roots_revision.wrapping_add(1);
+            self.chats_synced = true;
+            self.transcript_cache
+                .retain(|cached| self.chats.iter().any(|c| c.id == cached.chat_id));
+        }
         if let Some(selected) = &self.selected_chat
             && !self.chats.iter().any(|c| &c.id == selected)
         {
+            changed = true;
             // Selected chat vanished (deleted elsewhere): drop selection + transcript.
             self.transcript_baselines.remove(selected);
             self.prepared_transcripts.remove(selected);
@@ -1094,6 +1181,7 @@ impl AppState {
             self.queue.clear();
             self.queue_task = None;
         }
+        changed
     }
 
     pub fn apply_sessions(&mut self, sessions: Vec<Session>) -> bool {
@@ -1101,10 +1189,7 @@ impl AppState {
     }
 
     fn apply_sessions_at(&mut self, sessions: Vec<Session>, now: DateTime<Utc>) -> bool {
-        let presence: Vec<_> = sessions
-            .iter()
-            .map(|session| effective_indicator(Some(session), now))
-            .collect();
+        let presence = session_presence_at(&sessions, now);
         let presentation: Vec<_> = sessions
             .iter()
             .map(|session| {
@@ -1123,11 +1208,22 @@ impl AppState {
         changed
     }
 
-    pub fn apply_spaces(&mut self, mut spaces: Vec<Space>) {
+    /// Returns whether the list or the healed selection changed.
+    pub fn apply_spaces(&mut self, mut spaces: Vec<Space>) -> bool {
         sort_spaces(&mut spaces);
-        self.spaces = spaces;
-        self.link_roots_revision = self.link_roots_revision.wrapping_add(1);
-        self.spaces_synced = true;
+        let previous_selection = self.selected_space.clone();
+        let mut changed = false;
+        if !self.spaces_synced || self.spaces != spaces {
+            changed = true;
+            self.spaces = spaces;
+            self.link_roots_revision = self.link_roots_revision.wrapping_add(1);
+            self.spaces_synced = true;
+        }
+        self.heal_space_selection();
+        changed || self.selected_space != previous_selection
+    }
+
+    fn heal_space_selection(&mut self) {
         if self.no_project {
             self.selected_space = None;
             return;
@@ -1246,9 +1342,13 @@ impl AppState {
         }
     }
 
-    pub fn apply_connectivity(&mut self, connectivity: zeron_proto::Connectivity) {
+    /// Returns whether the posture changed. The first frame after attach always
+    /// counts: it ends the bootstrap gap the shell's alert baseline waits on.
+    pub fn apply_connectivity(&mut self, connectivity: zeron_proto::Connectivity) -> bool {
+        let changed = !self.connectivity_observed || self.connectivity != connectivity;
         self.connectivity = connectivity;
         self.connectivity_observed = true;
+        changed
     }
 
     /// Is this chat's delivery path degraded — will a send QUEUE rather than
@@ -1317,23 +1417,8 @@ impl AppState {
             self.change_requests
                 .clear_unsupported_on_version_change(&device.id, device.version.as_deref());
         }
-        let presentation: Vec<_> = devices
-            .iter()
-            .map(|device| {
-                let mut metadata = device.clone();
-                metadata.last_seen_at = None;
-                (
-                    metadata,
-                    crate::settings::devices::device_online(device.last_seen_at, now),
-                    crate::settings::devices::format_last_seen(device.last_seen_at, now),
-                )
-            })
-            .collect();
-        let session_presence: Vec<_> = self
-            .sessions
-            .iter()
-            .map(|session| effective_indicator(Some(session), now))
-            .collect();
+        let presentation = device_presentation_at(&devices, now);
+        let session_presence = session_presence_at(&self.sessions, now);
         let changed = self.device_presentation.as_ref() != Some(&presentation)
             || self.session_presence_presentation != session_presence;
         self.device_presentation = Some(presentation);
@@ -1394,19 +1479,33 @@ impl AppState {
             .map(|s| s.id.clone())
     }
 
-    pub fn apply_harness_updates(&mut self, statuses: Vec<zeron_proto::HarnessUpdateStatus>) {
+    pub fn apply_harness_updates(
+        &mut self,
+        statuses: Vec<zeron_proto::HarnessUpdateStatus>,
+    ) -> bool {
+        if self.harness_updates == statuses {
+            return false;
+        }
         self.harness_updates = statuses;
+        true
     }
 
-    pub fn apply_auth(&mut self, auth: AuthState) {
+    pub fn apply_auth(&mut self, auth: AuthState) -> bool {
+        if self.auth.as_ref() == Some(&auth) {
+            return false;
+        }
         self.auth = Some(auth);
+        true
     }
 
     /// Tolerant AuthStatus frame reducer (see [`parse_auth_state`]).
-    pub fn apply_auth_value(&mut self, value: serde_json::Value) {
+    pub fn apply_auth_value(&mut self, value: serde_json::Value) -> bool {
         match parse_auth_state(&value) {
             Some(auth) => self.apply_auth(auth),
-            None => tracing::warn!("dropping unrecognized AuthStatus frame"),
+            None => {
+                tracing::warn!("dropping unrecognized AuthStatus frame");
+                false
+            }
         }
     }
 
@@ -1681,11 +1780,16 @@ impl AppState {
 
     /// A `WatchTransfers` snapshot: the engine-side relay leg's in-flight
     /// queued-attachment transfers, replacing the whole set each frame.
-    pub fn apply_transfers(&mut self, transfers: Vec<zeron_proto::TransferProgress>) {
-        self.transfers = transfers
+    pub fn apply_transfers(&mut self, transfers: Vec<zeron_proto::TransferProgress>) -> bool {
+        let transfers: HashMap<_, _> = transfers
             .into_iter()
             .map(|t| (t.upload_id, (t.done, t.total)))
             .collect();
+        if self.transfers == transfers {
+            return false;
+        }
+        self.transfers = transfers;
+        true
     }
 
     /// Percent of one queued attachment's relay transfer, by the uploadId
@@ -2121,6 +2225,113 @@ impl AppState {
         effective_indicator(self.session_for(chat_id), now)
     }
 
+    /// The earliest moment after `now` at which a clock-derived value flips
+    /// with no frame to announce it: a Working/AwaitingInput session going
+    /// stale ([`SESSION_STALE_MS`]), a remote device leaving its online window
+    /// (offline glyphs, degraded delivery, Queued badges), or a pending send's
+    /// grace expiring into "Not delivered". Each deadline is the first instant
+    /// the predicate reads differently. Relative-time labels are excluded:
+    /// they advance on the views' minute heartbeat. Pure.
+    pub fn next_clock_transition(&self, now: DateTime<Utc>) -> Option<DateTime<Utc>> {
+        self.clock_deadlines()
+            .filter(|deadline| *deadline > now)
+            .min()
+    }
+
+    /// Whether any clock-driven transition fell in `(from, to]`. Heartbeats
+    /// that move a deadline later without notifying (session and device
+    /// liveness leases) leave an armed timer early; this tells a real
+    /// transition from such an obsolete wake. Pure.
+    fn clock_transition_between(&self, from: DateTime<Utc>, to: DateTime<Utc>) -> bool {
+        self.clock_deadlines()
+            .any(|deadline| from < deadline && deadline <= to)
+    }
+
+    fn clock_deadlines(&self) -> impl Iterator<Item = DateTime<Utc>> + '_ {
+        let stale = self
+            .sessions
+            .iter()
+            .filter(|session| {
+                matches!(
+                    session.status,
+                    zeron_proto::SessionStatus::Working | zeron_proto::SessionStatus::AwaitingInput
+                )
+            })
+            // `age_ms > SESSION_STALE_MS` first holds one millisecond past it.
+            .map(|session| {
+                session.updated_at + chrono::TimeDelta::milliseconds(SESSION_STALE_MS + 1)
+            });
+        let offline = self
+            .devices
+            .iter()
+            .filter(|device| self.local_device_id.as_deref() != Some(device.id.as_str()))
+            .filter_map(|device| device.last_seen_at)
+            // Whole seconds `<= DEVICE_ONLINE_WINDOW_SECS` stay online.
+            .map(|at| {
+                at + chrono::TimeDelta::seconds(
+                    crate::settings::devices::DEVICE_ONLINE_WINDOW_SECS + 1,
+                )
+            });
+        let grace = self.pending_sends.values().map(|pending| {
+            pending.started + chrono::TimeDelta::milliseconds(UNDELIVERED_GRACE_MS + 1)
+        });
+        stale.chain(offline).chain(grace)
+    }
+
+    /// Notify this entity at every clock-driven transition, so each state
+    /// observer (composer interrupts, session sounds, views) sees a session
+    /// go stale, a device go dark or a send's grace expire on time — no state
+    /// frame announces those. Idempotent; every notify re-arms a single
+    /// one-shot timer for the next deadline, so idle state never polls.
+    pub fn watch_clock_transitions(&mut self, cx: &mut Context<Self>) {
+        if self.clock.observation.is_none() {
+            self.clock.observation =
+                Some(cx.observe_self(|state, cx| state.arm_clock_transition(cx)));
+        }
+        self.arm_clock_transition(cx);
+    }
+
+    /// Re-evaluate the clock-dependent parts of the change-detection caches.
+    fn refresh_clock_presentations(&mut self, now: DateTime<Utc>) {
+        self.session_presence_presentation = session_presence_at(&self.sessions, now);
+        if self.device_presentation.is_some() {
+            self.device_presentation = Some(device_presentation_at(&self.devices, now));
+        }
+    }
+
+    fn arm_clock_transition(&mut self, cx: &mut Context<Self>) {
+        let now = clock_now();
+        self.clock.checked_at = Some(now);
+        let wake = self.next_clock_transition(now);
+        if wake == self.clock.wake_at && self.clock.task.is_some() {
+            return;
+        }
+        self.clock.wake_at = wake;
+        self.clock.task = wake.map(|wake| {
+            let delay = (wake - now).to_std().unwrap_or_default();
+            cx.spawn(async move |this, cx| {
+                cx.background_executor().timer(delay).await;
+                this.update(cx, |state, cx| {
+                    state.clock.wake_at = None;
+                    state.clock.task = None;
+                    let now = clock_now();
+                    let from = state.clock.checked_at.unwrap_or(now);
+                    if state.clock_transition_between(from, now) {
+                        // Record what this transition changed, so the frame
+                        // that later reverts it (a heartbeat reviving the
+                        // session or device) compares unequal and notifies.
+                        state.refresh_clock_presentations(now);
+                        // The self-observer re-arms for the next deadline.
+                        cx.notify();
+                    } else {
+                        state.arm_clock_transition(cx);
+                    }
+                })
+                .ok();
+            })
+        });
+    }
+
     pub fn selected_chat_row(&self) -> Option<&Chat> {
         let id = self.selected_chat.as_deref()?;
         self.chats.iter().find(|c| c.id == id)
@@ -2227,6 +2438,7 @@ impl AppState {
             state.attach_engine(engine, cx);
         }
         state.select_chat(Some(chat.id), cx);
+        state.watch_clock_transitions(cx);
         state
     }
 
@@ -2378,29 +2590,27 @@ impl AppState {
                 cx,
                 handle.clone(),
                 methods::WATCH_CONNECTIVITY,
-                |state, value| {
-                    state.apply_connectivity(value);
-                    true
-                },
+                AppState::apply_connectivity,
             ),
             spawn_watch(
                 cx,
                 handle.clone(),
                 methods::WATCH_TRANSFERS,
-                |state, value| {
-                    state.apply_transfers(value);
-                    true
-                },
+                AppState::apply_transfers,
+            ),
+            spawn_watch(
+                cx,
+                handle.clone(),
+                methods::WATCH_SPACES,
+                AppState::apply_spaces,
             ),
-            spawn_watch(cx, handle.clone(), methods::WATCH_SPACES, |state, value| {
-                state.apply_spaces(value);
-                true
-            }),
             // Auth frames parse tolerantly — engine and proto tags differ today.
-            spawn_watch(cx, handle.clone(), methods::AUTH_STATUS, |state, value| {
-                state.apply_auth_value(value);
-                true
-            }),
+            spawn_watch(
+                cx,
+                handle.clone(),
+                methods::AUTH_STATUS,
+                AppState::apply_auth_value,
+            ),
             spawn_local_device_probe(cx, handle.clone()),
         ]);
         if supports_harness_updates {
@@ -2408,10 +2618,7 @@ impl AppState {
                 cx,
                 handle.clone(),
                 methods::WATCH_HARNESS_UPDATES,
-                |state, value| {
-                    state.apply_harness_updates(value);
-                    true
-                },
+                AppState::apply_harness_updates,
             ));
         }
         self.watch_tasks = watch_tasks;
@@ -2483,29 +2690,34 @@ impl AppState {
         cx.notify();
     }
 
-    fn apply_pending_deep_link(&mut self, cx: &mut Context<Self>) {
+    /// Returns whether a pending link was resolved (selected or rejected).
+    fn apply_pending_deep_link(&mut self, cx: &mut Context<Self>) -> bool {
         let Some(link) = self.pending_deep_link.clone() else {
-            return;
+            return false;
         };
         let Some(locator) = crate::links::workspace_locator(
             self.workspace_scope,
             self.auth.as_ref(),
             self.local_device_id.as_deref(),
         ) else {
-            return;
+            return false;
         };
         if locator != link.workspace {
             self.pending_deep_link = None;
             self.deep_link_notice =
                 Some("This conversation link belongs to another workspace".into());
-            return;
+            return true;
         }
         if self.chats.iter().any(|chat| chat.id == link.chat_id) {
             self.pending_deep_link = None;
             self.select_chat(Some(link.chat_id), cx);
+            true
         } else if self.chats_synced {
             self.pending_deep_link = None;
             self.deep_link_notice = Some("The linked conversation was not found".into());
+            true
+        } else {
+            false
         }
     }
 
@@ -2827,10 +3039,16 @@ fn spawn_chats_watch(cx: &mut Context<AppState>, handle: EngineHandle) -> Task<(
                     }
                 };
                 let alive = this.update(cx, |state, cx| {
-                    state.apply_chats(parsed);
-                    state.apply_pending_deep_link(cx);
-                    state.reconcile_change_request_watches(cx);
-                    cx.notify();
+                    // Identical re-published lists skip the re-sort fan-out:
+                    // watch reconciliation and a whole-shell re-render.
+                    let changed = state.apply_chats(parsed);
+                    let linked = state.apply_pending_deep_link(cx);
+                    if changed {
+                        state.reconcile_change_request_watches(cx);
+                    }
+                    if changed || linked {
+                        cx.notify();
+                    }
                 });
                 if alive.is_err() {
                     return;
@@ -2913,8 +3131,9 @@ fn spawn_change_request_watch(
                 };
                 if this
                     .update(cx, |state, cx| {
-                        state.change_requests.store(target.clone(), snapshot);
-                        cx.notify();
+                        if state.change_requests.store(target.clone(), snapshot) {
+                            cx.notify();
+                        }
                     })
                     .is_err()
                 {
@@ -2975,11 +3194,11 @@ fn spawn_watch<T: DeserializeOwned + 'static>(
                 };
                 let alive = this.update(cx, |state, cx| {
                     let changed = apply(state, parsed);
-                    state.apply_pending_deep_link(cx);
-                    if changed {
-                        if matches!(method, methods::WATCH_SPACES | methods::WATCH_DEVICES) {
-                            state.reconcile_change_request_watches(cx);
-                        }
+                    let linked = state.apply_pending_deep_link(cx);
+                    if changed && matches!(method, methods::WATCH_SPACES | methods::WATCH_DEVICES) {
+                        state.reconcile_change_request_watches(cx);
+                    }
+                    if changed || linked {
                         cx.notify();
                     }
                 });
@@ -4815,6 +5034,301 @@ mod tests {
         assert_eq!(state.selected_chat.as_deref(), Some("b"));
     }
 
+    fn clock_epoch() -> DateTime<Utc> {
+        DateTime::parse_from_rfc3339("2026-07-19T12:00:00Z")
+            .unwrap()
+            .to_utc()
+    }
+
+    /// Builds a clock-watching state at the pinned `now` and counts its
+    /// notifications.
+    fn clock_state(
+        cx: &mut gpui::TestAppContext,
+        setup: impl FnOnce(&mut AppState),
+    ) -> (
+        Entity<AppState>,
+        std::rc::Rc<std::cell::Cell<usize>>,
+        gpui::Subscription,
+    ) {
+        let state = cx.new(|cx| {
+            let mut state = AppState::new();
+            setup(&mut state);
+            state.watch_clock_transitions(cx);
+            state
+        });
+        let notifies = std::rc::Rc::new(std::cell::Cell::new(0));
+        let counter = notifies.clone();
+        let subscription =
+            cx.update(|cx| cx.observe(&state, move |_, _| counter.set(counter.get() + 1)));
+        (state, notifies, subscription)
+    }
+
+    /// Steps the simulated executor and the pinned wall clock together.
+    fn advance_to(
+        cx: &mut gpui::TestAppContext,
+        clock: &TestClock,
+        from: DateTime<Utc>,
+        to: DateTime<Utc>,
+    ) {
+        clock.set(to);
+        cx.executor().advance_clock((to - from).to_std().unwrap());
+    }
+
+    /// Proves the state notifies exactly once, exactly at `deadline`.
+    fn assert_state_notifies_at(
+        cx: &mut gpui::TestAppContext,
+        now: DateTime<Utc>,
+        deadline: DateTime<Utc>,
+        setup: impl FnOnce(&mut AppState),
+    ) {
+        let clock = TestClock::start(now);
+        let (_state, notifies, _subscription) = clock_state(cx, setup);
+        let before = deadline - TimeDelta::milliseconds(1);
+        advance_to(cx, &clock, now, before);
+        assert_eq!(notifies.get(), 0, "no notify before the deadline");
+        advance_to(cx, &clock, before, deadline);
+        assert_eq!(notifies.get(), 1, "one notify at the deadline");
+        // Nothing else is due: the next minute passes silently.
+        advance_to(cx, &clock, deadline, deadline + TimeDelta::minutes(1));
+        assert_eq!(notifies.get(), 1);
+    }
+
+    #[gpui::test]
+    fn stale_session_notifies_state_at_its_cutoff(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let row = session("row", SessionStatus::Working, 10, now);
+        let cutoff = row.updated_at + TimeDelta::milliseconds(SESSION_STALE_MS + 1);
+        let mut probe = AppState::new();
+        probe.sessions = vec![row.clone()];
+        assert_eq!(
+            probe.indicator_for("row", cutoff - TimeDelta::milliseconds(1)),
+            Indicator::Working
+        );
+        assert_eq!(probe.indicator_for("row", cutoff), Indicator::None);
+        assert_state_notifies_at(cx, now, cutoff, |state| state.sessions = vec![row]);
+    }
+
+    #[gpui::test]
+    fn remote_device_notifies_state_when_it_goes_offline(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let seen = now - TimeDelta::seconds(40);
+        let mut remote = device("remote", "Remote");
+        remote.last_seen_at = Some(seen);
+        // The local device is always online; its stale heartbeat is no deadline.
+        let mut local = device("local", "Local");
+        local.last_seen_at = Some(now - TimeDelta::seconds(65));
+        let offline =
+            seen + TimeDelta::seconds(crate::settings::devices::DEVICE_ONLINE_WINDOW_SECS + 1);
+        let mut probe = AppState::new();
+        probe.devices = vec![remote.clone()];
+        assert!(probe.device_online("remote", offline - TimeDelta::milliseconds(1)));
+        assert!(!probe.device_online("remote", offline));
+        assert_state_notifies_at(cx, now, offline, |state| {
+            state.local_device_id = Some("local".into());
+            state.devices = vec![local, remote];
+        });
+    }
+
+    #[gpui::test]
+    fn pending_send_notifies_state_when_its_grace_expires(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let started = now - TimeDelta::seconds(100);
+        let expiry = started + TimeDelta::milliseconds(UNDELIVERED_GRACE_MS + 1);
+        let mut probe = AppState::new();
+        probe.begin_pending_send("chat", "message", started);
+        assert!(!probe.send_undelivered("chat", expiry - TimeDelta::milliseconds(1)));
+        assert!(probe.send_undelivered("chat", expiry));
+        assert_state_notifies_at(cx, now, expiry, |state| {
+            state.begin_pending_send("chat", "message", started)
+        });
+    }
+
+    #[gpui::test]
+    fn settled_state_arms_no_clock(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let clock = TestClock::start(now);
+        let (state, notifies, _subscription) = clock_state(cx, |state| {
+            state.sessions = vec![
+                session("failed", SessionStatus::Errored, 0, now),
+                session("idle", SessionStatus::Idle, 0, now),
+            ];
+        });
+        assert!(state.read_with(cx, |state, _| state.clock.task.is_none()));
+        advance_to(cx, &clock, now, now + TimeDelta::hours(1));
+        assert_eq!(notifies.get(), 0);
+    }
+
+    #[gpui::test]
+    fn silent_heartbeat_defers_the_stale_notify(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let clock = TestClock::start(now);
+        let row = session("row", SessionStatus::Working, 10, now);
+        let first_cutoff = row.updated_at + TimeDelta::milliseconds(SESSION_STALE_MS + 1);
+        let (state, notifies, _subscription) = clock_state(cx, |state| {
+            state.apply_sessions_at(vec![row], now);
+        });
+        // A heartbeat only refreshes the lease: the reducer stores it without
+        // notifying, so the armed timer is now early.
+        let heartbeat = now + TimeDelta::seconds(20);
+        advance_to(cx, &clock, now, heartbeat);
+        state.update(cx, |state, _| {
+            let changed = state.apply_sessions_at(
+                vec![session("row", SessionStatus::Working, 0, heartbeat)],
+                heartbeat,
+            );
+            assert!(!changed);
+        });
+        advance_to(cx, &clock, heartbeat, first_cutoff);
+        assert_eq!(notifies.get(), 0, "an obsolete deadline re-arms silently");
+        let cutoff = heartbeat + TimeDelta::milliseconds(SESSION_STALE_MS + 1);
+        advance_to(
+            cx,
+            &clock,
+            first_cutoff,
+            cutoff - TimeDelta::milliseconds(1),
+        );
+        assert_eq!(notifies.get(), 0);
+        advance_to(cx, &clock, cutoff - TimeDelta::milliseconds(1), cutoff);
+        assert_eq!(notifies.get(), 1);
+    }
+
+    #[gpui::test]
+    fn revival_after_a_clock_transition_notifies_and_rearms(cx: &mut gpui::TestAppContext) {
+        let now = clock_epoch();
+        let clock = TestClock::start(now);
+        let row = session("row", SessionStatus::Working, 0, now);
+        let stale_at = now + TimeDelta::milliseconds(SESSION_STALE_MS + 1);
+        let (state, notifies, _subscription) = clock_state(cx, |state| {
+            state.apply_sessions_at(vec![row], now);
+        });
+        advance_to(cx, &clock, now, stale_at);
+        assert_eq!(notifies.get(), 1, "went stale by clock alone");
+        // A heartbeat revives it: that is a visible change again, and the
+        // revived lease arms its own cutoff.
+        let revived = stale_at + TimeDelta::seconds(1);
+        advance_to(cx, &clock, stale_at, revived);
+        state.update(cx, |state, cx| {
+            let changed = state.apply_sessions_at(
+                vec![session("row", SessionStatus::Working, 0, revived)],
+                revived,
+            );
+            assert!(changed, "revival is a change");
+            cx.notify();
+        });
+        assert_eq!(notifies.get(), 2);
+        let next_cutoff = revived + TimeDelta::milliseconds(SESSION_STALE_MS + 1);
+        advance_to(cx, &clock, revived, next_cutoff);
+        assert_eq!(notifies.get(), 3, "the revived lease's cutoff fires");
+    }
+
+    #[test]
+    fn identical_chats_frames_report_no_change() {
+        let mut state = AppState::new();
+        // The first frame flips `chats_synced` even when empty.
+        assert!(state.apply_chats(vec![]));
+        assert!(!state.apply_chats(vec![]));
+        assert!(state.apply_chats(vec![chat("b", 1, None), chat("a", 0, None)]));
+        let revision = state.link_roots_revision;
+        // Same rows in a different wire order sort to the same list.
+        assert!(!state.apply_chats(vec![chat("a", 0, None), chat("b", 1, None)]));
+        assert_eq!(state.link_roots_revision, revision);
+        let mut renamed = chat("a", 0, None);
+        renamed.title = Some("Renamed".into());
+        assert!(state.apply_chats(vec![renamed.clone(), chat("b", 1, None)]));
+        assert_ne!(state.link_roots_revision, revision);
+        // A selection pointing at no row still heals on an unchanged frame.
+        state.selected_chat = Some("gone".into());
+        assert!(state.apply_chats(vec![renamed, chat("b", 1, None)]));
+        assert_eq!(state.selected_chat, None);
+    }
+
+    #[test]
+    fn identical_spaces_frames_report_no_change() {
+        let mut state = AppState::new();
+        assert!(state.apply_spaces(vec![]));
+        assert!(!state.apply_spaces(vec![]));
+        let frame = vec![space("s2", "dev", "/b", 2), space("s1", "dev", "/a", 1)];
+        assert!(state.apply_spaces(frame.clone()));
+        assert_eq!(state.selected_space.as_deref(), Some("s1"));
+        assert!(!state.apply_spaces(frame.clone()));
+        // A vanished selection still heals (and reports it) on an unchanged list.
+        state.selected_space = Some("gone".into());
+        assert!(state.apply_spaces(frame));
+        assert_eq!(state.selected_space.as_deref(), Some("s1"));
+    }
+
+    #[test]
+    fn identical_connectivity_frames_report_no_change() {
+        use zeron_proto::{Connectivity, ConnectivityState};
+        let mut state = AppState::new();
+        // The first frame ends the bootstrap gap even when it equals the default.
+        assert!(state.apply_connectivity(Connectivity::default()));
+        assert!(state.connectivity_observed);
+        assert!(!state.apply_connectivity(Connectivity::default()));
+        let reconnecting = Connectivity {
+            state: ConnectivityState::Reconnecting,
+            retry_at_ms: 5_000,
+            ..Default::default()
+        };
+        assert!(state.apply_connectivity(reconnecting.clone()));
+        assert!(!state.apply_connectivity(reconnecting.clone()));
+        assert!(state.apply_connectivity(Connectivity {
+            retry_at_ms: 9_000,
+            ..reconnecting
+        }));
+        // Re-attach reopens the gap: the next frame counts again.
+        state.connectivity_observed = false;
+        assert!(state.apply_connectivity(state.connectivity.clone()));
+    }
+
+    #[test]
+    fn identical_transfer_auth_and_harness_frames_report_no_change() {
+        use zeron_proto::{HarnessUpdatePhase, HarnessUpdateStatus, TransferProgress};
+        let mut state = AppState::new();
+        assert!(!state.apply_transfers(vec![]));
+        let progress = |done| TransferProgress {
+            upload_id: "u1".into(),
+            file_name: "a.png".into(),
+            done,
+            total: 100,
+        };
+        assert!(state.apply_transfers(vec![progress(10)]));
+        assert!(!state.apply_transfers(vec![progress(10)]));
+        assert!(state.apply_transfers(vec![progress(20)]));
+        assert_eq!(state.transfer_percent("u1"), Some(20));
+        assert!(state.apply_transfers(vec![]));
+
+        assert!(state.apply_auth(AuthState::SignedOut));
+        assert!(!state.apply_auth_value(serde_json::json!({ "state": "signedOut" })));
+        let user = UserProfile {
+            id: "u".into(),
+            email: "w@example.com".into(),
+            name: None,
+        };
+        assert!(state.apply_auth(AuthState::NeedsOrganization { user: user.clone() }));
+        assert!(!state.apply_auth(AuthState::NeedsOrganization { user }));
+        assert!(!state.apply_auth_value(serde_json::json!({ "bogus": true })));
+
+        let status = |phase| HarnessUpdateStatus {
+            harness: HarnessId::Codex,
+            installed_version: Some("1.0".into()),
+            latest_version: Some("2.0".into()),
+            channel: None,
+            source: Default::default(),
+            policy: Default::default(),
+            phase,
+            progress: None,
+            checked_at: None,
+            error: None,
+            can_apply: true,
+            manual_command: None,
+        };
+        assert!(!state.apply_harness_updates(vec![]));
+        assert!(state.apply_harness_updates(vec![status(HarnessUpdatePhase::Available)]));
+        assert!(!state.apply_harness_updates(vec![status(HarnessUpdatePhase::Available)]));
+        assert!(state.apply_harness_updates(vec![status(HarnessUpdatePhase::Current)]));
+    }
+
     #[test]
     fn apply_chat_config_stamps_the_row() {
         let mut state = AppState::new();

From e5466c533616d6466c6bd5a0b60cfacb7b9422ef Mon Sep 17 00:00:00 2001
From: fate <119829254+Master0fFate@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:06:18 -0700
Subject: [PATCH 62/74] Windows browser, image previews in tool calls,
 selectable tool output (#813)

* Embed the browser on Windows and preview images in tool calls

- Browser tabs render pages inside Zeron on Windows (WebView2), matching macOS and Linux.
- Expanded tool calls preview the images they touch and free them on collapse.
  Right-click any transcript image to copy its path or the image itself.
- Paths, commands and output in expanded tool calls can be selected and copied.
- Fix: answering an agent question with multiple lines now grows the card instead
  of spilling text below it.

* Address review: repin zui upstream, harden the Windows browser and previews

- Depend on zeronsh/zui dce5c1f (zui#15 merged) and gpui-component
  47ccd07 instead of patching every gpui crate to a personal fork.
- Tool image previews: refuse UNC/device/drive-relative paths in the UI
  and, before any filesystem call, lexically jail requested paths in the
  engine (canonicalizing \\host\share opened an SMB session and leaked
  the user's NTLM hash); read chunks on the blocking pool; bound decodes
  with the shared raster limits; release keys a chip stops showing;
  decode base64 off the UI thread; copy sanitized SVG; cap output lines.
- Windows browser: fail closed on unreadable navigation targets; police
  subframes and cancel external-scheme launches; open tabs only for
  user-initiated popups (handled first); deny permission requests;
  disable web messages and host objects; cancel downloads silently
  unless the page itself is the file; recover from a browser-process
  exit on Reload; give each BrowserData its own InPrivate profile (no
  persistent fallback); sweep only folders of exited processes; never
  remount from an older composition generation.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock                                |   47 +-
 Cargo.toml                                |    8 +-
 crates/engine/src/rpc.rs                  |   11 +-
 crates/engine/src/uploads.rs              |  143 ++-
 crates/ui/Cargo.toml                      |   11 +
 crates/ui/examples/tool-images-fixture.rs |  428 +++++++
 crates/ui/src/attachments.rs              |    8 +-
 crates/ui/src/browser/mod.rs              |   88 +-
 crates/ui/src/browser/model.rs            |   30 +
 crates/ui/src/browser/view.rs             |  149 ++-
 crates/ui/src/browser/windows_webview.rs  | 1360 +++++++++++++++++++++
 crates/ui/src/composer.rs                 |   18 +
 crates/ui/src/image_media.rs              |   16 +-
 crates/ui/src/lib.rs                      |    1 +
 crates/ui/src/markdown/render.rs          |    2 +-
 crates/ui/src/shell.rs                    |   14 +-
 crates/ui/src/tool_images.rs              |  902 ++++++++++++++
 crates/ui/src/transcript.rs               |  696 ++++++++++-
 docs/image-preview.md                     |   10 +
 docs/reference/windows-development.md     |   26 +-
 20 files changed, 3823 insertions(+), 145 deletions(-)
 create mode 100644 crates/ui/examples/tool-images-fixture.rs
 create mode 100644 crates/ui/src/browser/windows_webview.rs
 create mode 100644 crates/ui/src/tool_images.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8e3be05ea5..9221c1fe32 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -952,7 +952,7 @@ dependencies = [
  "bitflags 2.13.1",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.10.5",
  "log",
  "prettyplease",
  "proc-macro2",
@@ -1628,7 +1628,7 @@ dependencies = [
 [[package]]
 name = "collections"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "gpui_util",
  "indexmap",
@@ -2426,7 +2426,7 @@ dependencies = [
 [[package]]
 name = "derive_refineable"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3647,7 +3647,7 @@ dependencies = [
 [[package]]
 name = "gpui"
 version = "0.2.2"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "accesskit",
  "anyhow",
@@ -3733,7 +3733,7 @@ dependencies = [
 [[package]]
 name = "gpui-base"
 version = "0.5.2"
-source = "git+https://github.com/zeronsh/gpui-component?rev=4764fd002ab5894ec9413511d01d37481b2129ab#4764fd002ab5894ec9413511d01d37481b2129ab"
+source = "git+https://github.com/zeronsh/gpui-component?rev=47ccd07295858d66f8fe826df9651a56218eb887#47ccd07295858d66f8fe826df9651a56218eb887"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3763,7 +3763,7 @@ dependencies = [
 [[package]]
 name = "gpui_linux"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "accesskit",
  "accesskit_unix",
@@ -3815,7 +3815,7 @@ dependencies = [
 [[package]]
 name = "gpui_macos"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "accesskit",
  "accesskit_macos",
@@ -3864,7 +3864,7 @@ dependencies = [
 [[package]]
 name = "gpui_macros"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -3875,7 +3875,7 @@ dependencies = [
 [[package]]
 name = "gpui_platform"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "console_error_panic_hook",
  "gpui",
@@ -3888,7 +3888,7 @@ dependencies = [
 [[package]]
 name = "gpui_shared_string"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "schemars",
  "serde",
@@ -3898,7 +3898,7 @@ dependencies = [
 [[package]]
 name = "gpui_tokio"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "anyhow",
  "gpui",
@@ -3909,7 +3909,7 @@ dependencies = [
 [[package]]
 name = "gpui_util"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "anyhow",
  "log",
@@ -3919,7 +3919,7 @@ dependencies = [
 [[package]]
 name = "gpui_web"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -3943,7 +3943,7 @@ dependencies = [
 [[package]]
 name = "gpui_wgpu"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "anyhow",
  "bytemuck",
@@ -3972,7 +3972,7 @@ dependencies = [
 [[package]]
 name = "gpui_windows"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "accesskit",
  "accesskit_windows",
@@ -4316,7 +4316,7 @@ dependencies = [
 [[package]]
 name = "http_client"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "anyhow",
  "async-compression",
@@ -5563,7 +5563,7 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 [[package]]
 name = "media"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "anyhow",
  "bindgen 0.71.1",
@@ -6937,7 +6937,7 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "perf"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "collections",
  "serde",
@@ -8051,7 +8051,7 @@ dependencies = [
 [[package]]
 name = "refineable"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "derive_refineable",
 ]
@@ -8772,7 +8772,7 @@ dependencies = [
 [[package]]
 name = "scheduler"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "async-task",
  "backtrace",
@@ -9619,7 +9619,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "sum_tree"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "heapless 0.9.3",
  "log",
@@ -11131,7 +11131,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 [[package]]
 name = "util_macros"
 version = "0.1.0"
-source = "git+https://github.com/zeronsh/zui?rev=0966d065b23e0b7c9b53c2e186705b8bce16fe2d#0966d065b23e0b7c9b53c2e186705b8bce16fe2d"
+source = "git+https://github.com/zeronsh/zui?rev=dce5c1f737a834b32c2b531d552ea78035e54093#dce5c1f737a834b32c2b531d552ea78035e54093"
 dependencies = [
  "perf",
  "quote",
@@ -13334,6 +13334,9 @@ dependencies = [
  "url",
  "usvg",
  "uuid",
+ "webview2-com",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
  "windows-sys 0.61.2",
  "wry",
  "x11rb 0.14.0",
diff --git a/Cargo.toml b/Cargo.toml
index b5edee7fd6..9eb9e5b5be 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -87,15 +87,15 @@ loro-protocol = "0.3"
 # Linux — the Metal path's snapshot/blur/composite, ported).
 # Paint-time rounded image masks (#9), bounded Windows backdrop blur and
 # translucent compositing, plus blur-aware scene batching (#10).
-gpui = { git = "https://github.com/zeronsh/zui", rev = "0966d065b23e0b7c9b53c2e186705b8bce16fe2d" }
-gpui_platform = { git = "https://github.com/zeronsh/zui", rev = "0966d065b23e0b7c9b53c2e186705b8bce16fe2d", features = [
+gpui = { git = "https://github.com/zeronsh/zui", rev = "dce5c1f737a834b32c2b531d552ea78035e54093" }
+gpui_platform = { git = "https://github.com/zeronsh/zui", rev = "dce5c1f737a834b32c2b531d552ea78035e54093", features = [
     "wayland",
     "x11",
     "font-kit",
     "runtime_shaders",
 ] }
-gpui_tokio = { git = "https://github.com/zeronsh/zui", rev = "0966d065b23e0b7c9b53c2e186705b8bce16fe2d" }
-gpui-base = { git = "https://github.com/zeronsh/gpui-component", rev = "4764fd002ab5894ec9413511d01d37481b2129ab" }
+gpui_tokio = { git = "https://github.com/zeronsh/zui", rev = "dce5c1f737a834b32c2b531d552ea78035e54093" }
+gpui-base = { git = "https://github.com/zeronsh/gpui-component", rev = "47ccd07295858d66f8fe826df9651a56218eb887" }
 
 # diffs
 similar = "2"
diff --git a/crates/engine/src/rpc.rs b/crates/engine/src/rpc.rs
index 0ee6078d19..d26f7046d3 100644
--- a/crates/engine/src/rpc.rs
+++ b/crates/engine/src/rpc.rs
@@ -3471,10 +3471,13 @@ impl RpcService for EngineRpc {
                     .filter_map(|chat| chat.cwd)
                     .map(std::path::PathBuf::from)
                     .collect();
-                let chunk = self
-                    .uploads
-                    .read_chunk(&p.path, p.offset, &roots)
-                    .map_err(|e| RpcError::Failed(e.to_string()))?;
+                let uploads = self.uploads.clone();
+                let chunk = tokio::task::spawn_blocking(move || {
+                    uploads.read_chunk(&p.path, p.offset, &roots)
+                })
+                .await
+                .map_err(|e| RpcError::Failed(e.to_string()))?
+                .map_err(|e| RpcError::Failed(e.to_string()))?;
                 RpcReply::value(&chunk)
             }
             methods::FETCH_TOOL_BLOB => {
diff --git a/crates/engine/src/uploads.rs b/crates/engine/src/uploads.rs
index 2557681375..a3aa7a3690 100644
--- a/crates/engine/src/uploads.rs
+++ b/crates/engine/src/uploads.rs
@@ -332,17 +332,37 @@ impl Uploads {
         } else {
             path
         };
-        // Canonicalize BOTH sides so `..` segments and symlinks can't escape.
-        let resolved = std::fs::canonicalize(path).map_err(|_| outside())?;
         let read_roots = self
             .inner
             .read_only_roots
             .read()
             .unwrap_or_else(std::sync::PoisonError::into_inner)
             .clone();
-        let allowed = std::iter::once(&self.inner.dir)
+        let roots: Vec<&PathBuf> = std::iter::once(&self.inner.dir)
             .chain(read_roots.iter())
             .chain(extra_roots.iter())
+            .collect();
+        // Jail lexically BEFORE any filesystem call: tool chips send paths an
+        // agent printed, and merely opening `\\host\share\a.png` (or an autofs
+        // `/net/host/…`) reaches out to that host — on Windows with the
+        // user's NTLM credentials. Roots match in raw and canonical form
+        // (`/var` vs `/private/var`, symlinked cwds).
+        let requested = lexical_components(Path::new(path)).ok_or_else(outside)?;
+        let lexically_allowed = roots.iter().any(|root| {
+            let canonical = std::fs::canonicalize(root).ok();
+            [Some(root.as_path()), canonical.as_deref()]
+                .into_iter()
+                .flatten()
+                .filter_map(lexical_components)
+                .any(|root| requested.len() > root.len() && requested.starts_with(&root))
+        });
+        if !lexically_allowed {
+            return Err(outside());
+        }
+        // Canonicalize BOTH sides so symlinks can't escape.
+        let resolved = std::fs::canonicalize(path).map_err(|_| outside())?;
+        let allowed = roots
+            .iter()
             .filter_map(|root| std::fs::canonicalize(root).ok())
             .any(|root| resolved.starts_with(&root) && resolved != root);
         if !allowed {
@@ -389,6 +409,48 @@ struct InspectedFile {
     size: u64,
 }
 
+/// An absolute local path's components with `.`/`..` resolved WITHOUT
+/// touching the filesystem. `None` for relative or drive-relative paths and
+/// for any Windows prefix but a drive letter (UNC, `\\.\` devices, verbatim
+/// non-disk). `C:` and `\\?\C:` agree; Windows compares case-insensitively.
+fn lexical_components(path: &Path) -> Option<Vec<std::ffi::OsString>> {
+    use std::path::{Component, Prefix};
+    if !path.is_absolute() {
+        return None;
+    }
+    let mut out: Vec<std::ffi::OsString> = Vec::new();
+    // Prefix + root: `/..` is `/`, so `..` never pops below them.
+    let mut anchor = 0;
+    for component in path.components() {
+        match component {
+            Component::Prefix(prefix) => match prefix.kind() {
+                Prefix::Disk(drive) | Prefix::VerbatimDisk(drive) => {
+                    out.push(format!("{}:", drive.to_ascii_uppercase() as char).into());
+                    anchor = out.len();
+                }
+                _ => return None,
+            },
+            Component::RootDir => {
+                out.push(std::path::MAIN_SEPARATOR_STR.into());
+                anchor = out.len();
+            }
+            Component::CurDir => {}
+            Component::ParentDir => {
+                if out.len() > anchor {
+                    out.pop();
+                }
+            }
+            Component::Normal(name) => {
+                #[cfg(windows)]
+                out.push(name.to_string_lossy().to_lowercase().into());
+                #[cfg(not(windows))]
+                out.push(name.to_os_string());
+            }
+        }
+    }
+    Some(out)
+}
+
 fn chunk_files(dir: &Path) -> Result<Vec<(u64, PathBuf)>, EngineError> {
     let Ok(entries) = std::fs::read_dir(dir) else {
         return Ok(Vec::new());
@@ -596,6 +658,81 @@ mod tests {
         assert!(target.starts_with(dir.path()));
         assert!(!target.to_string_lossy().contains(".."));
     }
+
+    #[test]
+    fn network_and_escaping_paths_are_refused_before_touching_the_filesystem() {
+        let dir = tempfile::tempdir().unwrap();
+        let workspace = tempfile::tempdir().unwrap();
+        let elsewhere = tempfile::tempdir().unwrap();
+        let uploads = Uploads::from_root(dir.path());
+        let roots = [workspace.path().to_path_buf()];
+        std::fs::write(workspace.path().join("shot.png"), b"png").unwrap();
+        std::fs::write(elsewhere.path().join("shot.png"), b"png").unwrap();
+        let inside = workspace.path().join("shot.png");
+        assert!(
+            uploads
+                .read_chunk(inside.to_str().unwrap(), 0, &roots)
+                .is_ok()
+        );
+        let escape = workspace
+            .path()
+            .join("..")
+            .join(elsewhere.path().file_name().unwrap())
+            .join("shot.png");
+        let mut paths = vec![
+            r"\\host\share\x.png".to_string(),
+            "//host/share/x.png".into(),
+            r"\\?\UNC\host\share\x.png".into(),
+            r"\\.\pipe\x.png".into(),
+            "file:////host/share/x.png".into(),
+            "/net/somehost/x.png".into(),
+            "C:x.png".into(),
+            "shot.png".into(),
+            escape.to_string_lossy().into_owned(),
+        ];
+        // A link from outside every root into one canonicalizes inside the
+        // jail; refusing it proves the lexical check runs before any
+        // filesystem call on the requested path.
+        #[cfg(unix)]
+        {
+            let link = elsewhere.path().join("link");
+            std::os::unix::fs::symlink(workspace.path(), &link).unwrap();
+            paths.push(link.join("shot.png").to_string_lossy().into_owned());
+        }
+        for path in paths {
+            let error = uploads
+                .read_chunk(&path, 0, &roots)
+                .expect_err(&format!("accepted {path:?}"));
+            assert!(
+                error.to_string().contains("outside the upload cache"),
+                "{path:?}: {error}"
+            );
+        }
+    }
+
+    #[test]
+    fn lexical_components_resolve_dots_and_refuse_non_disk_prefixes() {
+        let lexical = |path: &str| lexical_components(Path::new(path));
+        assert_eq!(lexical("/a/./b/../c/../../.."), lexical("/"));
+        assert_eq!(lexical("/a/b/../c.png"), lexical("/a/c.png"));
+        assert_eq!(lexical("relative/c.png"), None);
+        #[cfg(windows)]
+        {
+            assert_eq!(lexical(r"\\?\c:\A\b.png"), lexical(r"C:\a\B.PNG"));
+            assert_eq!(lexical(r"C:\..\..\a.png"), lexical(r"C:\a.png"));
+            for path in [
+                r"\\host\share\x.png",
+                "//host/share/x.png",
+                r"\\?\UNC\host\share\x.png",
+                r"\\.\pipe\x.png",
+                r"\\?\pipe\x.png",
+                "C:x.png",
+                r"\x.png",
+            ] {
+                assert_eq!(lexical(path), None, "{path}");
+            }
+        }
+    }
 }
 
 /// Imported generated media: only these sanitized fields may leave the engine.
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 2f6d6abc86..79a6e7c6b1 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -35,6 +35,10 @@ required-features = ["windows-render-fixture"]
 name = "appshots-fixture"
 required-features = ["appshots-fixture"]
 
+[[example]]
+name = "tool-images-fixture"
+required-features = ["appshots-fixture"]
+
 [[example]]
 name = "new-project-fixture"
 required-features = ["project-palette-fixture"]
@@ -124,4 +128,11 @@ mimalloc.workspace = true
 tracing-subscriber.workspace = true
 
 [target.'cfg(windows)'.dependencies]
+# Embedded browser: WebView2 in visual-hosting mode, composited by the zui
+# overlay plane. Same windows 0.61 as gpui_windows, so COM types interoperate.
+webview2-com = "0.38"
+windows = { version = "0.61", features = ["Win32_Foundation", "Win32_Graphics_Direct2D_Common", "Win32_Graphics_DirectComposition", "Win32_System_Com", "Win32_UI_Input_KeyboardAndMouse", "Win32_UI_WindowsAndMessaging"] }
+windows-core = "0.61"
+raw-window-handle = "0.6"
+reqwest.workspace = true
 windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_System_Threading", "Win32_UI_WindowsAndMessaging"] }
diff --git a/crates/ui/examples/tool-images-fixture.rs b/crates/ui/examples/tool-images-fixture.rs
new file mode 100644
index 0000000000..c84b6ef464
--- /dev/null
+++ b/crates/ui/examples/tool-images-fixture.rs
@@ -0,0 +1,428 @@
+//! Interactive tool-image preview session with isolated data and mock images.
+//! Images load through the real engine RPC (ReadAttachmentChunk) from a temp
+//! workspace. Close the window to exit. No agent runs.
+use gpui::{AppContext, Bounds, WindowBounds, WindowOptions, px, size};
+use image::{ImageEncoder, Rgba, RgbaImage};
+use serde_json::json;
+use std::{path::Path, sync::Arc};
+use zeron_proto::ToolCall;
+use zeron_ui::*;
+
+fn port() -> u16 {
+    std::net::TcpListener::bind("127.0.0.1:0")
+        .unwrap()
+        .local_addr()
+        .unwrap()
+        .port()
+}
+
+fn gradient(width: u32, height: u32, seed: u8) -> RgbaImage {
+    RgbaImage::from_fn(width, height, |x, y| {
+        let (fx, fy) = (x as f32 / width as f32, y as f32 / height as f32);
+        let ring = (((fx - 0.5).powi(2) + (fy - 0.5).powi(2)).sqrt() * 18.0).sin() > 0.6;
+        Rgba([
+            (fx * 255.0) as u8 ^ seed,
+            (fy * 220.0) as u8,
+            if ring { 255 } else { 90 + seed / 2 },
+            255,
+        ])
+    })
+}
+
+fn write_png(path: &Path, image: &RgbaImage) -> anyhow::Result<()> {
+    std::fs::create_dir_all(path.parent().unwrap())?;
+    let file = std::io::BufWriter::new(std::fs::File::create(path)?);
+    image::codecs::png::PngEncoder::new_with_quality(
+        file,
+        image::codecs::png::CompressionType::Fast,
+        image::codecs::png::FilterType::NoFilter,
+    )
+    .write_image(
+        image,
+        image.width(),
+        image.height(),
+        image::ExtendedColorType::Rgba8,
+    )?;
+    Ok(())
+}
+
+fn seed_workspace(root: &Path) -> anyhow::Result<()> {
+    write_png(&root.join("screenshots/home.png"), &gradient(1600, 1000, 0))?;
+    let mut chart = RgbaImage::from_pixel(800, 500, Rgba([24, 24, 28, 255]));
+    for (i, h) in [120u32, 260, 180, 420, 330, 210].iter().enumerate() {
+        for x in (60 + i as u32 * 120)..(140 + i as u32 * 120) {
+            for y in (480 - h)..480 {
+                chart.put_pixel(x, y, Rgba([90, 160 + i as u8 * 15, 255, 255]));
+            }
+        }
+    }
+    write_png(&root.join("charts/chart.png"), &chart)?;
+    write_png(&root.join("user/attached.png"), &gradient(900, 600, 77))?;
+    write_png(&root.join("generated/gen.png"), &gradient(1024, 1024, 150))?;
+    std::fs::create_dir_all(root.join("photos"))?;
+    image::DynamicImage::ImageRgba8(gradient(1920, 1080, 33))
+        .to_rgb8()
+        .save(root.join("photos/sunset.jpg"))?;
+    std::fs::create_dir_all(root.join("assets"))?;
+    image::DynamicImage::ImageRgba8(gradient(512, 512, 200)).save(root.join("assets/icon.webp"))?;
+    {
+        let file = std::fs::File::create(root.join("assets/spinner.gif"))?;
+        let mut encoder = image::codecs::gif::GifEncoder::new(file);
+        for seed in [10, 120] {
+            encoder.encode_frame(image::Frame::new(gradient(300, 300, seed)))?;
+        }
+    }
+    std::fs::write(
+        root.join("assets/logo.svg"),
+        r##"<svg xmlns="http://www.w3.org/2000/svg" width="420" height="160"><rect width="420" height="160" rx="24" fill="#1d1f27"/><circle cx="80" cy="80" r="48" fill="#7aa2ff"/><text x="150" y="98" font-size="44" fill="#e6e6e6" font-family="Geist">zeron</text></svg>"##,
+    )?;
+    std::fs::write(root.join("assets/notes.txt"), "not an image")?;
+    // Decode-bound check: 15 MP source, previewed as a ≤1280×640 thumbnail.
+    write_png(&root.join("big/huge.png"), &gradient(5000, 3000, 5))?;
+    for i in 0..12 {
+        write_png(
+            &root.join(format!("stress/frame-{i:02}.png")),
+            &gradient(1400, 900, i * 20),
+        )?;
+    }
+    Ok(())
+}
+
+fn tool(id: &str, call: ToolCall, output: &str, is_error: bool) -> serde_json::Value {
+    json!({"id": id, "kind": "tool", "call": call, "isError": is_error, "resolved": true, "output": output})
+}
+
+async fn pause(cx: &mut gpui::AsyncApp, ms: u64) {
+    cx.background_executor()
+        .timer(std::time::Duration::from_millis(ms))
+        .await;
+}
+
+fn capture(
+    window: gpui::AnyWindowHandle,
+    cx: &mut gpui::AsyncApp,
+    dir: &Path,
+    name: &str,
+) -> anyhow::Result<()> {
+    // Best effort: some platforms (Windows) have no render_to_image.
+    window.update(cx, |_, w, cx| {
+        w.draw(cx).clear();
+        if let Ok(image) = w.render_to_image() {
+            image.save(dir.join(format!("{name}.png"))).ok();
+        }
+    })?;
+    Ok(())
+}
+
+/// Expand, spam-toggle, collapse and copy through the production views,
+/// asserting residency at each step. Restores the user's clipboard.
+async fn self_check(
+    window: gpui::WindowHandle<shell::Shell>,
+    dir: &Path,
+    chart: &str,
+    cx: &mut gpui::AsyncApp,
+) -> anyhow::Result<()> {
+    std::fs::create_dir_all(dir)?;
+    let transcript = window.update(cx, |shell, _, _| shell.fixture_transcript())?;
+    let stats =
+        |cx: &mut gpui::AsyncApp| transcript.read_with(cx, |t, _| t.fixture_tool_image_stats());
+    let toggle = |open: bool, cx: &mut gpui::AsyncApp| {
+        transcript.update(cx, |t, cx| t.fixture_tool_images(open, cx))
+    };
+    let mut log = String::new();
+    pause(cx, 1500).await;
+    capture(window.into(), cx, dir, "1-collapsed")?;
+    let collapsed = stats(cx);
+    log += &format!(
+        "collapsed: {collapsed:?}
+"
+    );
+    anyhow::ensure!(collapsed == (0, 0), "collapsed chips hold previews");
+
+    toggle(true, cx);
+    transcript.update(cx, |t, cx| t.fixture_appshots_start(cx));
+    pause(cx, 8000).await;
+    capture(window.into(), cx, dir, "2-expanded")?;
+    let expanded = stats(cx);
+    log += &format!(
+        "expanded: {expanded:?}
+"
+    );
+    anyhow::ensure!(
+        expanded.0 > 0 && expanded.1 > 0,
+        "expanded chips decoded nothing"
+    );
+
+    let started = std::time::Instant::now();
+    for i in 0..60 {
+        toggle(i % 2 == 1, cx);
+        pause(cx, 16).await;
+    }
+    pause(cx, 300).await;
+    let spammed = stats(cx);
+    log += &format!(
+        "after 60 toggles in {:?}: {spammed:?}
+",
+        started.elapsed()
+    );
+    anyhow::ensure!(spammed == expanded, "spam re-decoded or dropped previews");
+
+    toggle(false, cx);
+    pause(cx, 250).await;
+    let grace = stats(cx);
+    log += &format!(
+        "250ms after collapse: {grace:?}
+"
+    );
+    pause(cx, 1200).await;
+    capture(window.into(), cx, dir, "3-collapsed-again")?;
+    let freed = stats(cx);
+    log += &format!(
+        "1450ms after collapse: {freed:?}
+"
+    );
+    anyhow::ensure!(freed == (0, 0), "collapsed previews were not freed");
+
+    let previous = cx.update(|cx| cx.read_from_clipboard());
+    gpui::AnyWindowHandle::from(window).update(cx, |_, w, cx| {
+        transcript.update(cx, |t, cx| t.fixture_image_menu(chart.into(), None, w, cx))
+    })?;
+    pause(cx, 2500).await;
+    capture(window.into(), cx, dir, "4-menu")?;
+    gpui::AnyWindowHandle::from(window).update(cx, |_, w, cx| {
+        transcript.update(cx, |t, cx| {
+            t.fixture_image_menu(chart.into(), Some(0), w, cx)
+        })
+    })?;
+    let text = cx.update(|cx| cx.read_from_clipboard().and_then(|c| c.text()));
+    log += &format!(
+        "copy path: {text:?}
+"
+    );
+    anyhow::ensure!(text.as_deref() == Some(chart), "copy path mismatch");
+    gpui::AnyWindowHandle::from(window).update(cx, |_, w, cx| {
+        transcript.update(cx, |t, cx| {
+            t.fixture_image_menu(chart.into(), Some(1), w, cx)
+        })
+    })?;
+    pause(cx, 2000).await;
+    let image = cx.update(|cx| {
+        cx.read_from_clipboard().and_then(|c| {
+            c.entries().iter().find_map(|e| match e {
+                gpui::ClipboardEntry::Image(image) => Some(image.bytes().len()),
+                _ => None,
+            })
+        })
+    });
+    log += &format!(
+        "copy image bytes: {image:?}
+"
+    );
+    if let Some(previous) = previous {
+        cx.update(|cx| cx.write_to_clipboard(previous));
+    }
+    anyhow::ensure!(
+        image.is_some_and(|n| n > 0),
+        "copy image put no image on the clipboard"
+    );
+    log += "PASS
+";
+    print!("{log}");
+    std::fs::write(dir.join("result.txt"), log)?;
+    Ok(())
+}
+
+fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter("warn,zeron_ui::tool_images=debug")
+        .init();
+    let temp = tempfile::tempdir()?;
+    let workspace = temp.path().join("workspace");
+    seed_workspace(&workspace)?;
+    let cwd = workspace.to_string_lossy().into_owned();
+    let abs = |rel: &str| {
+        workspace
+            .join(rel.replace('/', std::path::MAIN_SEPARATOR_STR))
+            .to_string_lossy()
+            .into_owned()
+    };
+    let runtime = tokio::runtime::Runtime::new()?;
+    let core = runtime.block_on(async {
+        zeron_engine::EngineCore::assemble(
+            &temp.path().join("engine"),
+            Arc::new(zeron_engine::default_registry()),
+            zeron_proto::HarnessId::ClaudeCode,
+            None,
+        )
+    })?;
+    core.workspace.create_chat(
+        "tool-images",
+        None,
+        Some(&core.device_id),
+        None,
+        Some(cwd.clone()),
+    )?;
+    core.workspace
+        .rename_chat("tool-images", "Tool image previews")?;
+    let ipc_port = port();
+    let _ipc = runtime.block_on(zeron_engine::serve_ipc(ipc_port, core.rpc_service()))?;
+    let data = temp.path().join("ui");
+    std::fs::create_dir(&data)?;
+    let boot = EngineBootConfig {
+        data_dir: data.clone(),
+        ipc_port,
+        edge_url: String::new(),
+        edge_token: None,
+        org_id: None,
+        workos_client_id: None,
+        default_harness: zeron_proto::HarnessId::ClaudeCode,
+    };
+    let handle = runtime.block_on(state::EngineHandle::bootstrap(boot.clone()))?;
+    let chats = core.workspace.read_chats()?;
+    let device = core.device_id.clone();
+
+    let read = |path: &str| ToolCall::ReadFile { path: path.into() };
+    let exec = |command: &str| ToolCall::Exec {
+        command: command.into(),
+    };
+    let outside = if cfg!(windows) {
+        r"C:\Windows\Web\Wallpaper\Windows\img0.jpg"
+    } else {
+        "/usr/share/backgrounds/outside.png"
+    };
+    let capture = std::env::args()
+        .skip_while(|arg| arg != "--capture")
+        .nth(1)
+        .map(std::path::PathBuf::from);
+    let chart = abs("charts/chart.png");
+    let entries = json!([
+        {"id": "u1", "role": "user", "createdAt": 1788900000000_i64, "deviceId": device,
+         "parts": [{"id": "t", "kind": "text", "text": attachments::with_attachments(
+            "Here is the mockup I attached. Render every image the tools touch.",
+            &[abs("user/attached.png")])}]},
+        {"id": "a1", "role": "assistant", "createdAt": 1788900001000_i64, "deviceId": device, "status": "complete",
+         "parts": [
+            {"id": "p0", "kind": "text", "text": "Open a tool group, then expand a chip. Its image decodes only while the chip is open. Right-click any image for **Copy path** / **Copy image**."},
+            tool("t1", read("screenshots/home.png"), "Read image (1600×1000)", false),
+            tool("t2", exec("python scripts/plot.py --out charts/chart.png"), "Saved chart to charts/chart.png", false),
+            tool("t3", ToolCall::Mcp { server: "browser".into(), tool: "screenshot".into(),
+                input: Some(json!({"path": abs("photos/sunset.jpg"), "fullPage": true})) }, "Captured viewport", false),
+            tool("t4", exec("ls assets"), "icon.webp\nlogo.svg\nnotes.txt\nspinner.gif", false),
+            tool("t5", read("big/huge.png"), "Read image (5000×3000)", false),
+            tool("t6", read("missing/nope.png"), "File not found", true),
+            tool("t7", read(outside), "Read image", false),
+            tool("t8", read("src/main.rs"), "fn main() {}", false),
+            {"id": "p1", "kind": "text", "text": "Above: PNG, chart, JPEG via MCP, WebP/SVG/GIF from output, a 15 MP PNG, a missing file and a path outside the workspace jail (both show *Image unavailable*)."},
+            {"id": "g1", "kind": "image", "path": abs("generated/gen.png"), "name": "gen.png", "mimeType": "image/png"},
+         ]},
+        {"id": "a2", "role": "assistant", "createdAt": 1788900002000_i64, "deviceId": device, "status": "complete",
+         "parts": (0..12).map(|i| tool(&format!("s{i}"), read(&format!("stress/frame-{i:02}.png")), "Read image (1400×900)", false))
+            .chain(std::iter::once(json!({"id": "p2", "kind": "text", "text": "Stress group: spam-toggle these chips. Previews reuse their texture inside the 600 ms grace and free after it (watch the `tool_images` debug log)."})))
+            .collect::<Vec<_>>()},
+    ]);
+
+    gpui_platform::application()
+        .with_assets(icons::Assets)
+        .run(move |cx| {
+            gpui_tokio::init(cx);
+            gpui_base::init(cx);
+            let settings = settings::UiSettings::default();
+            settings::init(settings.clone(), data.clone(), cx);
+            let fonts = typography::register_fonts(cx);
+            typography::init(
+                settings.ui_font_family.clone(),
+                settings.ui_font_size,
+                settings.terminal_font_family.clone(),
+                settings.terminal_font_size,
+                settings.code_font_family.clone(),
+                settings.code_font_size,
+                fonts,
+                cx,
+            );
+            theme_library::init(data.clone(), cx);
+            appearance::init(
+                appearance::AppearanceMode::Dark,
+                settings.theme_selection,
+                settings.accent,
+                settings.surface,
+                cx,
+            );
+            history::init(
+                settings.git_history_columns,
+                settings.git_history_column_widths,
+                settings.git_history_column_order,
+                settings.git_history_author_display,
+                cx,
+            );
+            composer::init(cx, settings.composer_send_behavior);
+            terminal::panel::init(cx);
+            app_menus::init(cx);
+            let state = cx.new(|_| {
+                let mut s = state::AppState::new();
+                s.fixture_attachment_engine(handle);
+                s.connection = zeron_proto::view::ConnectionStatus::Ready;
+                s.workspace_scope = Some(zeron_proto::WorkspaceScope::Development);
+                s.local_device_id = Some(device.clone());
+                s.devices = vec![
+                    serde_json::from_value(json!({"id": device, "name": "This device",
+                    "platform": std::env::consts::OS, "lastSeenAt": null}))
+                    .unwrap(),
+                ];
+                s.chats = chats;
+                s.selected_chat = Some("tool-images".into());
+                s.auto_selected = true;
+                s.chats_synced = true;
+                s.spaces_synced = true;
+                s.no_project = true;
+                s
+            });
+            let window = cx
+                .open_window(
+                    WindowOptions {
+                        window_background: theme::Theme::of(cx).window_background_appearance(),
+                        window_bounds: Some(WindowBounds::Windowed(Bounds::new(
+                            gpui::point(px(40.), px(40.)),
+                            size(px(1200.), px(900.)),
+                        ))),
+                        ..Default::default()
+                    },
+                    |_, cx| cx.new(|cx| shell::Shell::new(state.clone(), boot, cx)),
+                )
+                .unwrap();
+            cx.on_window_closed(|cx, _| cx.quit()).detach();
+            state.update(cx, |_, cx| cx.notify());
+            cx.activate(true);
+            cx.spawn(async move |cx| {
+                cx.background_executor()
+                    .timer(std::time::Duration::from_millis(800))
+                    .await;
+                state.update(cx, |s, cx| {
+                    s.receive_transcript_frame(
+                        zeron_doc::TranscriptFrame::Reset {
+                            reset: serde_json::from_value(entries).unwrap(),
+                        },
+                        cx,
+                    )
+                    .unwrap();
+                    cx.notify();
+                });
+                if let Some(dir) = capture {
+                    if let Err(error) = self_check(window, &dir, &chart, cx).await {
+                        eprintln!("self-check failed: {error:#}");
+                        std::fs::write(
+                            dir.join("result.txt"),
+                            format!(
+                                "FAILED: {error:#}
+"
+                            ),
+                        )
+                        .ok();
+                    }
+                    cx.update(|cx| cx.quit());
+                }
+            })
+            .detach();
+        });
+    runtime.block_on(core.shutdown());
+    Ok(())
+}
diff --git a/crates/ui/src/attachments.rs b/crates/ui/src/attachments.rs
index 38fa5195bf..06b0d65f55 100644
--- a/crates/ui/src/attachments.rs
+++ b/crates/ui/src/attachments.rs
@@ -631,7 +631,7 @@ pub struct LoadedAttachmentImage {
 /// `ReadAttachmentChunk` loop: 45KB base64 chunks until `done` (bounded, with
 /// the same stuck-offset guard as zeron's `readAttachmentImage`). Returns the
 /// file's name, MIME type and bytes.
-async fn read_attachment_bytes(
+pub(crate) async fn read_attachment_bytes(
     engine: &EngineHandle,
     executor: &BackgroundExecutor,
     target_device_id: Option<&str>,
@@ -680,7 +680,11 @@ async fn read_attachment_bytes(
     if !done {
         return None;
     }
-    let bytes = BASE64.decode(b64.as_bytes()).ok()?;
+    // Callers await this on the UI thread; decode the (up to 24 MiB) payload
+    // off it.
+    let bytes = executor
+        .spawn(async move { BASE64.decode(b64.as_bytes()).ok() })
+        .await?;
     Some((name, mime, bytes))
 }
 
diff --git a/crates/ui/src/browser/mod.rs b/crates/ui/src/browser/mod.rs
index 6b4cb526a8..83f03f529b 100644
--- a/crates/ui/src/browser/mod.rs
+++ b/crates/ui/src/browser/mod.rs
@@ -7,6 +7,10 @@ mod macos;
 use linux as native;
 #[cfg(target_os = "macos")]
 use macos as native;
+#[cfg(windows)]
+mod windows_webview;
+#[cfg(windows)]
+use windows_webview as native;
 pub mod model;
 mod view;
 
@@ -70,12 +74,12 @@ pub enum BrowserEvent {
 /// A window/profile's ephemeral website data, allocated on first navigation.
 #[derive(Clone, Default)]
 pub struct BrowserContext {
-    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    #[cfg(any(target_os = "macos", target_os = "linux", windows))]
     data: native::BrowserData,
 }
 
 pub struct BrowserSurface {
-    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    #[cfg(any(target_os = "macos", target_os = "linux", windows))]
     context: BrowserContext,
     address: Entity<ComposerInput>,
     focus: FocusHandle,
@@ -92,19 +96,22 @@ pub struct BrowserSurface {
     presentation: Presentation,
     #[cfg(target_os = "macos")]
     resize_inset: gpui::Pixels,
-    #[cfg(target_os = "macos")]
+    #[cfg(any(target_os = "macos", windows))]
     right_occlusion: gpui::Pixels,
     _input_sub: Subscription,
-    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    #[cfg(any(target_os = "macos", target_os = "linux", windows))]
     native: Option<native::NativePage>,
-    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    #[cfg(any(target_os = "macos", target_os = "linux", windows))]
     native_tx: tokio::sync::mpsc::Sender<native::NativeEvent>,
-    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    #[cfg(any(target_os = "macos", target_os = "linux", windows))]
     _native_task: gpui::Task<()>,
-    #[cfg(target_os = "macos")]
+    #[cfg(any(target_os = "macos", windows))]
     favicon_task: Option<gpui::Task<()>>,
-    #[cfg(target_os = "macos")]
+    #[cfg(any(target_os = "macos", windows))]
     favicon_generation: u64,
+    /// The page's pointer cursor (Windows: GPUI owns the cursor).
+    #[cfg(windows)]
+    page_cursor: gpui::CursorStyle,
 }
 
 impl EventEmitter<BrowserEvent> for BrowserSurface {}
@@ -135,9 +142,9 @@ impl BrowserSurface {
                 cx.notify();
             }
         });
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         let (native_tx, mut events) = tokio::sync::mpsc::channel(64);
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         let native_task = cx.spawn_in(window, async move |this, cx| {
             while let Some(event) = events.recv().await {
                 if this
@@ -150,10 +157,10 @@ impl BrowserSurface {
                 }
             }
         });
-        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
         let _ = (window, context);
         Self {
-            #[cfg(any(target_os = "macos", target_os = "linux"))]
+            #[cfg(any(target_os = "macos", target_os = "linux", windows))]
             context,
             address,
             focus: cx.focus_handle(),
@@ -170,19 +177,21 @@ impl BrowserSurface {
             presentation: Presentation::Hidden,
             #[cfg(target_os = "macos")]
             resize_inset: gpui::px(0.0),
-            #[cfg(target_os = "macos")]
+            #[cfg(any(target_os = "macos", windows))]
             right_occlusion: gpui::px(0.0),
             _input_sub: input_sub,
-            #[cfg(any(target_os = "macos", target_os = "linux"))]
+            #[cfg(any(target_os = "macos", target_os = "linux", windows))]
             native: None,
-            #[cfg(any(target_os = "macos", target_os = "linux"))]
+            #[cfg(any(target_os = "macos", target_os = "linux", windows))]
             native_tx,
-            #[cfg(any(target_os = "macos", target_os = "linux"))]
+            #[cfg(any(target_os = "macos", target_os = "linux", windows))]
             _native_task: native_task,
-            #[cfg(target_os = "macos")]
+            #[cfg(any(target_os = "macos", windows))]
             favicon_task: None,
-            #[cfg(target_os = "macos")]
+            #[cfg(any(target_os = "macos", windows))]
             favicon_generation: 0,
+            #[cfg(windows)]
+            page_cursor: gpui::CursorStyle::Arrow,
         }
     }
 
@@ -193,7 +202,7 @@ impl BrowserSurface {
         self.remote = remote;
     }
     pub fn set_shortcuts(&mut self, keymap: &crate::settings::KeymapConfig) {
-        #[cfg(target_os = "macos")]
+        #[cfg(any(target_os = "macos", windows))]
         if let Some(native) = &self.native {
             native.set_shortcuts(
                 crate::settings::ShortcutId::ALL
@@ -203,12 +212,12 @@ impl BrowserSurface {
                     .collect(),
             );
         }
-        #[cfg(not(target_os = "macos"))]
+        #[cfg(not(any(target_os = "macos", windows)))]
         let _ = keymap;
     }
 
     pub fn focus_address(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        #[cfg(target_os = "macos")]
+        #[cfg(any(target_os = "macos", windows))]
         if let Some(native) = &self.native {
             native.focus_chrome();
         }
@@ -226,7 +235,7 @@ impl BrowserSurface {
     }
 
     /// Crop a GPUI overlay out of both native painting and native hit testing.
-    #[cfg(target_os = "macos")]
+    #[cfg(any(target_os = "macos", windows))]
     pub fn set_right_occlusion(&mut self, width: gpui::Pixels, cx: &mut Context<Self>) {
         if self.right_occlusion != width {
             self.right_occlusion = width;
@@ -239,7 +248,7 @@ impl BrowserSurface {
             return;
         }
         self.presentation = presentation;
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         if let Some(native) = &mut self.native {
             native.present(presentation);
         }
@@ -331,9 +340,9 @@ impl BrowserSurface {
         self.page.title.clear();
         self.page.error = None;
         self.clear_favicon(cx);
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         {
-            #[cfg(target_os = "macos")]
+            #[cfg(any(target_os = "macos", windows))]
             {
                 self.favicon_generation += 1;
                 self.favicon_task = None;
@@ -354,7 +363,7 @@ impl BrowserSurface {
             }
             window.focus(&self.focus, cx);
         }
-        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
         {
             let _ = window;
             cx.open_url(&url);
@@ -369,7 +378,7 @@ impl BrowserSurface {
     }
 
     fn reload(&mut self, cx: &mut Context<Self>) {
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         if let Some(native) = &self.native {
             if self.page.error.is_some() {
                 if let Some(url) = &self.page.url {
@@ -380,7 +389,7 @@ impl BrowserSurface {
             }
             self.page.error = None;
         }
-        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
         self.open_external(cx);
         cx.notify();
     }
@@ -397,11 +406,11 @@ impl BrowserSurface {
     }
 
     fn history(&mut self, forward: bool) {
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         if let Some(native) = &self.native {
             native.history(forward);
         }
-        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
         let _ = forward;
     }
 
@@ -415,7 +424,7 @@ impl BrowserSurface {
     pub fn close(&mut self, cx: &mut Context<Self>) {
         self.set_presentation(Presentation::Hidden, cx);
         self.clear_favicon(cx);
-        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        #[cfg(any(target_os = "macos", target_os = "linux", windows))]
         {
             if let Some(native) = &mut self.native {
                 native.present(Presentation::Hidden);
@@ -425,7 +434,7 @@ impl BrowserSurface {
                 cx.defer(move |cx| gpui::ImageSource::Render(image).evict(None, cx));
             }
             self.native = None;
-            #[cfg(target_os = "macos")]
+            #[cfg(any(target_os = "macos", windows))]
             {
                 self.favicon_task = None;
                 self.favicon_generation += 1;
@@ -434,7 +443,7 @@ impl BrowserSurface {
     }
 }
 
-#[cfg(target_os = "macos")]
+#[cfg(any(target_os = "macos", windows))]
 impl BrowserSurface {
     fn on_native_event(
         &mut self,
@@ -495,6 +504,13 @@ impl BrowserSurface {
                     });
                 }
             }
+            #[cfg(windows)]
+            native::NativeEvent::Cursor(style) => {
+                if self.page_cursor != style {
+                    self.page_cursor = style;
+                    cx.notify();
+                }
+            }
             native::NativeEvent::Favicon { page, url } => {
                 if self.page.url.as_deref() != Some(&page) || !model::allowed_navigation(&url) {
                     return;
@@ -607,7 +623,11 @@ impl BrowserSurface {
             self.presentation != Presentation::Hidden
                 && self.native.as_ref().is_some_and(|n| n.image.is_some())
         }
-        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        #[cfg(windows)]
+        {
+            self.presentation != Presentation::Hidden && self.native.is_some()
+        }
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
         {
             false
         }
diff --git a/crates/ui/src/browser/model.rs b/crates/ui/src/browser/model.rs
index 92d5a94b35..306bc13a70 100644
--- a/crates/ui/src/browser/model.rs
+++ b/crates/ui/src/browser/model.rs
@@ -137,6 +137,14 @@ pub fn allowed_navigation(address: &str) -> bool {
     })
 }
 
+/// Subframe navigations: web content, including a frame's own documents
+/// (`about:blank`, `about:srcdoc`, `data:`, `blob:`) — never a scheme that
+/// leaves the page (`file:`, `javascript:`, app links).
+pub fn allowed_frame_navigation(address: &str) -> bool {
+    allowed_navigation(address)
+        || url::Url::parse(address).is_ok_and(|u| matches!(u.scheme(), "about" | "data" | "blob"))
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub enum Presentation {
     #[default]
@@ -193,6 +201,28 @@ mod tests {
         assert!(!allowed_navigation("https://user@example.com/"));
     }
     #[test]
+    fn frames_load_web_content_but_never_leave_the_page() {
+        for ok in [
+            "https://example.com/embed",
+            "about:blank",
+            "about:srcdoc",
+            "data:text/html,hi",
+            "blob:https://example.com/0f3e",
+        ] {
+            assert!(allowed_frame_navigation(ok), "{ok}");
+        }
+        for blocked in [
+            "zeron://open/chat/a",
+            "ms-settings:privacy",
+            "file:///C:/Windows/win.ini",
+            "javascript:alert(1)",
+            "mailto:a@example.com",
+            "",
+        ] {
+            assert!(!allowed_frame_navigation(blocked), "{blocked}");
+        }
+    }
+    #[test]
     fn native_visibility_never_outlives_its_surface() {
         assert_eq!(presentation(false, false), Presentation::Hidden);
         assert_eq!(presentation(false, true), Presentation::Hidden);
diff --git a/crates/ui/src/browser/view.rs b/crates/ui/src/browser/view.rs
index 47d268754b..f968cfddf2 100644
--- a/crates/ui/src/browser/view.rs
+++ b/crates/ui/src/browser/view.rs
@@ -284,7 +284,7 @@ impl BrowserSurface {
         if self.page.url.is_none() && self.previews_task.is_some() {
             return self.preview_body(theme, cx);
         }
-        let external = !cfg!(any(target_os = "macos", target_os = "linux"));
+        let external = !cfg!(any(target_os = "macos", target_os = "linux", windows));
         let has_error = self.page.error.is_some();
         let title = if has_error {
             "Couldn’t load this page"
@@ -399,11 +399,140 @@ impl BrowserSurface {
     }
 }
 
+#[cfg(windows)]
+impl BrowserSurface {
+    /// The page composites natively beneath GPUI's overlay plane; this
+    /// element only positions it and forwards pointer input that GPUI's hit
+    /// testing delivers here, so popovers above the page occlude naturally.
+    fn windows_page(
+        &self,
+        body: gpui::Stateful<gpui::Div>,
+        host: std::rc::Rc<super::native::Host>,
+        cx: &mut Context<Self>,
+    ) -> gpui::Stateful<gpui::Div> {
+        use super::native::{PointerKind, wheel_units};
+        let entity = cx.entity().downgrade();
+        let forward = |kind: PointerKind| {
+            move |this: &mut Self,
+                  position: gpui::Point<gpui::Pixels>,
+                  button: Option<MouseButton>,
+                  modifiers: gpui::Modifiers,
+                  clicks: usize| {
+                if let Some(native) = &this.native {
+                    native.pointer(kind, position, button, modifiers, clicks);
+                }
+            }
+        };
+        let right_occlusion = self.right_occlusion;
+        let mut body = body.cursor(self.page_cursor).child(
+            gpui::canvas(
+                |_, _, _| (),
+                move |bounds, _, window, _| {
+                    // The Files panel slides over the page from the right.
+                    let mut mask = window.content_mask().bounds;
+                    let right = (window.viewport_size().width - right_occlusion).max(mask.left());
+                    mask.size.width = mask.size.width.min(right - mask.left());
+                    let scale = window.scale_factor();
+                    let composition = window.native_composition();
+                    let page = std::rc::Rc::downgrade(&host);
+                    window.on_present(move || {
+                        if let Some(page) = page.upgrade() {
+                            page.sync(bounds, mask, scale, composition);
+                        }
+                    });
+                    // A drag that began in the page keeps extending its
+                    // selection outside the page, like a native child.
+                    let capture = entity.clone();
+                    window.on_mouse_event(move |event: &gpui::MouseMoveEvent, phase, _, cx| {
+                        if phase == gpui::DispatchPhase::Bubble
+                            && !bounds.contains(&event.position)
+                            && !cx.has_active_drag()
+                        {
+                            let _ = capture.update(cx, |this, _| {
+                                if let Some(native) =
+                                    this.native.as_ref().filter(|native| native.pressed())
+                                {
+                                    native.pointer(
+                                        PointerKind::Move,
+                                        event.position,
+                                        None,
+                                        event.modifiers,
+                                        0,
+                                    );
+                                }
+                            });
+                        }
+                    });
+                },
+            )
+            .absolute()
+            .inset_0(),
+        );
+        for button in [MouseButton::Left, MouseButton::Right, MouseButton::Middle] {
+            let down = forward(PointerKind::Down);
+            let up = forward(PointerKind::Up);
+            let up_out = forward(PointerKind::Up);
+            body = body
+                .on_mouse_down(
+                    button,
+                    cx.listener(move |this, event: &gpui::MouseDownEvent, window, cx| {
+                        if cx.has_active_drag() {
+                            return;
+                        }
+                        window.focus(&this.focus, cx);
+                        down(
+                            this,
+                            event.position,
+                            Some(event.button),
+                            event.modifiers,
+                            event.click_count,
+                        );
+                        cx.stop_propagation();
+                    }),
+                )
+                .on_mouse_up(
+                    button,
+                    cx.listener(move |this, event: &gpui::MouseUpEvent, _, cx| {
+                        up(this, event.position, Some(event.button), event.modifiers, 0);
+                        cx.stop_propagation();
+                    }),
+                )
+                .on_mouse_up_out(
+                    button,
+                    cx.listener(move |this, event: &gpui::MouseUpEvent, _, _| {
+                        if this.native.as_ref().is_some_and(|native| native.pressed()) {
+                            up_out(this, event.position, Some(event.button), event.modifiers, 0);
+                        }
+                    }),
+                );
+        }
+        let moved = forward(PointerKind::Move);
+        body.on_mouse_move(
+            cx.listener(move |this, event: &gpui::MouseMoveEvent, _, cx| {
+                if !cx.has_active_drag() {
+                    moved(this, event.position, None, event.modifiers, 0);
+                }
+            }),
+        )
+        .on_scroll_wheel(cx.listener(|this, event: &gpui::ScrollWheelEvent, _, cx| {
+            if let Some(native) = &this.native {
+                native.wheel(event.position, wheel_units(event.delta), event.modifiers);
+                cx.stop_propagation();
+            }
+        }))
+        .on_hover(cx.listener(|this, hovered: &bool, _, _| {
+            if !*hovered && let Some(native) = &this.native {
+                native.leave();
+            }
+        }))
+    }
+}
+
 impl Render for BrowserSurface {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let theme = Theme::of(cx).clone();
         let focused = self.address.focus_handle(cx).is_focused(window);
-        let external = !cfg!(any(target_os = "macos", target_os = "linux"));
+        let external = !cfg!(any(target_os = "macos", target_os = "linux", windows));
         let has_page = self.page.url.is_some();
         let back = button(
             "browser-back",
@@ -446,11 +575,11 @@ impl Render for BrowserSurface {
             .on_mouse_down(
                 MouseButton::Left,
                 cx.listener(|this, _, _, _| {
-                    #[cfg(target_os = "macos")]
+                    #[cfg(any(target_os = "macos", windows))]
                     if let Some(native) = &this.native {
                         native.focus_chrome();
                     }
-                    #[cfg(not(target_os = "macos"))]
+                    #[cfg(not(any(target_os = "macos", windows)))]
                     let _ = this;
                 }),
             )
@@ -613,7 +742,17 @@ impl Render for BrowserSurface {
         } else {
             body.child(self.empty_body(&theme, cx))
         };
-        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        #[cfg(windows)]
+        let body = if let Some(native) = &self.native {
+            if self.page.error.is_some() {
+                body.child(self.empty_body(&theme, cx))
+            } else {
+                self.windows_page(body, native.handle(), cx)
+            }
+        } else {
+            body.child(self.empty_body(&theme, cx))
+        };
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
         let body = body.child(self.empty_body(&theme, cx));
 
         #[cfg(target_os = "linux")]
diff --git a/crates/ui/src/browser/windows_webview.rs b/crates/ui/src/browser/windows_webview.rs
new file mode 100644
index 0000000000..d96594be75
--- /dev/null
+++ b/crates/ui/src/browser/windows_webview.rs
@@ -0,0 +1,1360 @@
+//! Windows boundary for the browser: WebView2 in visual-hosting mode. Each
+//! page is a DirectComposition visual mounted in the zui overlay plane's
+//! native layer, so DWM composites it between GPUI's base and overlay planes
+//! without copies or child windows. GPUI keeps every pointer event and
+//! forwards only those that reach the page; the page owns the keyboard while
+//! focused. Callbacks enqueue events and never re-enter GPUI.
+use super::model::{PageState, Presentation, allowed_frame_navigation, allowed_navigation};
+use gpui::{Bounds, CursorStyle, Keystroke, Modifiers, MouseButton, Pixels, Point, Window};
+use std::{
+    cell::{Cell, RefCell},
+    rc::Rc,
+};
+use webview2_com::{
+    AcceleratorKeyPressedEventHandler, CreateCoreWebView2CompositionControllerCompletedHandler,
+    CreateCoreWebView2EnvironmentCompletedHandler, CursorChangedEventHandler,
+    DocumentTitleChangedEventHandler, DownloadStartingEventHandler, FaviconChangedEventHandler,
+    HistoryChangedEventHandler, LaunchingExternalUriSchemeEventHandler,
+    Microsoft::Web::WebView2::Win32::*, NavigationCompletedEventHandler,
+    NavigationStartingEventHandler, NewWindowRequestedEventHandler,
+    PermissionRequestedEventHandler, ProcessFailedEventHandler, SourceChangedEventHandler,
+    take_pwstr,
+};
+use windows::{
+    Win32::{
+        Foundation::{HWND, POINT, RECT},
+        Graphics::{Direct2D::Common::D2D_RECT_F, DirectComposition::*},
+        UI::Input::KeyboardAndMouse::{
+            GetKeyState, VIRTUAL_KEY, VK_CONTROL, VK_LWIN, VK_MENU, VK_RWIN, VK_SHIFT,
+        },
+    },
+    core::{HSTRING, Interface, PWSTR},
+};
+
+type Sender = tokio::sync::mpsc::Sender<NativeEvent>;
+
+pub(super) enum NativeEvent {
+    Changed,
+    Finished,
+    NewTab(String),
+    Key(Keystroke),
+    Favicon { page: String, url: String },
+    Cursor(CursorStyle),
+}
+
+// ---------------------------------------------------------------------------
+// Shared environment: one browser process for a window's tabs
+// ---------------------------------------------------------------------------
+
+type EnvironmentWaiter = Box<dyn FnOnce(Result<ICoreWebView2Environment, String>)>;
+
+#[derive(Default)]
+enum Environment {
+    #[default]
+    Idle,
+    Pending(Vec<EnvironmentWaiter>),
+    Ready(ICoreWebView2Environment),
+    Failed(String),
+}
+
+struct EnvironmentState {
+    environment: Environment,
+    /// Set once the shared folder answered ERROR_BUSY (see [`is_busy`]).
+    own_folder: bool,
+    /// InPrivate profile of this window/profile's pages. Every InPrivate
+    /// controller with the same profile name shares one cookie jar — across
+    /// windows, profile switches and processes sharing the folder — so each
+    /// `BrowserData` gets its own, as macOS gets a fresh non-persistent store.
+    profile: String,
+}
+
+impl Default for EnvironmentState {
+    fn default() -> Self {
+        static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+        let started = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_or(0, |elapsed| elapsed.as_nanos());
+        Self {
+            environment: Environment::default(),
+            own_folder: false,
+            profile: format!(
+                "zeron-{}-{started}-{}",
+                std::process::id(),
+                NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+            ),
+        }
+    }
+}
+
+/// A window/profile's WebView2 environment, created on first use: one
+/// browser process for all of its tabs. Pages are InPrivate, so nothing
+/// outlives the session (as macOS's non-persistent store); the user-data
+/// folder only holds the runtime's own caches.
+#[derive(Clone, Default)]
+pub(super) struct BrowserData(Rc<RefCell<EnvironmentState>>);
+
+impl BrowserData {
+    fn with_environment(
+        &self,
+        done: impl FnOnce(Result<ICoreWebView2Environment, String>) + 'static,
+    ) {
+        let mut state = self.0.borrow_mut();
+        match &mut state.environment {
+            Environment::Ready(environment) => {
+                let environment = environment.clone();
+                drop(state);
+                done(Ok(environment));
+            }
+            Environment::Failed(error) => {
+                let error = error.clone();
+                drop(state);
+                done(Err(error));
+            }
+            Environment::Pending(waiters) => waiters.push(Box::new(done)),
+            Environment::Idle => {
+                state.environment = Environment::Pending(vec![Box::new(done)]);
+                drop(state);
+                create_environment(Rc::downgrade(&self.0));
+            }
+        }
+    }
+
+    /// Drop `environment` after its browser process exited, so the next page
+    /// starts a fresh one. A newer environment is left alone.
+    fn forget(&self, environment: &ICoreWebView2Environment) {
+        let mut state = self.0.borrow_mut();
+        if matches!(&state.environment, Environment::Ready(ready) if ready == environment) {
+            state.environment = Environment::Idle;
+        }
+    }
+
+    fn profile(&self) -> String {
+        self.0.borrow().profile.clone()
+    }
+
+    /// Move this process to its own folder after the shared one was busy.
+    /// Returns false when that already happened (no further retries).
+    fn fall_back(&self) -> bool {
+        let mut state = self.0.borrow_mut();
+        if state.own_folder {
+            return false;
+        }
+        state.own_folder = true;
+        if !matches!(state.environment, Environment::Pending(_)) {
+            state.environment = Environment::Idle;
+        }
+        true
+    }
+}
+
+/// A folder still held by another process (a second Zeron, or one shutting
+/// down after a quick restart) answers ERROR_BUSY at any creation step.
+fn is_busy(error: &windows::core::Error) -> bool {
+    error.code() == windows::core::HRESULT(0x8007_00AA_u32 as i32)
+}
+
+/// The runtime's caches are shared across launches for a warm start; a
+/// busy shared folder sends this process to its own.
+fn user_data_folder(own: bool) -> std::path::PathBuf {
+    let temp = std::env::temp_dir();
+    if !own {
+        return temp.join("zeron-webview2");
+    }
+    // Sweep folders of exited processes. Only those: removal deletes what
+    // it can before failing on a locked file, so a live instance's folder
+    // would lose its unlocked files.
+    let pid = std::process::id();
+    let sweep = temp.clone();
+    std::thread::spawn(move || {
+        for entry in std::fs::read_dir(&sweep).into_iter().flatten().flatten() {
+            let name = entry.file_name();
+            let owner = name
+                .to_str()
+                .and_then(|name| name.strip_prefix("zeron-webview2-"))
+                .and_then(|owner| owner.parse::<u32>().ok());
+            if let Some(owner) = owner
+                && owner != pid
+                && !process_alive(owner)
+            {
+                let _ = std::fs::remove_dir_all(entry.path());
+            }
+        }
+    });
+    temp.join(format!("zeron-webview2-{pid}"))
+}
+
+/// Whether `pid` names a running process (pids are reused, so a false
+/// "alive" only leaves a stale folder for a later sweep).
+fn process_alive(pid: u32) -> bool {
+    use windows_sys::Win32::{
+        Foundation::{CloseHandle, STILL_ACTIVE},
+        System::Threading::{GetExitCodeProcess, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION},
+    };
+    unsafe {
+        let process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
+        if process.is_null() {
+            return false;
+        }
+        let mut code = 0u32;
+        let alive = GetExitCodeProcess(process, &mut code) != 0 && code == STILL_ACTIVE as u32;
+        CloseHandle(process);
+        alive
+    }
+}
+
+fn create_environment(shared: std::rc::Weak<RefCell<EnvironmentState>>) {
+    let Some(state) = shared.upgrade() else {
+        return;
+    };
+    let own = state.borrow().own_folder;
+    drop(state);
+    let finish = |shared: &std::rc::Weak<RefCell<EnvironmentState>>,
+                  outcome: Result<ICoreWebView2Environment, String>| {
+        let Some(shared) = shared.upgrade() else {
+            return;
+        };
+        let next = match &outcome {
+            Ok(environment) => Environment::Ready(environment.clone()),
+            Err(error) => Environment::Failed(error.clone()),
+        };
+        let waiters = match std::mem::replace(&mut shared.borrow_mut().environment, next) {
+            Environment::Pending(waiters) => waiters,
+            _ => Vec::new(),
+        };
+        for waiter in waiters {
+            waiter(outcome.clone());
+        }
+    };
+    let retry = |shared: std::rc::Weak<RefCell<EnvironmentState>>| {
+        if let Some(state) = shared.upgrade() {
+            state.borrow_mut().own_folder = true;
+        }
+        create_environment(shared);
+    };
+    let callback = shared.clone();
+    let handler = CreateCoreWebView2EnvironmentCompletedHandler::create(Box::new(
+        move |result, environment| {
+            match result.and_then(|()| environment.ok_or_else(windows::core::Error::empty)) {
+                Ok(environment) => finish(&callback, Ok(environment)),
+                Err(error) if !own && is_busy(&error) => retry(callback),
+                Err(error) => finish(&callback, Err(runtime_error(&error))),
+            }
+            Ok(())
+        },
+    ));
+    let created = unsafe {
+        CreateCoreWebView2EnvironmentWithOptions(
+            None,
+            &HSTRING::from(user_data_folder(own).to_string_lossy().as_ref()),
+            None::<&ICoreWebView2EnvironmentOptions>,
+            &handler,
+        )
+    };
+    match created {
+        Ok(()) => {}
+        Err(error) if !own && is_busy(&error) => retry(shared),
+        Err(error) => finish(&shared, Err(runtime_error(&error))),
+    }
+}
+
+fn runtime_error(error: &windows::core::Error) -> String {
+    tracing::warn!(%error, "WebView2 unavailable");
+    "The Microsoft Edge WebView2 Runtime is required to show pages here.".into()
+}
+
+// ---------------------------------------------------------------------------
+// Page
+// ---------------------------------------------------------------------------
+
+/// COM objects of a created page.
+struct Page {
+    /// The environment the page lives in (forgotten if its browser exits).
+    environment: ICoreWebView2Environment,
+    composition: ICoreWebView2CompositionController,
+    controller: ICoreWebView2Controller,
+    webview: ICoreWebView2,
+    /// The page's root visual and the layer it mounts in, from `generation`.
+    visual: Option<(IDCompositionVisual, IDCompositionVisual, u64)>,
+    mounted: bool,
+    /// What was last handed to WebView2 and the visual, so an unchanged
+    /// frame makes no calls at all.
+    applied: Option<Applied>,
+    shown: Option<bool>,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+struct Applied {
+    origin: (f32, f32),
+    size: (i32, i32),
+    clip: [f32; 4],
+    scale: f32,
+}
+
+#[derive(Default)]
+struct Geometry {
+    /// Page bounds and their visible part, in physical pixels.
+    origin: (f32, f32),
+    size: (i32, i32),
+    clip: D2D_RECT_F,
+    scale: f32,
+}
+
+pub(super) struct Host {
+    hwnd: HWND,
+    tx: Sender,
+    /// Where pages are created (again, after the browser process exited).
+    data: BrowserData,
+    page: RefCell<Option<Page>>,
+    pending_url: RefCell<Option<String>>,
+    requested_url: RefCell<Option<String>>,
+    error: RefCell<Option<String>>,
+    loading: Cell<bool>,
+    changed_pending: Cell<bool>,
+    presentation: Cell<Presentation>,
+    geometry: RefCell<Geometry>,
+    has_area: Cell<bool>,
+    /// Pointer buttons pressed inside the page (forwarded until released).
+    pressed: Cell<u32>,
+    hovered: Cell<bool>,
+    shortcuts: RefCell<Vec<Keystroke>>,
+}
+
+pub(super) struct NativePage(Rc<Host>);
+
+impl NativePage {
+    pub fn new(window: &Window, data: &BrowserData, tx: Sender) -> Result<Self, String> {
+        use raw_window_handle::{HasWindowHandle, RawWindowHandle};
+        let hwnd = match HasWindowHandle::window_handle(window)
+            .map_err(|error| error.to_string())?
+            .as_raw()
+        {
+            RawWindowHandle::Win32(handle) => HWND(handle.hwnd.get() as *mut _),
+            _ => return Err("Browser requires a Win32 window".into()),
+        };
+        window
+            .enable_scene_overlay()
+            .map_err(|error| error.to_string())?;
+        let host = Rc::new(Host {
+            hwnd,
+            tx,
+            data: data.clone(),
+            page: RefCell::new(None),
+            pending_url: RefCell::new(None),
+            requested_url: RefCell::new(None),
+            error: RefCell::new(None),
+            loading: Cell::new(true),
+            changed_pending: Cell::new(false),
+            presentation: Cell::new(Presentation::Hidden),
+            geometry: RefCell::new(Geometry::default()),
+            has_area: Cell::new(false),
+            pressed: Cell::new(0),
+            hovered: Cell::new(false),
+            shortcuts: RefCell::new(Vec::new()),
+        });
+        Host::start(&host, data.clone());
+        Ok(Self(host))
+    }
+
+    pub fn handle(&self) -> Rc<Host> {
+        self.0.clone()
+    }
+
+    pub fn set_shortcuts(&self, shortcuts: Vec<String>) {
+        *self.0.shortcuts.borrow_mut() = shortcuts
+            .iter()
+            .filter_map(|s| Keystroke::parse(s).ok())
+            .collect();
+    }
+
+    pub fn present(&mut self, presentation: Presentation) {
+        self.0.presentation.set(presentation);
+        if presentation != Presentation::Live {
+            self.0.leave();
+        }
+        self.0.update_visibility();
+    }
+
+    pub fn load(&self, url: &str) -> Result<(), String> {
+        self.0.error.borrow_mut().take();
+        *self.0.requested_url.borrow_mut() = Some(url.into());
+        self.0.loading.set(true);
+        match &*self.0.page.borrow() {
+            Some(page) => unsafe { page.webview.Navigate(&HSTRING::from(url)) }
+                .map_err(|error| error.message()),
+            None => {
+                *self.0.pending_url.borrow_mut() = Some(url.into());
+                Ok(())
+            }
+        }
+    }
+
+    pub fn reload(&self) {
+        let failed = self.0.error.borrow_mut().take().is_some();
+        if failed && self.0.page.borrow().is_none() {
+            // Nothing is being created (that ends in a page or an error):
+            // start over, in a fresh environment if the old one died.
+            self.0.loading.set(true);
+            Host::start(&self.0, self.0.data.clone());
+        }
+        if let Some(page) = &*self.0.page.borrow() {
+            // Retrying the requested URL also works after a failed load.
+            let failed_url = self.0.requested_url.borrow().clone();
+            unsafe {
+                let _ = match failed_url {
+                    Some(url) if self.0.page_url().is_none() => {
+                        page.webview.Navigate(&HSTRING::from(url))
+                    }
+                    _ => page.webview.Reload(),
+                };
+            }
+        }
+        self.0.update_visibility();
+        self.0.changed();
+    }
+
+    pub fn history(&self, forward: bool) {
+        if let Some(page) = &*self.0.page.borrow() {
+            unsafe {
+                let _ = if forward {
+                    page.webview.GoForward()
+                } else {
+                    page.webview.GoBack()
+                };
+            }
+        }
+    }
+
+    pub fn state(&self) -> PageState {
+        let host = &self.0;
+        host.changed_pending.set(false);
+        let (title, can_back, can_forward) = match &*host.page.borrow() {
+            Some(page) => unsafe {
+                let mut title = PWSTR::null();
+                let mut back = windows::core::BOOL::default();
+                let mut forward = windows::core::BOOL::default();
+                let _ = page.webview.DocumentTitle(&mut title);
+                let _ = page.webview.CanGoBack(&mut back);
+                let _ = page.webview.CanGoForward(&mut forward);
+                (take_pwstr(title), back.as_bool(), forward.as_bool())
+            },
+            None => (String::new(), false, false),
+        };
+        PageState {
+            url: host
+                .requested_url
+                .borrow()
+                .clone()
+                .or_else(|| host.page_url()),
+            title,
+            loading: host.loading.get(),
+            can_back,
+            can_forward,
+            error: host.error.borrow().clone(),
+        }
+    }
+
+    pub fn discover_favicon(&self, page_url: String) {
+        if let Some(page) = &*self.0.page.borrow()
+            && let Ok(webview) = page.webview.cast::<ICoreWebView2_15>()
+        {
+            let mut uri = PWSTR::null();
+            if unsafe { webview.FaviconUri(&mut uri) }.is_ok() {
+                let url = take_pwstr(uri);
+                if !url.is_empty() {
+                    let _ = self.0.tx.try_send(NativeEvent::Favicon {
+                        page: page_url,
+                        url,
+                    });
+                }
+            }
+        }
+    }
+
+    /// Return the keyboard to GPUI chrome (the address bar).
+    pub fn focus_chrome(&self) {
+        use windows::Win32::UI::{
+            Input::KeyboardAndMouse::{GetFocus, SetFocus},
+            WindowsAndMessaging::IsChild,
+        };
+        unsafe {
+            let focus = GetFocus();
+            if !focus.is_invalid() && focus != self.0.hwnd && IsChild(self.0.hwnd, focus).as_bool()
+            {
+                let _ = SetFocus(Some(self.0.hwnd));
+            }
+        }
+    }
+
+    /// A press, release or move at `position` (window coordinates).
+    pub fn pointer(
+        &self,
+        kind: PointerKind,
+        position: Point<Pixels>,
+        button: Option<MouseButton>,
+        modifiers: Modifiers,
+        click_count: usize,
+    ) {
+        self.0
+            .pointer(kind, position, button, modifiers, click_count);
+    }
+
+    pub fn wheel(&self, position: Point<Pixels>, delta: Point<f32>, modifiers: Modifiers) {
+        self.0.wheel(position, delta, modifiers);
+    }
+
+    pub fn leave(&self) {
+        self.0.leave();
+    }
+
+    pub fn pressed(&self) -> bool {
+        self.0.pressed.get() != 0
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum PointerKind {
+    Down,
+    Up,
+    Move,
+}
+
+impl Host {
+    /// Create the page in `data`'s environment. A busy folder at any step
+    /// moves the window to its own folder and retries once.
+    fn start(host: &Rc<Self>, data: BrowserData) {
+        let weak = Rc::downgrade(host);
+        data.clone().with_environment(move |environment| {
+            let Some(host) = weak.upgrade() else { return };
+            match environment {
+                Ok(environment) => {
+                    if let Err(error) = Host::create_controller(&host, &environment, data) {
+                        host.fail(&runtime_error(&error));
+                    }
+                }
+                Err(error) => host.fail(&error),
+            }
+        });
+    }
+
+    fn create_controller(
+        host: &Rc<Self>,
+        environment: &ICoreWebView2Environment,
+        data: BrowserData,
+    ) -> windows::core::Result<()> {
+        let profile = HSTRING::from(data.profile());
+        let attach_environment = environment.clone();
+        let weak = Rc::downgrade(host);
+        let handler = CreateCoreWebView2CompositionControllerCompletedHandler::create(Box::new(
+            move |result, composition| {
+                let Some(host) = weak.upgrade() else {
+                    return Ok(());
+                };
+                match result.and_then(|()| composition.ok_or_else(windows::core::Error::empty)) {
+                    Ok(composition) => {
+                        if let Err(error) = Host::attach(&host, composition, &attach_environment) {
+                            host.fail(&runtime_error(&error));
+                        }
+                    }
+                    Err(error) if is_busy(&error) && data.fall_back() => Host::start(&host, data),
+                    Err(error) => host.fail(&runtime_error(&error)),
+                }
+                Ok(())
+            },
+        ));
+        // InPrivate in this window's own profile, or not at all: a runtime
+        // without controller options would persist cookies in the folder.
+        unsafe {
+            let environment = environment.cast::<ICoreWebView2Environment10>()?;
+            let options = environment.CreateCoreWebView2ControllerOptions()?;
+            options.SetIsInPrivateModeEnabled(true)?;
+            options.SetProfileName(&profile)?;
+            environment
+                .CreateCoreWebView2CompositionControllerWithOptions(host.hwnd, &options, &handler)
+        }
+    }
+
+    fn attach(
+        host: &Rc<Self>,
+        composition: ICoreWebView2CompositionController,
+        environment: &ICoreWebView2Environment,
+    ) -> windows::core::Result<()> {
+        let controller: ICoreWebView2Controller = composition.cast()?;
+        let webview = unsafe { controller.CoreWebView2()? };
+        unsafe {
+            let settings = webview.Settings()?;
+            settings.SetAreDevToolsEnabled(false)?;
+            // No page↔host channel exists; keep it that way.
+            settings.SetIsWebMessageEnabled(false)?;
+            settings.SetAreHostObjectsAllowed(false)?;
+            settings.SetIsStatusBarEnabled(false)?;
+            settings.SetIsZoomControlEnabled(true)?;
+            if let Ok(controller) = controller.cast::<ICoreWebView2Controller3>() {
+                // GPUI owns DPI: it re-syncs the scale with the bounds.
+                controller.SetShouldDetectMonitorScaleChanges(false)?;
+            }
+            controller.SetIsVisible(false)?;
+            let mut token = 0i64;
+            let weak = Rc::downgrade(host);
+            webview.add_NavigationStarting(
+                &NavigationStartingEventHandler::create(Box::new(move |_, args| {
+                    if let (Some(host), Some(args)) = (weak.upgrade(), args) {
+                        // Fail closed: an unreadable target is cancelled.
+                        let mut uri = PWSTR::null();
+                        let uri = args.Uri(&mut uri).map(|()| take_pwstr(uri));
+                        match uri {
+                            Ok(uri) if allowed_navigation(&uri) => {
+                                *host.requested_url.borrow_mut() = Some(uri);
+                                host.error.borrow_mut().take();
+                                host.loading.set(true);
+                                host.changed();
+                            }
+                            _ => args.SetCancel(true)?,
+                        }
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            // Subframes too (the main-frame event does not see them): web
+            // content only — their own documents (about:blank, srcdoc, data:,
+            // blob:) included — never a scheme that leaves the page.
+            webview.add_FrameNavigationStarting(
+                &NavigationStartingEventHandler::create(Box::new(move |_, args| {
+                    if let Some(args) = args {
+                        let mut uri = PWSTR::null();
+                        let allowed = args
+                            .Uri(&mut uri)
+                            .is_ok_and(|()| allowed_frame_navigation(&take_pwstr(uri)));
+                        if !allowed {
+                            args.SetCancel(true)?;
+                        }
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            // Never hand a page's link to another app (zeron://, ms-*, mailto:)
+            // from inside Zeron, prompt or not.
+            if let Ok(webview18) = webview.cast::<ICoreWebView2_18>() {
+                webview18.add_LaunchingExternalUriScheme(
+                    &LaunchingExternalUriSchemeEventHandler::create(Box::new(move |_, args| {
+                        if let Some(args) = args {
+                            args.SetCancel(true)?;
+                        }
+                        Ok(())
+                    })),
+                    &mut token,
+                )?;
+            }
+            // Camera, microphone, location, notifications, clipboard reads:
+            // nothing a preview needs, and no prompt that looks like Zeron's.
+            webview.add_PermissionRequested(
+                &PermissionRequestedEventHandler::create(Box::new(move |_, args| {
+                    if let Some(args) = args {
+                        args.SetState(COREWEBVIEW2_PERMISSION_STATE_DENY)?;
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            webview.add_SourceChanged(
+                &SourceChangedEventHandler::create(Box::new(move |_, _| {
+                    if let Some(host) = weak.upgrade() {
+                        host.requested_url.borrow_mut().take();
+                        host.changed();
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            webview.add_HistoryChanged(
+                &HistoryChangedEventHandler::create(Box::new(move |_, _| {
+                    if let Some(host) = weak.upgrade() {
+                        host.changed();
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            webview.add_DocumentTitleChanged(
+                &DocumentTitleChangedEventHandler::create(Box::new(move |_, _| {
+                    if let Some(host) = weak.upgrade() {
+                        host.changed();
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            webview.add_NavigationCompleted(
+                &NavigationCompletedEventHandler::create(Box::new(move |_, args| {
+                    let Some(host) = weak.upgrade() else {
+                        return Ok(());
+                    };
+                    host.loading.set(false);
+                    if let Some(args) = args {
+                        let mut success = windows::core::BOOL::default();
+                        args.IsSuccess(&mut success)?;
+                        if !success.as_bool() {
+                            let mut status = COREWEBVIEW2_WEB_ERROR_STATUS::default();
+                            args.WebErrorStatus(&mut status)?;
+                            if let Some(message) = navigation_error(status) {
+                                tracing::warn!(status = status.0, "browser navigation failed");
+                                *host.error.borrow_mut() = Some(message.into());
+                                host.update_visibility();
+                            }
+                        }
+                    }
+                    host.changed();
+                    let _ = host.tx.try_send(NativeEvent::Finished);
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            webview.add_NewWindowRequested(
+                &NewWindowRequestedEventHandler::create(Box::new(move |_, args| {
+                    if let (Some(host), Some(args)) = (weak.upgrade(), args) {
+                        // Handled first: no default popup window, whatever
+                        // fails below. Only a click opens a tab — WebView2
+                        // has no popup blocker, and each opened tab could
+                        // open more.
+                        args.SetHandled(true)?;
+                        let mut clicked = windows::core::BOOL::default();
+                        args.IsUserInitiated(&mut clicked)?;
+                        let mut uri = PWSTR::null();
+                        args.Uri(&mut uri)?;
+                        let uri = take_pwstr(uri);
+                        if clicked.as_bool() && allowed_navigation(&uri) {
+                            let _ = host.tx.try_send(NativeEvent::NewTab(uri));
+                        }
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            webview.add_ProcessFailed(
+                &ProcessFailedEventHandler::create(Box::new(move |_, args| {
+                    let (Some(host), Some(args)) = (weak.upgrade(), args) else {
+                        return Ok(());
+                    };
+                    let mut kind = COREWEBVIEW2_PROCESS_FAILED_KIND::default();
+                    args.ProcessFailedKind(&mut kind)?;
+                    match kind {
+                        // The whole environment is gone: every page of it
+                        // needs a new one, which Reload then creates.
+                        COREWEBVIEW2_PROCESS_FAILED_KIND_BROWSER_PROCESS_EXITED => {
+                            host.browser_exited();
+                        }
+                        // Reload recreates the renderer.
+                        COREWEBVIEW2_PROCESS_FAILED_KIND_RENDER_PROCESS_EXITED
+                        | COREWEBVIEW2_PROCESS_FAILED_KIND_RENDER_PROCESS_UNRESPONSIVE => {
+                            host.fail("The page stopped responding. Reload to continue.");
+                        }
+                        // GPU, utility and subframe processes are restarted
+                        // by WebView2; the page keeps working.
+                        kind => tracing::debug!(kind = kind.0, "browser helper process failed"),
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            if let Ok(webview4) = webview.cast::<ICoreWebView2_4>() {
+                let weak = Rc::downgrade(host);
+                webview4.add_DownloadStarting(
+                    &DownloadStartingEventHandler::create(Box::new(move |_, args| {
+                        let Some(args) = args else {
+                            return Ok(());
+                        };
+                        args.SetCancel(true)?;
+                        let mut uri = PWSTR::null();
+                        let uri = args
+                            .DownloadOperation()
+                            .and_then(|download| download.Uri(&mut uri))
+                            .map(|()| take_pwstr(uri))
+                            .unwrap_or_default();
+                        let Some(host) = weak.upgrade() else {
+                            return Ok(());
+                        };
+                        // Only a page that turned out to be a file is an error
+                        // (as on macOS); a download the page started leaves it
+                        // as it was.
+                        let requested = host.requested_url.borrow().clone();
+                        if requested.is_some_and(|requested| requested == uri) {
+                            host.fail(
+                                "This file can’t be previewed here. Open it in your default browser.",
+                            );
+                        } else {
+                            host.loading.set(false);
+                            host.changed();
+                        }
+                        Ok(())
+                    })),
+                    &mut token,
+                )?;
+            }
+            if let Ok(webview15) = webview.cast::<ICoreWebView2_15>() {
+                let weak = Rc::downgrade(host);
+                webview15.add_FaviconChanged(
+                    &FaviconChangedEventHandler::create(Box::new(move |sender, _| {
+                        let (Some(host), Some(sender)) = (weak.upgrade(), sender) else {
+                            return Ok(());
+                        };
+                        let mut uri = PWSTR::null();
+                        let mut source = PWSTR::null();
+                        if let Ok(sender) = sender.cast::<ICoreWebView2_15>() {
+                            sender.FaviconUri(&mut uri)?;
+                        }
+                        sender.Source(&mut source)?;
+                        let (url, page) = (take_pwstr(uri), take_pwstr(source));
+                        if !url.is_empty() {
+                            let _ = host.tx.try_send(NativeEvent::Favicon { page, url });
+                        }
+                        Ok(())
+                    })),
+                    &mut token,
+                )?;
+            }
+            let weak = Rc::downgrade(host);
+            composition.add_CursorChanged(
+                &CursorChangedEventHandler::create(Box::new(move |sender, _| {
+                    if let (Some(host), Some(sender)) = (weak.upgrade(), sender) {
+                        let mut id = 0u32;
+                        sender.SystemCursorId(&mut id)?;
+                        let _ = host.tx.try_send(NativeEvent::Cursor(cursor_style(id)));
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+            let weak = Rc::downgrade(host);
+            controller.add_AcceleratorKeyPressed(
+                &AcceleratorKeyPressedEventHandler::create(Box::new(move |_, args| {
+                    let (Some(host), Some(args)) = (weak.upgrade(), args) else {
+                        return Ok(());
+                    };
+                    let mut kind = COREWEBVIEW2_KEY_EVENT_KIND::default();
+                    args.KeyEventKind(&mut kind)?;
+                    if kind != COREWEBVIEW2_KEY_EVENT_KIND_KEY_DOWN
+                        && kind != COREWEBVIEW2_KEY_EVENT_KIND_SYSTEM_KEY_DOWN
+                    {
+                        return Ok(());
+                    }
+                    let mut key = 0u32;
+                    args.VirtualKey(&mut key)?;
+                    if let Some(keystroke) = accelerator(key)
+                        && host.claims(&keystroke)
+                        && host.tx.try_send(NativeEvent::Key(keystroke)).is_ok()
+                    {
+                        args.SetHandled(true)?;
+                    }
+                    Ok(())
+                })),
+                &mut token,
+            )?;
+        }
+        *host.page.borrow_mut() = Some(Page {
+            environment: environment.clone(),
+            composition,
+            controller,
+            webview,
+            visual: None,
+            mounted: false,
+            applied: None,
+            shown: None,
+        });
+        host.apply_geometry();
+        host.update_visibility();
+        if let Some(url) = host.pending_url.borrow_mut().take()
+            && let Some(page) = &*host.page.borrow()
+        {
+            unsafe {
+                let _ = page.webview.Navigate(&HSTRING::from(url));
+            }
+        }
+        host.changed();
+        Ok(())
+    }
+
+    fn page_url(&self) -> Option<String> {
+        let page = self.page.borrow();
+        let page = page.as_ref()?;
+        let mut source = PWSTR::null();
+        unsafe { page.webview.Source(&mut source) }.ok()?;
+        Some(take_pwstr(source)).filter(|url| !url.is_empty() && url != "about:blank")
+    }
+
+    fn changed(&self) {
+        if !self.changed_pending.replace(true) && self.tx.try_send(NativeEvent::Changed).is_err() {
+            self.changed_pending.set(false);
+        }
+    }
+
+    fn fail(&self, message: &str) {
+        *self.error.borrow_mut() = Some(message.into());
+        self.loading.set(false);
+        self.update_visibility();
+        self.changed();
+    }
+
+    /// The page's browser process exited: release the dead page and its
+    /// environment, and keep the URL so Reload rebuilds the page there.
+    fn browser_exited(&self) {
+        let url = self
+            .requested_url
+            .borrow()
+            .clone()
+            .or_else(|| self.page_url());
+        if let Some(page) = self.close_page() {
+            self.data.forget(&page.environment);
+        }
+        *self.pending_url.borrow_mut() = url;
+        self.fail("The browser stopped. Reload to continue.");
+    }
+
+    fn close_page(&self) -> Option<Page> {
+        let page = self.page.borrow_mut().take()?;
+        unsafe {
+            if let Some((visual, layer, _)) = &page.visual
+                && page.mounted
+            {
+                let _ = layer.RemoveVisual(visual);
+            }
+            let _ = page.controller.Close();
+        }
+        Some(page)
+    }
+
+    /// Browser and app shortcuts go to GPUI even while the page has focus.
+    fn claims(&self, keystroke: &Keystroke) -> bool {
+        let browser = [
+            "ctrl-l", "ctrl-t", "ctrl-w", "ctrl-[", "ctrl-]", "ctrl-k", "ctrl-,",
+        ]
+        .iter()
+        .any(|combo| Keystroke::parse(combo).is_ok_and(|k| &k == keystroke));
+        browser || self.shortcuts.borrow().iter().any(|k| k == keystroke)
+    }
+
+    /// Mount, position and clip the page for a painted frame. Runs from the
+    /// frame's presentation callback; the renderer commits it with the frame.
+    pub fn sync(
+        &self,
+        bounds: Bounds<Pixels>,
+        mask: Bounds<Pixels>,
+        scale: f32,
+        composition: Option<gpui::NativeComposition>,
+    ) {
+        let visible = bounds.intersect(&mask);
+        {
+            let mut geometry = self.geometry.borrow_mut();
+            let x = f32::from(bounds.origin.x) * scale;
+            let y = f32::from(bounds.origin.y) * scale;
+            geometry.origin = (x.round(), y.round());
+            geometry.size = (
+                (f32::from(bounds.size.width) * scale).round().max(0.) as i32,
+                (f32::from(bounds.size.height) * scale).round().max(0.) as i32,
+            );
+            geometry.clip = D2D_RECT_F {
+                left: (f32::from(visible.origin.x) * scale - x).max(0.),
+                top: (f32::from(visible.origin.y) * scale - y).max(0.),
+                right: (f32::from(visible.origin.x + visible.size.width) * scale - x).max(0.),
+                bottom: (f32::from(visible.origin.y + visible.size.height) * scale - y).max(0.),
+            };
+            geometry.scale = scale;
+        }
+        self.has_area
+            .set(f32::from(visible.size.width) > 0. && f32::from(visible.size.height) > 0.);
+        if let Some(composition) = composition {
+            self.remount(composition);
+        }
+        self.apply_geometry();
+        self.update_visibility();
+    }
+
+    /// (Re)create the page visual when the renderer's device generation
+    /// changes (first frame, or GPU recovery).
+    fn remount(&self, composition: gpui::NativeComposition) {
+        let mut page = self.page.borrow_mut();
+        let Some(page) = page.as_mut() else { return };
+        // Handles are only valid for their generation, and the renderer frees
+        // older ones; a callback carrying an older generation than the mounted
+        // one must not touch its pointers.
+        if page
+            .visual
+            .as_ref()
+            .is_some_and(|(_, _, generation)| *generation >= composition.generation)
+        {
+            return;
+        }
+        let mounted = unsafe {
+            let (Some(device), Some(layer)) = (
+                IDCompositionDevice::from_raw_borrowed(&composition.device),
+                IDCompositionVisual::from_raw_borrowed(&composition.layer),
+            ) else {
+                return;
+            };
+            device.CreateVisual().and_then(|visual| {
+                page.composition.SetRootVisualTarget(&visual)?;
+                Ok((visual, layer.clone()))
+            })
+        };
+        match mounted {
+            Ok((visual, layer)) => {
+                page.visual = Some((visual, layer, composition.generation));
+                page.mounted = false;
+                page.applied = None;
+            }
+            Err(error) => tracing::warn!(%error, "browser visual unavailable"),
+        }
+    }
+
+    fn apply_geometry(&self) {
+        let mut page = self.page.borrow_mut();
+        let Some(page) = page.as_mut() else { return };
+        let geometry = self.geometry.borrow();
+        let next = Applied {
+            origin: geometry.origin,
+            size: geometry.size,
+            clip: [
+                geometry.clip.left,
+                geometry.clip.top,
+                geometry.clip.right,
+                geometry.clip.bottom,
+            ],
+            scale: geometry.scale,
+        };
+        let previous = page.applied.replace(next);
+        if previous == Some(next) {
+            return;
+        }
+        unsafe {
+            if let Some((visual, _, _)) = &page.visual {
+                if previous.is_none_or(|p| p.origin != next.origin) {
+                    let _ = visual.SetOffsetX2(next.origin.0);
+                    let _ = visual.SetOffsetY2(next.origin.1);
+                }
+                if previous.is_none_or(|p| p.clip != next.clip) {
+                    let _ = visual.SetClip2(&geometry.clip);
+                }
+            }
+            if previous.is_none_or(|p| p.size != next.size) {
+                let _ = page.controller.SetBounds(RECT {
+                    left: 0,
+                    top: 0,
+                    right: next.size.0,
+                    bottom: next.size.1,
+                });
+            }
+            if next.scale > 0.
+                && previous.is_none_or(|p| p.scale != next.scale)
+                && let Ok(controller) = page.controller.cast::<ICoreWebView2Controller3>()
+            {
+                let _ = controller.SetRasterizationScale(f64::from(next.scale));
+            }
+        }
+    }
+
+    /// Visible pages render and mount; hidden ones unmount and let
+    /// Chromium throttle them (timers, painting) like a background tab.
+    fn update_visibility(&self) {
+        let visible = self.presentation.get() != Presentation::Hidden
+            && self.error.borrow().is_none()
+            && self.has_area.get();
+        let mut page = self.page.borrow_mut();
+        let Some(page) = page.as_mut() else { return };
+        unsafe {
+            if page.shown.replace(visible) != Some(visible) {
+                let _ = page.controller.SetIsVisible(visible);
+            }
+            if let Some((visual, layer, _)) = &page.visual
+                && page.mounted != visible
+            {
+                let _ = if visible {
+                    layer.AddVisual(visual, true, None::<&IDCompositionVisual>)
+                } else {
+                    layer.RemoveVisual(visual)
+                };
+                page.mounted = visible;
+            }
+        }
+        if !visible {
+            self.pressed.set(0);
+        }
+    }
+
+    fn local_point(&self, position: Point<Pixels>) -> POINT {
+        let geometry = self.geometry.borrow();
+        POINT {
+            x: (f32::from(position.x) * geometry.scale - geometry.origin.0).round() as i32,
+            y: (f32::from(position.y) * geometry.scale - geometry.origin.1).round() as i32,
+        }
+    }
+
+    fn pointer(
+        &self,
+        kind: PointerKind,
+        position: Point<Pixels>,
+        button: Option<MouseButton>,
+        modifiers: Modifiers,
+        click_count: usize,
+    ) {
+        let page = self.page.borrow();
+        let Some(page) = page.as_ref() else { return };
+        let bit = match button {
+            Some(MouseButton::Left) => 1,
+            Some(MouseButton::Right) => 2,
+            Some(MouseButton::Middle) => 4,
+            _ => 0,
+        };
+        let pressed = match kind {
+            PointerKind::Down => self.pressed.get() | bit,
+            PointerKind::Up => self.pressed.get() & !bit,
+            PointerKind::Move => self.pressed.get(),
+        };
+        let event = match (kind, button) {
+            (PointerKind::Move, _) => COREWEBVIEW2_MOUSE_EVENT_KIND_MOVE,
+            (PointerKind::Down, Some(MouseButton::Left)) if click_count % 2 == 0 => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOUBLE_CLICK
+            }
+            (PointerKind::Down, Some(MouseButton::Left)) => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOWN
+            }
+            (PointerKind::Up, Some(MouseButton::Left)) => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_UP
+            }
+            (PointerKind::Down, Some(MouseButton::Right)) => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_DOWN
+            }
+            (PointerKind::Up, Some(MouseButton::Right)) => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_UP
+            }
+            (PointerKind::Down, Some(MouseButton::Middle)) => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_DOWN
+            }
+            (PointerKind::Up, Some(MouseButton::Middle)) => {
+                COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_UP
+            }
+            _ => return,
+        };
+        self.pressed.set(pressed);
+        self.hovered.set(true);
+        unsafe {
+            let _ = page.composition.SendMouseInput(
+                event,
+                virtual_keys(pressed, modifiers),
+                0,
+                self.local_point(position),
+            );
+            if kind == PointerKind::Down {
+                let _ = page
+                    .controller
+                    .MoveFocus(COREWEBVIEW2_MOVE_FOCUS_REASON_PROGRAMMATIC);
+            }
+        }
+    }
+
+    /// GPUI line deltas use WHEEL_DELTA per three lines; precise (pixel)
+    /// deltas map 100 px to one notch, matching Chromium's own scaling.
+    fn wheel(&self, position: Point<Pixels>, delta: Point<f32>, modifiers: Modifiers) {
+        let page = self.page.borrow();
+        let Some(page) = page.as_ref() else { return };
+        let point = self.local_point(position);
+        let keys = virtual_keys(self.pressed.get(), modifiers);
+        unsafe {
+            if delta.y != 0. {
+                let _ = page.composition.SendMouseInput(
+                    COREWEBVIEW2_MOUSE_EVENT_KIND_WHEEL,
+                    keys,
+                    (delta.y.round() as i32) as u32,
+                    point,
+                );
+            }
+            if delta.x != 0. {
+                let _ = page.composition.SendMouseInput(
+                    COREWEBVIEW2_MOUSE_EVENT_KIND_HORIZONTAL_WHEEL,
+                    keys,
+                    (-(delta.x.round()) as i32) as u32,
+                    point,
+                );
+            }
+        }
+    }
+
+    fn leave(&self) {
+        if !self.hovered.replace(false) {
+            return;
+        }
+        if let Some(page) = &*self.page.borrow() {
+            unsafe {
+                let _ = page.composition.SendMouseInput(
+                    COREWEBVIEW2_MOUSE_EVENT_KIND_LEAVE,
+                    COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE,
+                    0,
+                    POINT::default(),
+                );
+            }
+        }
+    }
+}
+
+impl Drop for Host {
+    fn drop(&mut self) {
+        self.close_page();
+    }
+}
+
+/// Wheel units: GPUI lines (3 per notch) or pixels (100 per notch).
+pub(super) fn wheel_units(delta: gpui::ScrollDelta) -> Point<f32> {
+    const WHEEL_DELTA: f32 = 120.;
+    match delta {
+        gpui::ScrollDelta::Lines(lines) => {
+            gpui::point(lines.x * WHEEL_DELTA / 3., lines.y * WHEEL_DELTA / 3.)
+        }
+        gpui::ScrollDelta::Pixels(pixels) => gpui::point(
+            f32::from(pixels.x) * WHEEL_DELTA / 100.,
+            f32::from(pixels.y) * WHEEL_DELTA / 100.,
+        ),
+    }
+}
+
+fn virtual_keys(pressed: u32, modifiers: Modifiers) -> COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS {
+    let mut keys = COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE.0;
+    if pressed & 1 != 0 {
+        keys |= COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_LEFT_BUTTON.0;
+    }
+    if pressed & 2 != 0 {
+        keys |= COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_RIGHT_BUTTON.0;
+    }
+    if pressed & 4 != 0 {
+        keys |= COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_MIDDLE_BUTTON.0;
+    }
+    if modifiers.shift {
+        keys |= COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_SHIFT.0;
+    }
+    if modifiers.control {
+        keys |= COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_CONTROL.0;
+    }
+    COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS(keys)
+}
+
+/// User-facing copy for a failed main-frame navigation; cancellations
+/// (a newer navigation, a blocked scheme) are silent.
+fn navigation_error(status: COREWEBVIEW2_WEB_ERROR_STATUS) -> Option<&'static str> {
+    match status {
+        COREWEBVIEW2_WEB_ERROR_STATUS_OPERATION_CANCELED => None,
+        COREWEBVIEW2_WEB_ERROR_STATUS_CONNECTION_ABORTED
+        | COREWEBVIEW2_WEB_ERROR_STATUS_CONNECTION_RESET
+        | COREWEBVIEW2_WEB_ERROR_STATUS_DISCONNECTED => {
+            Some("The connection was interrupted. Try loading this page again.")
+        }
+        _ => Some("Check the address and make sure your server is running, then try again."),
+    }
+}
+
+/// Windows system cursor ids (`IDC_*`) as GPUI cursor styles.
+fn cursor_style(id: u32) -> CursorStyle {
+    match id {
+        32513 => CursorStyle::IBeam,
+        32515 => CursorStyle::Crosshair,
+        32642 => CursorStyle::ResizeUpLeftDownRight,
+        32643 => CursorStyle::ResizeUpRightDownLeft,
+        32644 => CursorStyle::ResizeLeftRight,
+        32645 => CursorStyle::ResizeUpDown,
+        32648 => CursorStyle::OperationNotAllowed,
+        32649 => CursorStyle::PointingHand,
+        _ => CursorStyle::Arrow,
+    }
+}
+
+/// The GPUI keystroke for a key-down the page received, when it is one an
+/// app shortcut could use (a modifier other than Shift, or a function key).
+fn accelerator(key: u32) -> Option<Keystroke> {
+    let down = |vk: VIRTUAL_KEY| unsafe { GetKeyState(i32::from(vk.0)) } < 0;
+    let control = down(VK_CONTROL);
+    let alt = down(VK_MENU);
+    let platform = down(VK_LWIN) || down(VK_RWIN);
+    let shift = down(VK_SHIFT);
+    let name = match key {
+        0x30..=0x39 | 0x41..=0x5A => char::from_u32(key)?.to_ascii_lowercase().to_string(),
+        0x70..=0x7B => format!("f{}", key - 0x6F),
+        0x09 => "tab".into(),
+        0xBC => ",".into(),
+        0xBE => ".".into(),
+        0xBF => "/".into(),
+        0xDB => "[".into(),
+        0xDD => "]".into(),
+        0xBA => ";".into(),
+        0xDE => "'".into(),
+        0xC0 => "`".into(),
+        0xBD => "-".into(),
+        0xBB => "=".into(),
+        0xDC => "\\".into(),
+        _ => return None,
+    };
+    if !(control || alt || platform || matches!(key, 0x70..=0x7B)) {
+        return None;
+    }
+    let mut combo = String::new();
+    for (held, prefix) in [
+        (control, "ctrl-"),
+        (alt, "alt-"),
+        (platform, "win-"),
+        (shift, "shift-"),
+    ] {
+        if held {
+            combo.push_str(prefix);
+        }
+    }
+    combo.push_str(&name);
+    Keystroke::parse(&combo).ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn wheel_units_match_win32_notches() {
+        let lines = wheel_units(gpui::ScrollDelta::Lines(gpui::point(0., 3.)));
+        assert_eq!(lines.y, 120.);
+        let pixels = wheel_units(gpui::ScrollDelta::Pixels(gpui::point(
+            gpui::px(-50.),
+            gpui::px(100.),
+        )));
+        assert_eq!((pixels.x, pixels.y), (-60., 120.));
+    }
+
+    #[test]
+    fn cursors_and_errors_map_to_gpui_and_copy() {
+        assert_eq!(cursor_style(32649), CursorStyle::PointingHand);
+        assert_eq!(cursor_style(32513), CursorStyle::IBeam);
+        assert_eq!(cursor_style(1), CursorStyle::Arrow);
+        assert!(navigation_error(COREWEBVIEW2_WEB_ERROR_STATUS_OPERATION_CANCELED).is_none());
+        assert!(
+            navigation_error(COREWEBVIEW2_WEB_ERROR_STATUS_CANNOT_CONNECT)
+                .unwrap()
+                .contains("server")
+        );
+    }
+
+    #[test]
+    fn virtual_keys_carry_buttons_and_modifiers() {
+        let keys = virtual_keys(
+            1 | 4,
+            Modifiers {
+                shift: true,
+                ..Default::default()
+            },
+        );
+        assert_eq!(
+            keys.0,
+            COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_LEFT_BUTTON.0
+                | COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_MIDDLE_BUTTON.0
+                | COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_SHIFT.0
+        );
+    }
+}
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index 24b76c82e4..e72a6cf4e5 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -9747,6 +9747,24 @@ impl Composer {
         let Some(question) = wizard.current().cloned() else {
             return gpui::Empty.into_any_element();
         };
+        // The answer borrows the composer's editor, but the composer's own
+        // sizing does not run while the panel shows. Without a limit of its
+        // own the editor kept a stale one-line viewport, so new lines painted
+        // below the card instead of growing it. Grow up to the composer's cap.
+        let answer_cap = TEXTAREA_MAX - TEXTAREA_PAD_V;
+        self.input.update(cx, |input, cx| {
+            if input.viewport_height != Some(answer_cap)
+                || input.settled_viewport_height != Some(answer_cap)
+                || input.resizing
+                || input.overflow_top_padding != 0.0
+            {
+                input.viewport_height = Some(answer_cap);
+                input.settled_viewport_height = Some(answer_cap);
+                input.resizing = false;
+                input.overflow_top_padding = 0.0;
+                cx.notify();
+            }
+        });
         let page = wizard.page;
         let last = page + 1 >= wizard.questions.len();
         let typed_empty = self.input.read(cx).is_empty();
diff --git a/crates/ui/src/image_media.rs b/crates/ui/src/image_media.rs
index 7f862be142..dc8b08543f 100644
--- a/crates/ui/src/image_media.rs
+++ b/crates/ui/src/image_media.rs
@@ -254,6 +254,16 @@ pub(crate) fn decode_raster_image(bytes: Vec<u8>, max_bytes: usize) -> Result<Me
     decode_raster_image_bounded(bytes, max_bytes, None)
 }
 
+/// Decoder bounds for every raster preview: 4096 px per side, 64 MiB of
+/// decoder allocation.
+pub(crate) fn raster_limits() -> image::Limits {
+    let mut limits = image::Limits::default();
+    limits.max_image_width = Some(4096);
+    limits.max_image_height = Some(4096);
+    limits.max_alloc = Some(64 * 1024 * 1024);
+    limits
+}
+
 fn decode_raster_image_bounded(
     bytes: Vec<u8>,
     max_bytes: usize,
@@ -265,11 +275,7 @@ fn decode_raster_image_bounded(
     let mut reader = image::ImageReader::new(Cursor::new(bytes))
         .with_guessed_format()
         .map_err(|e| e.to_string())?;
-    let mut limits = image::Limits::default();
-    limits.max_image_width = Some(4096);
-    limits.max_image_height = Some(4096);
-    limits.max_alloc = Some(64 * 1024 * 1024);
-    reader.limits(limits);
+    reader.limits(raster_limits());
     // Decode one frame and encode a static PNG so GPUI cannot expand unbounded animation frames.
     let decoded = reader.decode().map_err(|e| e.to_string())?;
     // Generated previews retain one bounded 8-bit frame. This keeps each
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index 218eeccb7f..ad81f2eaf7 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -63,6 +63,7 @@ pub(crate) mod surface_chrome;
 pub mod syntax_cache;
 pub mod terminal;
 mod todo_panel;
+pub(crate) mod tool_images;
 pub mod theme;
 pub mod theme_library;
 pub mod transcript;
diff --git a/crates/ui/src/markdown/render.rs b/crates/ui/src/markdown/render.rs
index ceb642fa21..e3d07d3009 100644
--- a/crates/ui/src/markdown/render.rs
+++ b/crates/ui/src/markdown/render.rs
@@ -1407,7 +1407,7 @@ pub(crate) fn selectable_text_wrap() -> Div {
     div().relative().cursor(CursorStyle::IBeam)
 }
 
-fn selectable_text_element(
+pub(crate) fn selectable_text_element(
     key: std::sync::Arc<str>,
     text: SharedString,
     runs: Vec<TextRun>,
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index c2eb984c81..d8d1a83def 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -3595,7 +3595,7 @@ impl Shell {
                 LinkAction::External
             };
         }
-        let outcome = resolved.web_outcome(cfg!(any(target_os = "macos", target_os = "linux")));
+        let outcome = resolved.web_outcome(cfg!(any(target_os = "macos", target_os = "linux", windows)));
         if outcome == LinkOutcome::Internal {
             self.set_surfaces_open(true, cx);
             self.add_browser_surface(activation.target.navigation.clone().ok(), window, cx);
@@ -12729,7 +12729,7 @@ impl Render for Shell {
         } else {
             px(0.0)
         };
-        #[cfg(target_os = "macos")]
+        #[cfg(any(target_os = "macos", windows))]
         let browser_overlay_width = px(if self.files_visible_width(cx) > 0.0 {
             self.files_visible_width(cx) + PANE_RESIZE_HITBOX_HALF_WIDTH
         } else {
@@ -12743,10 +12743,9 @@ impl Render for Shell {
             );
             browser.update(cx, |browser, cx| {
                 #[cfg(target_os = "macos")]
-                {
-                    browser.set_resize_inset(browser_resize_inset, cx);
-                    browser.set_right_occlusion(browser_overlay_width, cx);
-                }
+                browser.set_resize_inset(browser_resize_inset, cx);
+                #[cfg(any(target_os = "macos", windows))]
+                browser.set_right_occlusion(browser_overlay_width, cx);
                 browser.set_shortcuts(&self.settings.keymap);
                 browser.set_presentation(presentation, cx);
             });
@@ -17055,6 +17054,9 @@ impl Shell {
         self.transcript
             .update(cx, |t, cx| t.fixture_appshots_start(cx));
     }
+    pub fn fixture_transcript(&self) -> Entity<crate::transcript::Transcript> {
+        self.transcript.clone()
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ui/src/tool_images.rs b/crates/ui/src/tool_images.rs
new file mode 100644
index 0000000000..a51f07a0fc
--- /dev/null
+++ b/crates/ui/src/tool_images.rs
@@ -0,0 +1,902 @@
+//! Image previews inside expanded tool chips: files a tool read, wrote or
+//! printed. Pixels exist only while their chip is expanded. Opening reads the
+//! file from the agent's device and decodes a bounded BGRA thumbnail off the
+//! UI thread (handed straight to GPUI — no PNG re-encode, no asset cache).
+//! Collapsing starts a short grace; when it lapses the CPU frame and the GPU
+//! atlas tiles are released. Rapid toggling inside the grace reuses the
+//! texture instead of re-reading and re-decoding the file.
+
+use std::{
+    collections::HashMap,
+    io::Cursor,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use gpui::{Context, RenderImage, SharedString, Task};
+use zeron_proto::ToolCall;
+
+use crate::state::EngineHandle;
+
+/// Previews per chip; further paths stay in the text output.
+pub(crate) const MAX_IMAGES_PER_TOOL: usize = 4;
+/// Decoded thumbnail bounds: the 560×220 frame at 2× density (≤ 1.9 MiB
+/// BGRA per copy).
+const THUMB_MAX: (u32, u32) = (1120, 440);
+/// Collapsed chips keep pixels this long, so open/close spam never re-decodes.
+pub(crate) const RELEASE_GRACE: Duration = Duration::from_millis(600);
+/// Expanded-but-offscreen previews may be dropped past this (CPU + GPU bytes).
+const BUDGET_BYTES: usize = 64 * 1024 * 1024;
+/// Only previews unpainted this long count as offscreen. List overdraw paints
+/// rows beyond the viewport, so a frame-based rule evicted visible previews
+/// and re-decoded them in a loop once the painted set outgrew the budget.
+const STALE_AFTER: Duration = Duration::from_secs(2);
+
+const IMAGE_EXTENSIONS: [&str; 9] = [
+    "png", "jpg", "jpeg", "gif", "webp", "bmp", "svg", "tif", "tiff",
+];
+
+pub(crate) fn is_image_path(path: &str) -> bool {
+    let name = path.rsplit(['/', '\\']).next().unwrap_or(path);
+    name.rsplit_once('.').is_some_and(|(stem, ext)| {
+        !stem.is_empty() && IMAGE_EXTENSIONS.iter().any(|e| ext.eq_ignore_ascii_case(e))
+    })
+}
+
+/// UNC (`\\host\share`, `//host/share`), device and verbatim (`\\.\`,
+/// `\\?\`, `\??\`) and drive-relative (`C:x.png`) forms. Agent output names
+/// them freely, and merely opening one can reach another host (on Windows
+/// with the user's NTLM credentials), so they are never previewed. The
+/// engine's jail refuses them as well.
+fn is_remote_or_device_path(path: &str) -> bool {
+    let bytes = path.as_bytes();
+    let separator = |b: Option<&u8>| matches!(b, Some(b'/' | b'\\'));
+    (separator(bytes.first()) && separator(bytes.get(1)))
+        || path.starts_with(r"\??\")
+        || (bytes.len() >= 2
+            && bytes[0].is_ascii_alphabetic()
+            && bytes[1] == b':'
+            && !separator(bytes.get(2)))
+}
+
+fn push_path(out: &mut Vec<SharedString>, path: &str) {
+    if out.len() < MAX_IMAGES_PER_TOOL
+        && is_image_path(path)
+        && !is_remote_or_device_path(path)
+        && !out.iter().any(|known| known.as_ref() == path)
+    {
+        out.push(SharedString::from(path.to_owned()));
+    }
+}
+
+/// Image-looking local paths in free text (commands, output, JSON strings).
+/// URLs and glob patterns are skipped; trailing sentence punctuation is not
+/// part of a path.
+fn push_text_paths(out: &mut Vec<SharedString>, text: &str) {
+    let separators = |c: char| {
+        c.is_whitespace()
+            || matches!(
+                c,
+                '"' | '\''
+                    | '`'
+                    | '<'
+                    | '>'
+                    | '('
+                    | ')'
+                    | '['
+                    | ']'
+                    | '{'
+                    | '}'
+                    | ','
+                    | ';'
+                    | '|'
+                    | '='
+            )
+    };
+    for token in text.split(separators) {
+        if out.len() >= MAX_IMAGES_PER_TOOL {
+            return;
+        }
+        let token = token.trim_end_matches(['.', ':', '!', '?']);
+        let token = token.strip_prefix("file://").unwrap_or(token);
+        if token.contains("://") || token.starts_with("data:") || token.contains(['*', '?']) {
+            continue;
+        }
+        push_path(out, token);
+    }
+}
+
+fn push_json_paths(out: &mut Vec<SharedString>, value: &serde_json::Value) {
+    match value {
+        serde_json::Value::String(text) => push_text_paths(out, text),
+        serde_json::Value::Array(items) => items.iter().for_each(|v| push_json_paths(out, v)),
+        serde_json::Value::Object(map) => map.values().for_each(|v| push_json_paths(out, v)),
+        _ => {}
+    }
+}
+
+/// The image files a tool call touched, as reported (possibly relative to the
+/// chat's working directory). Computed once per row build, never per paint.
+pub(crate) fn image_paths(call: &ToolCall, output: Option<&str>) -> Arc<[SharedString]> {
+    let mut out = Vec::new();
+    match call {
+        ToolCall::ReadFile { path }
+        | ToolCall::WriteFile { path, .. }
+        | ToolCall::EditFile { path, .. }
+        | ToolCall::ApplyPatch { path: Some(path) } => push_path(&mut out, path),
+        ToolCall::Exec { command } => push_text_paths(&mut out, command),
+        ToolCall::Mcp {
+            input: Some(input), ..
+        }
+        | ToolCall::Unknown {
+            input: Some(input), ..
+        } => push_json_paths(&mut out, input),
+        _ => {}
+    }
+    if let Some(output) = output {
+        push_text_paths(&mut out, output);
+    }
+    out.into()
+}
+
+/// Absolute path on the owning host. Relative paths join the chat's cwd in
+/// that host's separator style (the UI may run on another OS).
+pub(crate) fn resolve_path(path: &str, cwd: Option<&str>) -> String {
+    let bytes = path.as_bytes();
+    let absolute = path.starts_with(['/', '\\'])
+        || (bytes.len() >= 3
+            && bytes[0].is_ascii_alphabetic()
+            && bytes[1] == b':'
+            && matches!(bytes[2], b'/' | b'\\'));
+    match cwd.filter(|_| !absolute) {
+        Some(cwd) if cwd.contains('\\') => format!(
+            "{}\\{}",
+            cwd.trim_end_matches(['/', '\\']),
+            path.trim_start_matches("./").replace('/', "\\")
+        ),
+        Some(cwd) => format!(
+            "{}/{}",
+            cwd.trim_end_matches('/'),
+            path.trim_start_matches("./")
+        ),
+        None => path.to_owned(),
+    }
+}
+
+/// One file on one device.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct ImageKey {
+    pub device: String,
+    pub path: String,
+}
+
+/// What a frame paints for one key.
+#[derive(Clone)]
+pub(crate) enum Thumb {
+    Loading,
+    Ready {
+        image: Arc<RenderImage>,
+        aspect: f32,
+    },
+    Failed,
+}
+
+enum State {
+    /// The read/decode task; dropping it cancels the load.
+    Loading(#[allow(dead_code)] Task<()>),
+    Ready {
+        image: Arc<RenderImage>,
+        aspect: f32,
+        bytes: usize,
+        painted: Instant,
+    },
+    Failed,
+}
+
+struct Entry {
+    state: State,
+    /// Set while no expanded chip holds the key.
+    release_at: Option<Instant>,
+}
+
+/// Where loads go: the engine and this device's id (remote owners relay).
+pub(crate) struct Loader {
+    pub engine: Option<EngineHandle>,
+    pub local_device: Option<String>,
+}
+
+#[derive(Default)]
+pub(crate) struct ToolImages {
+    entries: HashMap<ImageKey, Entry>,
+    /// Expanded chip (`{row}#d{ix}`) → the keys it shows.
+    holders: HashMap<SharedString, Vec<ImageKey>>,
+    bytes: usize,
+    sweeper: Option<Task<()>>,
+}
+
+impl ToolImages {
+    pub(crate) fn is_idle(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn retained_bytes(&self) -> usize {
+        self.bytes
+    }
+
+    #[cfg(feature = "appshots-fixture")]
+    pub(crate) fn stats(&self) -> (usize, usize) {
+        (self.entries.len(), self.bytes)
+    }
+
+    /// An expanded chip shows `keys`: cancel their release and start any
+    /// missing loads. Returns one thumb per key.
+    pub(crate) fn hold<V: 'static>(
+        &mut self,
+        chip: &SharedString,
+        keys: Vec<ImageKey>,
+        loader: &Loader,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) -> Vec<Thumb> {
+        let now = cx.background_executor().now();
+        let thumbs = keys
+            .iter()
+            .map(|key| {
+                if !self.entries.contains_key(key) {
+                    self.start_load(key.clone(), loader, get, cx);
+                }
+                let entry = self.entries.get_mut(key).expect("inserted above");
+                entry.release_at = None;
+                match &mut entry.state {
+                    State::Loading(_) => Thumb::Loading,
+                    State::Ready {
+                        image,
+                        aspect,
+                        painted,
+                        ..
+                    } => {
+                        *painted = now;
+                        Thumb::Ready {
+                            image: image.clone(),
+                            aspect: *aspect,
+                        }
+                    }
+                    State::Failed => Thumb::Failed,
+                }
+            })
+            .collect();
+        if self.holders.get(chip) != Some(&keys) {
+            // Keys that dropped out of the chip (its output changed) start the
+            // grace like a collapse; ones it still shows stay held.
+            if let Some(previous) = self.holders.insert(chip.clone(), keys) {
+                self.start_grace(previous, get, cx);
+            }
+        }
+        thumbs
+    }
+
+    /// The chip collapsed (or left the transcript): its keys start the grace.
+    pub(crate) fn release<V: 'static>(
+        &mut self,
+        chip: &SharedString,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) {
+        let Some(keys) = self.holders.remove(chip) else {
+            return;
+        };
+        self.start_grace(keys, get, cx);
+    }
+
+    /// Keys no expanded chip holds any more start the release grace.
+    fn start_grace<V: 'static>(
+        &mut self,
+        keys: Vec<ImageKey>,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) {
+        let at = cx.background_executor().now() + RELEASE_GRACE;
+        for key in keys {
+            if self.holders.values().any(|held| held.contains(&key)) {
+                continue;
+            }
+            if let Some(entry) = self.entries.get_mut(&key) {
+                entry.release_at = Some(at);
+            }
+        }
+        self.schedule_sweep(get, cx);
+    }
+
+    /// Release every chip of a row whose body is hidden.
+    pub(crate) fn release_row<V: 'static>(
+        &mut self,
+        row: &str,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) {
+        if self.holders.is_empty() {
+            return;
+        }
+        let chips: Vec<SharedString> = self
+            .holders
+            .keys()
+            .filter(|chip| chip_row(chip) == row)
+            .cloned()
+            .collect();
+        for chip in chips {
+            self.release(&chip, get, cx);
+        }
+    }
+
+    /// Release chips whose row left the transcript (compact folds, resets).
+    pub(crate) fn retain_rows<V: 'static>(
+        &mut self,
+        live: impl Fn(&str) -> bool,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) {
+        if self.holders.is_empty() {
+            return;
+        }
+        let gone: Vec<SharedString> = self
+            .holders
+            .keys()
+            .filter(|chip| !live(chip_row(chip)))
+            .cloned()
+            .collect();
+        for chip in gone {
+            self.release(&chip, get, cx);
+        }
+    }
+
+    /// Drop everything now (chat switch).
+    pub(crate) fn clear(&mut self, cx: &mut gpui::App) {
+        self.holders.clear();
+        self.sweeper = None;
+        let released: Vec<_> = self.entries.drain().map(|(_, e)| e.state).collect();
+        self.bytes = 0;
+        free(released, cx);
+    }
+
+    fn start_load<V: 'static>(
+        &mut self,
+        key: ImageKey,
+        loader: &Loader,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) {
+        let Some(engine) = loader.engine.clone() else {
+            self.entries.insert(
+                key,
+                Entry {
+                    state: State::Failed,
+                    release_at: None,
+                },
+            );
+            return;
+        };
+        let target = (loader.local_device.as_deref() != Some(key.device.as_str()))
+            .then(|| key.device.clone());
+        let task_key = key.clone();
+        let task = cx.spawn(async move |view, cx| {
+            let executor = cx.background_executor().clone();
+            let raw = crate::attachments::read_attachment_bytes(
+                &engine,
+                &executor,
+                target.as_deref(),
+                &task_key.path,
+                None,
+            )
+            .await;
+            let decoded = match raw {
+                Some((_, mime, bytes)) => {
+                    executor
+                        .spawn(async move { decode_thumbnail(&mime, bytes) })
+                        .await
+                }
+                None => None,
+            };
+            view.update(cx, |view, cx| {
+                get(view).finish(task_key, decoded, cx);
+                cx.notify();
+            })
+            .ok();
+        });
+        self.entries.insert(
+            key,
+            Entry {
+                state: State::Loading(task),
+                release_at: None,
+            },
+        );
+    }
+
+    fn finish(
+        &mut self,
+        key: ImageKey,
+        decoded: Option<(Arc<RenderImage>, f32)>,
+        cx: &mut gpui::App,
+    ) {
+        // Released while loading: the result is simply dropped (never uploaded).
+        let Some(entry) = self.entries.get_mut(&key) else {
+            return;
+        };
+        if !matches!(entry.state, State::Loading(_)) {
+            return;
+        }
+        entry.state = match decoded {
+            Some((image, aspect)) => {
+                let bytes = retained_bytes(&image);
+                self.bytes += bytes;
+                State::Ready {
+                    image,
+                    aspect,
+                    bytes,
+                    painted: cx.background_executor().now(),
+                }
+            }
+            None => State::Failed,
+        };
+        tracing::debug!(path = %key.path, retained = self.bytes, "tool image decoded");
+        self.enforce_budget(&key, cx);
+    }
+
+    /// Over budget: drop the least recently painted offscreen previews. The
+    /// painted set itself may exceed the budget; it is never evicted. A held
+    /// preview reloads when it is painted again.
+    fn enforce_budget(&mut self, keep: &ImageKey, cx: &mut gpui::App) {
+        let mut released = Vec::new();
+        let Some(stale) = cx.background_executor().now().checked_sub(STALE_AFTER) else {
+            return;
+        };
+        while self.bytes > BUDGET_BYTES {
+            let oldest = self
+                .entries
+                .iter()
+                .filter_map(|(key, entry)| match entry.state {
+                    State::Ready { painted, .. } if key != keep && painted < stale => {
+                        Some((painted, key.clone()))
+                    }
+                    _ => None,
+                })
+                .min_by_key(|(painted, _)| *painted);
+            let Some((_, key)) = oldest else { break };
+            if let Some(entry) = self.entries.remove(&key) {
+                self.bytes -= state_bytes(&entry.state);
+                released.push(entry.state);
+            }
+        }
+        free(released, cx);
+    }
+
+    fn sweep(&mut self, cx: &mut gpui::App) {
+        let now = cx.background_executor().now();
+        let expired: Vec<ImageKey> = self
+            .entries
+            .iter()
+            .filter(|(_, entry)| entry.release_at.is_some_and(|at| at <= now))
+            .map(|(key, _)| key.clone())
+            .collect();
+        let mut released = Vec::with_capacity(expired.len());
+        for key in expired {
+            if let Some(entry) = self.entries.remove(&key) {
+                self.bytes -= state_bytes(&entry.state);
+                released.push(entry.state);
+            }
+        }
+        if !released.is_empty() {
+            tracing::debug!(
+                released = released.len(),
+                retained = self.bytes,
+                "tool images released"
+            );
+        }
+        free(released, cx);
+    }
+
+    /// One timer for the earliest pending release. Grace is constant, so a
+    /// later release never precedes the one already scheduled.
+    fn schedule_sweep<V: 'static>(
+        &mut self,
+        get: fn(&mut V) -> &mut ToolImages,
+        cx: &mut Context<V>,
+    ) {
+        if self.sweeper.is_some() {
+            return;
+        }
+        let Some(at) = self.entries.values().filter_map(|e| e.release_at).min() else {
+            return;
+        };
+        let delay = at.saturating_duration_since(cx.background_executor().now());
+        self.sweeper = Some(cx.spawn(async move |view, cx| {
+            cx.background_executor().timer(delay).await;
+            view.update(cx, |view, cx| {
+                let images = get(view);
+                images.sweeper = None;
+                images.sweep(cx);
+                images.schedule_sweep(get, cx);
+            })
+            .ok();
+        }));
+    }
+}
+
+fn chip_row(chip: &str) -> &str {
+    chip.rsplit_once("#d").map_or(chip, |(row, _)| row)
+}
+
+fn retained_bytes(image: &RenderImage) -> usize {
+    // GPUI keeps the CPU frame for atlas re-uploads plus the GPU copy.
+    image.as_bytes(0).map_or(0, |b| b.len() * 2)
+}
+
+fn state_bytes(state: &State) -> usize {
+    match state {
+        State::Ready { bytes, .. } => *bytes,
+        _ => 0,
+    }
+}
+
+/// Free released pixels: dropping a Loading task cancels its read; a Ready
+/// image leaves every window's sprite atlas once the current update ends.
+fn free(states: Vec<State>, cx: &mut gpui::App) {
+    let images: Vec<Arc<RenderImage>> = states
+        .into_iter()
+        .filter_map(|state| match state {
+            State::Ready { image, .. } => Some(image),
+            _ => None,
+        })
+        .collect();
+    if !images.is_empty() {
+        cx.defer(move |cx| {
+            for image in images {
+                cx.drop_image(image, None);
+            }
+        });
+    }
+}
+
+/// Decode one static frame and downsample to [`THUMB_MAX`], as BGRA.
+fn decode_thumbnail(mime: &str, bytes: Vec<u8>) -> Option<(Arc<RenderImage>, f32)> {
+    if mime == "image/svg+xml" {
+        let media = crate::image_media::decode_image(mime, bytes).ok()?;
+        let image = media
+            .image
+            .to_image_data(gpui::SvgRenderer::new(Arc::new(crate::icons::Assets)))
+            .ok()?;
+        return Some((image, media.width / media.height.max(1.0)));
+    }
+    let mut reader = image::ImageReader::new(Cursor::new(bytes))
+        .with_guessed_format()
+        .ok()?;
+    // Shared preview bounds: several chips may decode at once.
+    reader.limits(crate::image_media::raster_limits());
+    let decoded = reader.decode().ok()?;
+    let (width, height) = (decoded.width(), decoded.height());
+    if width == 0 || height == 0 {
+        return None;
+    }
+    let decoded = if width > THUMB_MAX.0 || height > THUMB_MAX.1 {
+        decoded.thumbnail(THUMB_MAX.0, THUMB_MAX.1)
+    } else {
+        decoded
+    };
+    let mut pixels = decoded.into_rgba8();
+    for pixel in pixels.chunks_exact_mut(4) {
+        pixel.swap(0, 2);
+    }
+    Some((
+        Arc::new(RenderImage::new(vec![image::Frame::new(pixels)])),
+        width as f32 / height as f32,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::AppContext as _;
+
+    fn paths(call: ToolCall, output: Option<&str>) -> Vec<String> {
+        image_paths(&call, output)
+            .iter()
+            .map(|p| p.to_string())
+            .collect()
+    }
+
+    #[test]
+    fn finds_images_in_paths_commands_output_and_json() {
+        assert_eq!(
+            paths(
+                ToolCall::ReadFile {
+                    path: "shots/A.PNG".into()
+                },
+                None
+            ),
+            ["shots/A.PNG"]
+        );
+        assert!(
+            paths(
+                ToolCall::ReadFile {
+                    path: "src/main.rs".into()
+                },
+                None
+            )
+            .is_empty()
+        );
+        assert_eq!(
+            paths(
+                ToolCall::Exec {
+                    command: "python plot.py --out=chart.png".into()
+                },
+                Some("Saved to /tmp/x/chart.png.\nsee https://a.b/c.png and **/*.jpg")
+            ),
+            ["chart.png", "/tmp/x/chart.png"]
+        );
+        assert_eq!(
+            paths(
+                ToolCall::Mcp {
+                    server: "browser".into(),
+                    tool: "screenshot".into(),
+                    input: Some(serde_json::json!({"opts": {"file": r"C:\shots\home.webp"}}))
+                },
+                None
+            ),
+            [r"C:\shots\home.webp"]
+        );
+        let many = (0..9).map(|i| format!("{i}.jpg ")).collect::<String>();
+        assert_eq!(
+            paths(ToolCall::Exec { command: many }, None).len(),
+            MAX_IMAGES_PER_TOOL
+        );
+    }
+
+    #[test]
+    fn relative_paths_join_the_owning_hosts_cwd() {
+        assert_eq!(resolve_path("a/b.png", Some("/w")), "/w/a/b.png");
+        assert_eq!(resolve_path("./b.png", Some("/w/")), "/w/b.png");
+        assert_eq!(resolve_path("a/b.png", Some(r"C:\w")), r"C:\w\a\b.png");
+        assert_eq!(resolve_path(r"D:\x.png", Some(r"C:\w")), r"D:\x.png");
+        assert_eq!(resolve_path("/x.png", Some("/w")), "/x.png");
+        assert_eq!(resolve_path("x.png", None), "x.png");
+        assert_eq!(resolve_path("C:x.png", Some("/w")), "/w/C:x.png");
+    }
+
+    #[test]
+    fn network_device_and_drive_relative_paths_are_never_previewed() {
+        let output = [
+            r"\\attacker\share\a.png",
+            "//attacker/share/b.png",
+            r"\/attacker\share\c.png",
+            "file:////attacker/share/d.png",
+            r"\\?\UNC\attacker\share\e.png",
+            r"\\?\C:\shots\f.png",
+            r"\\.\pipe\g.png",
+            r"\??\UNC\attacker\share\h.png",
+            "C:i.png",
+        ]
+        .join("\n");
+        let found = paths(
+            ToolCall::Exec {
+                command: "open ok.png".into(),
+            },
+            Some(&output),
+        );
+        assert_eq!(found, ["ok.png"]);
+        assert!(
+            paths(
+                ToolCall::ReadFile {
+                    path: r"\\attacker\share\a.png".into()
+                },
+                None
+            )
+            .is_empty()
+        );
+        // Ordinary absolute paths in both styles still preview.
+        assert_eq!(
+            paths(
+                ToolCall::Exec {
+                    command: r"cp /tmp/a.png C:\shots\b.png D:/c.png".into()
+                },
+                None
+            ),
+            ["/tmp/a.png", r"C:\shots\b.png", "D:/c.png"]
+        );
+    }
+
+    #[test]
+    fn thumbnails_are_bounded_bgra() {
+        let mut png = Cursor::new(Vec::new());
+        image::RgbaImage::from_pixel(4000, 1000, image::Rgba([255, 0, 0, 255]))
+            .write_to(&mut png, image::ImageFormat::Png)
+            .unwrap();
+        let (image, aspect) = decode_thumbnail("image/png", png.into_inner()).unwrap();
+        let size = image.size(0);
+        assert!(size.width.0 as u32 <= THUMB_MAX.0 && size.height.0 as u32 <= THUMB_MAX.1);
+        assert_eq!(aspect, 4.0);
+        // Red in RGBA is [0, 0, 255, 255] in BGRA.
+        assert_eq!(&image.as_bytes(0).unwrap()[..4], &[0, 0, 255, 255]);
+        assert!(decode_thumbnail("image/png", b"nope".to_vec()).is_none());
+        // Past the shared decoder bounds: refused, never fully allocated.
+        let mut wide = Cursor::new(Vec::new());
+        image::GrayImage::new(4097, 1)
+            .write_to(&mut wide, image::ImageFormat::Png)
+            .unwrap();
+        assert!(decode_thumbnail("image/png", wide.into_inner()).is_none());
+    }
+
+    struct Host {
+        images: ToolImages,
+    }
+
+    fn get(host: &mut Host) -> &mut ToolImages {
+        &mut host.images
+    }
+
+    #[gpui::test]
+    fn collapse_spam_keeps_pixels_and_settled_collapse_frees_them(cx: &mut gpui::TestAppContext) {
+        let host = cx.new(|_| Host {
+            images: ToolImages::default(),
+        });
+        let key = ImageKey {
+            device: "d".into(),
+            path: "/w/a.png".into(),
+        };
+        let chip = SharedString::from("row#d0");
+        let loader = Loader {
+            engine: None,
+            local_device: None,
+        };
+        host.update(cx, |host, cx| {
+            let mut pixels = image::RgbaImage::new(100, 50);
+            pixels.fill(1);
+            host.images.entries.insert(
+                key.clone(),
+                Entry {
+                    state: State::Loading(Task::ready(())),
+                    release_at: None,
+                },
+            );
+            host.images.finish(
+                key.clone(),
+                Some((
+                    Arc::new(RenderImage::new(vec![image::Frame::new(pixels)])),
+                    2.0,
+                )),
+                cx,
+            );
+            assert_eq!(host.images.retained_bytes(), 100 * 50 * 4 * 2);
+            // Spam: every reopen inside the grace reuses the same texture.
+            for _ in 0..50 {
+                let thumbs = host.images.hold(&chip, vec![key.clone()], &loader, get, cx);
+                assert!(matches!(thumbs[0], Thumb::Ready { aspect: 2.0, .. }));
+                host.images.release(&chip, get, cx);
+            }
+            assert!(!host.images.is_idle());
+        });
+        cx.executor().advance_clock(RELEASE_GRACE / 2);
+        cx.run_until_parked();
+        host.update(cx, |host, _| assert!(!host.images.is_idle()));
+        cx.executor().advance_clock(RELEASE_GRACE);
+        cx.run_until_parked();
+        host.update(cx, |host, _| {
+            assert!(host.images.is_idle(), "collapsed previews are freed");
+            assert_eq!(host.images.retained_bytes(), 0);
+        });
+        // A failed load (no engine) is retried after collapse + grace.
+        host.update(cx, |host, cx| {
+            let thumbs = host.images.hold(&chip, vec![key.clone()], &loader, get, cx);
+            assert!(matches!(thumbs[0], Thumb::Failed));
+            host.images.release(&chip, get, cx);
+        });
+        cx.executor().advance_clock(RELEASE_GRACE * 2);
+        cx.run_until_parked();
+        host.update(cx, |host, _| assert!(host.images.is_idle()));
+    }
+
+    #[gpui::test]
+    fn shared_keys_stay_while_another_chip_holds_them_and_rows_release(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let host = cx.new(|_| Host {
+            images: ToolImages::default(),
+        });
+        let key = ImageKey {
+            device: "d".into(),
+            path: "/w/a.png".into(),
+        };
+        let loader = Loader {
+            engine: None,
+            local_device: None,
+        };
+        host.update(cx, |host, cx| {
+            host.images
+                .hold(&"r1#d0".into(), vec![key.clone()], &loader, get, cx);
+            host.images
+                .hold(&"r2#d3".into(), vec![key.clone()], &loader, get, cx);
+            host.images.release(&"r1#d0".into(), get, cx);
+            assert!(host.images.entries[&key].release_at.is_none());
+            host.images.retain_rows(|row| row == "r1", get, cx);
+            assert!(host.images.entries[&key].release_at.is_some());
+            host.images
+                .hold(&"r2#d3".into(), vec![key.clone()], &loader, get, cx);
+            host.images.release_row("r2", get, cx);
+            assert!(host.images.holders.is_empty());
+        });
+        cx.executor().advance_clock(RELEASE_GRACE * 2);
+        cx.run_until_parked();
+        host.update(cx, |host, _| assert!(host.images.is_idle()));
+    }
+
+    #[gpui::test]
+    fn keys_dropped_from_a_held_chip_are_released(cx: &mut gpui::TestAppContext) {
+        let host = cx.new(|_| Host {
+            images: ToolImages::default(),
+        });
+        let key = |path: &str| ImageKey {
+            device: "d".into(),
+            path: path.into(),
+        };
+        let (a, b) = (key("/w/a.png"), key("/w/b.png"));
+        let chip = SharedString::from("row#d0");
+        let loader = Loader {
+            engine: None,
+            local_device: None,
+        };
+        host.update(cx, |host, cx| {
+            host.images
+                .hold(&chip, vec![a.clone(), b.clone()], &loader, get, cx);
+            // The chip's output changed while expanded: `a` is gone from it.
+            host.images.hold(&chip, vec![b.clone()], &loader, get, cx);
+            assert!(host.images.entries[&a].release_at.is_some());
+            assert!(host.images.entries[&b].release_at.is_none());
+        });
+        cx.executor().advance_clock(RELEASE_GRACE * 2);
+        cx.run_until_parked();
+        host.update(cx, |host, _| {
+            assert!(!host.images.entries.contains_key(&a));
+            assert!(host.images.entries.contains_key(&b));
+        });
+    }
+
+    #[gpui::test]
+    fn budget_drops_only_previews_unpainted_for_a_while(cx: &mut gpui::TestAppContext) {
+        let host = cx.new(|_| Host {
+            images: ToolImages::default(),
+        });
+        let insert = |host: &mut Host, i: usize, cx: &mut Context<Host>| {
+            let key = ImageKey {
+                device: "d".into(),
+                path: format!("/{i}.png"),
+            };
+            host.images.entries.insert(
+                key.clone(),
+                Entry {
+                    state: State::Loading(Task::ready(())),
+                    release_at: None,
+                },
+            );
+            // 2048² BGRA = 16 MiB CPU + 16 MiB GPU per preview.
+            let image =
+                RenderImage::new(vec![image::Frame::new(image::RgbaImage::new(2048, 2048))]);
+            host.images.finish(key, Some((Arc::new(image), 1.0)), cx);
+        };
+        host.update(cx, |host, cx| {
+            for i in 0..3 {
+                insert(host, i, cx);
+            }
+            // Recently painted previews survive even past the budget.
+            assert_eq!(host.images.entries.len(), 3);
+            assert!(host.images.retained_bytes() > BUDGET_BYTES);
+        });
+        cx.executor().advance_clock(STALE_AFTER * 2);
+        host.update(cx, |host, cx| {
+            insert(host, 3, cx);
+            assert!(host.images.retained_bytes() <= BUDGET_BYTES);
+            assert!(host.images.entries.contains_key(&ImageKey {
+                device: "d".into(),
+                path: "/3.png".into(),
+            }));
+        });
+    }
+}
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index 2e0f37ea0e..15f46a3fd4 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -380,6 +380,9 @@ pub struct ToolItem {
     /// is the `detail`; `resolved == false` means it is still streaming (the
     /// chip then defaults open).
     pub kind: ToolItemKind,
+    /// Image files the call read, wrote or printed (as reported; relative
+    /// paths resolve against the chat cwd). Expanding the chip previews them.
+    pub images: Arc<[SharedString]>,
 }
 
 /// Subagent spawn chips — [`ToolCall::is_subagent_spawn`], the shared genus
@@ -729,6 +732,7 @@ fn thought_item(part_id: &str, tree: &BlockTree, live: bool) -> ToolItem {
         subagent_status: None,
         subagent_tail: None,
         kind: ToolItemKind::Thought,
+        images: Arc::new([]),
     }
 }
 
@@ -827,10 +831,7 @@ pub fn tool_detail(
         });
     }
     let output = output?;
-    let mut lines: Vec<SharedString> = output
-        .lines()
-        .map(|l| SharedString::from(l.to_owned()))
-        .collect();
+    let mut lines: Vec<SharedString> = output.lines().map(output_line).collect();
     // Trim trailing blank output lines so the block hugs its content.
     while lines.last().is_some_and(|l| l.trim().is_empty()) {
         lines.pop();
@@ -846,6 +847,18 @@ pub fn tool_detail(
     })
 }
 
+/// Chars kept per output line. Lines clip rather than wrap, but each one is
+/// still shaped whole for selection — a minified megabyte must not be.
+const OUTPUT_LINE_MAX_CHARS: usize = 8 * 1024;
+
+/// One verbatim output line, cut to [`OUTPUT_LINE_MAX_CHARS`] with an ellipsis.
+fn output_line(line: &str) -> SharedString {
+    match line.char_indices().nth(OUTPUT_LINE_MAX_CHARS) {
+        Some((cut, _)) => SharedString::from(format!("{}…", &line[..cut])),
+        None => SharedString::from(line.to_owned()),
+    }
+}
+
 /// Columns at which an invocation line soft-wraps into continuation lines.
 /// The wrap is char-counted, not measured — block heights must be analytic —
 /// so the budget is sized to fit the narrowest useful transcript pane.
@@ -1143,6 +1156,7 @@ fn tool_fingerprint(tools: &[ToolItem], auto_open: bool) -> u64 {
         // Thought/note chips share `ToolCall::Unknown` — the kind is the
         // label/icon discriminator, so a flip must re-splice.
         acc.push(t.kind as u8);
+        acc.push(t.images.len() as u8);
         // Detail payload arriving (or growing) must re-splice the row even
         // when the resolved bit didn't change.
         match t.detail.as_deref() {
@@ -1465,6 +1479,7 @@ pub fn rows_for_entry(
                     subagent_status: *subagent_status,
                     subagent_tail: subagent_tail.clone().map(SharedString::from),
                     kind: ToolItemKind::Call,
+                    images: crate::tool_images::image_paths(call, output.as_deref()),
                 };
                 if compact {
                     // Compact mode keeps ONE group for the whole turn —
@@ -2158,6 +2173,26 @@ pub fn detail_height(detail: &ToolDetail) -> f32 {
     DETAIL_SEPARATOR + body
 }
 
+/// Tool image preview frame height; widths follow each image's aspect.
+const TOOL_IMAGE_HEIGHT: f32 = 220.0;
+const TOOL_IMAGE_MAX_WIDTH: f32 = 560.0;
+const TOOL_IMAGE_PAD: f32 = 8.0;
+/// Analytic height an open chip's image strip adds (separator + frames).
+const TOOL_IMAGE_STRIP_HEIGHT: f32 = DETAIL_SEPARATOR + TOOL_IMAGE_HEIGHT + 2.0 * TOOL_IMAGE_PAD;
+
+/// The open image context menu: what to copy and where it lives.
+struct ImageMenu {
+    path: String,
+    devices: Vec<String>,
+    position: Point<Pixels>,
+    active: Option<usize>,
+}
+
+/// Spawn chips never expand, so they never preview images either.
+fn chip_has_images(tool: &ToolItem) -> bool {
+    !tool.images.is_empty() && !is_spawn_link(tool)
+}
+
 /// Height of the "Show full output/diff" affordance row appended below an
 /// open detail whose full payload lives in the sidecar (chat2-sync A3).
 pub const BLOB_AFFORDANCE_HEIGHT: f32 = 24.0;
@@ -2183,10 +2218,7 @@ fn blob_detail(text: &str, is_diff: bool) -> Option<ToolDetail> {
         let diff: zeron_proto::ToolDiff = serde_json::from_str(text).ok()?;
         return tool_detail(None, Some(&diff), None);
     }
-    let mut lines: Vec<SharedString> = text
-        .lines()
-        .map(|l| SharedString::from(l.to_owned()))
-        .collect();
+    let mut lines: Vec<SharedString> = text.lines().map(output_line).collect();
     while lines.last().is_some_and(|l| l.trim().is_empty()) {
         lines.pop();
     }
@@ -3295,6 +3327,12 @@ pub struct Transcript {
     /// Prepared diagram shown in the lightbox: its natural size frames the
     /// enlarged raster, which is released when the lightbox closes.
     diagram_zoom: Option<crate::image_media::MediaImage>,
+    /// Expanded tool chips' image previews; freed shortly after collapse.
+    tool_images: crate::tool_images::ToolImages,
+    /// Right-click menu over any transcript image (Copy path / Copy image).
+    image_menu: crate::popover::Popup<ImageMenu>,
+    image_menu_focus: gpui::FocusHandle,
+    image_copy: Option<Task<()>>,
     /// In-flight ReadAttachmentChunk loads, keyed by device, path and validation
     /// policy; results land in the global attachment cache.
     attachment_loads: HashMap<crate::attachments::AttachmentKey, Task<()>>,
@@ -3473,6 +3511,7 @@ impl Transcript {
         cx.on_release(|this: &mut Self, cx| {
             this.close_diagram_zoom(cx);
             crate::image_media::release_media(this.diagrams.borrow_mut().drain(), cx);
+            this.tool_images.clear(cx);
         })
         .detach();
         let text_changes = cx.subscribe(
@@ -3579,6 +3618,10 @@ impl Transcript {
             diagram_media: None,
             diagram_worker: None,
             diagram_zoom: None,
+            tool_images: Default::default(),
+            image_menu: Default::default(),
+            image_menu_focus: cx.focus_handle(),
+            image_copy: None,
             attachment_loads: HashMap::new(),
             attachment_retries: HashMap::new(),
             blob_details: HashMap::new(),
@@ -4644,6 +4687,7 @@ impl Transcript {
             }
             self.chat_id = selected;
             self.rows.clear();
+            self.tool_images.clear(cx);
             self.row_cache.clear();
             self.live_parsers.clear();
             self.tree_cache.clear();
@@ -5011,6 +5055,7 @@ impl Transcript {
             None => {
                 self.rows = new_rows;
                 self.refresh_protected_attachments(cx);
+                self.release_departed_tool_images(cx);
                 self.reconcile_own_turn_prompt();
                 // Replay readiness is independent of row content: an empty
                 // reset (or one identical to optimistic rows) still resolves
@@ -5063,6 +5108,7 @@ impl Transcript {
             }
         }
         self.refresh_protected_attachments(cx);
+        self.release_departed_tool_images(cx);
         self.reconcile_own_turn_prompt();
         self.restore_pending_viewport(replay);
         self.promote_materialized_queued_turn(attached, cx);
@@ -5792,6 +5838,351 @@ impl Transcript {
         overlays
     }
 
+    // ---- tool-call image previews + the image context menu ----
+
+    fn tool_images_of(this: &mut Self) -> &mut crate::tool_images::ToolImages {
+        &mut this.tool_images
+    }
+
+    /// The chat whose agent produced these rows (a subagent tab borrows the
+    /// selected chat's host and cwd).
+    fn image_host(&self, cx: &gpui::App) -> (Option<String>, Option<String>) {
+        let state = self.state.read(cx);
+        let chat = self
+            .chat_id
+            .as_deref()
+            .and_then(|id| state.chats.iter().find(|chat| chat.id == id))
+            .or_else(|| state.selected_chat_row());
+        (
+            chat.map(|chat| chat.device_id.clone()),
+            chat.and_then(|chat| chat.cwd.clone()),
+        )
+    }
+
+    /// Hold the previews of every chip whose body is mounted; release the
+    /// rest. Returns `(absolute path, thumb)` lists per chip index.
+    fn hold_tool_images(
+        &mut self,
+        row_id: &SharedString,
+        tools: &[ToolItem],
+        opens: &[bool],
+        folds: &[FoldState],
+        cx: &mut Context<Self>,
+    ) -> Vec<Option<Vec<(String, crate::tool_images::Thumb)>>> {
+        if !tools.iter().any(chip_has_images) {
+            return vec![None; tools.len()];
+        }
+        let (device, cwd) = self.image_host(cx);
+        let loader = crate::tool_images::Loader {
+            engine: self.state.read(cx).engine().cloned(),
+            local_device: self.state.read(cx).local_device_id.clone(),
+        };
+        tools
+            .iter()
+            .enumerate()
+            .map(|(ix, tool)| {
+                if !chip_has_images(tool) {
+                    return None;
+                }
+                let chip = SharedString::from(format!("{row_id}#d{ix}"));
+                let tweening = folds[ix].epoch > 0
+                    && folds[ix]
+                        .toggled_at
+                        .is_some_and(|at| at.elapsed() < FOLD_TWEEN_WINDOW);
+                if !opens[ix] && !tweening {
+                    self.tool_images.release(&chip, Self::tool_images_of, cx);
+                    return None;
+                }
+                let keys: Vec<_> = tool
+                    .images
+                    .iter()
+                    .map(|path| crate::tool_images::ImageKey {
+                        device: device.clone().unwrap_or_default(),
+                        path: crate::tool_images::resolve_path(path, cwd.as_deref()),
+                    })
+                    .collect();
+                let paths: Vec<String> = keys.iter().map(|key| key.path.clone()).collect();
+                let loader = if device.is_some() {
+                    &loader
+                } else {
+                    &crate::tool_images::Loader {
+                        engine: None,
+                        local_device: None,
+                    }
+                };
+                let thumbs = self
+                    .tool_images
+                    .hold(&chip, keys, loader, Self::tool_images_of, cx);
+                Some(paths.into_iter().zip(thumbs).collect())
+            })
+            .collect()
+    }
+
+    /// Rows left the transcript (compact fold settled, history rebuilt):
+    /// their chips' previews start the release grace.
+    fn release_departed_tool_images(&mut self, cx: &mut Context<Self>) {
+        if self.tool_images.is_idle() {
+            return;
+        }
+        let live: HashSet<&str> = self
+            .rows
+            .iter()
+            .filter(|row| matches!(row.kind, RowKind::ToolGroup { .. }))
+            .map(|row| row.id.as_ref())
+            .collect();
+        self.tool_images
+            .retain_rows(|row| live.contains(row), Self::tool_images_of, cx);
+    }
+
+    fn render_tool_image_strip(
+        &self,
+        chip: &SharedString,
+        images: Vec<(String, crate::tool_images::Thumb)>,
+        collapses: bool,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        use crate::tool_images::Thumb;
+        let devices: Rc<[String]> = self.image_host(cx).0.into_iter().collect();
+        let frames = images.into_iter().enumerate().map(|(ix, (path, thumb))| {
+            let name = SharedString::from(file_badge_name(&path).to_owned());
+            let width = match &thumb {
+                Thumb::Ready { aspect, .. } => {
+                    (TOOL_IMAGE_HEIGHT * aspect).clamp(48.0, TOOL_IMAGE_MAX_WIDTH)
+                }
+                _ => TOOL_IMAGE_HEIGHT * 4.0 / 3.0,
+            };
+            let menu_devices = devices.clone();
+            let frame = div()
+                .id(SharedString::from(format!("{chip}-img{ix}")))
+                .w(px(width))
+                .h(px(TOOL_IMAGE_HEIGHT))
+                .flex_none()
+                .flex()
+                .items_center()
+                .justify_center()
+                .rounded(px(8.0))
+                .overflow_hidden()
+                .border_1()
+                .border_color(crate::theme::hairline(0.07))
+                .bg(crate::theme::ink(0.035))
+                .aria_label(name.clone())
+                .on_mouse_down(
+                    gpui::MouseButton::Right,
+                    cx.listener(move |this, event: &gpui::MouseDownEvent, window, cx| {
+                        cx.stop_propagation();
+                        this.open_image_menu(
+                            path.clone(),
+                            menu_devices.to_vec(),
+                            event.position,
+                            window,
+                            cx,
+                        );
+                    }),
+                );
+            match thumb {
+                // Explicit dims: img layout honors intrinsic aspect over a
+                // percent height (see the attachment strip).
+                Thumb::Ready { image, .. } => frame.child(
+                    img(image)
+                        .w(px(width - 2.0))
+                        .h(px(TOOL_IMAGE_HEIGHT - 2.0))
+                        .rounded(px(7.0))
+                        .object_fit(ObjectFit::Contain),
+                ),
+                Thumb::Loading => frame
+                    .text_size(px(TOOL_TEXT_SIZE))
+                    .text_color(theme.text_faint)
+                    .child("Loading image…"),
+                Thumb::Failed => frame
+                    .flex_col()
+                    .gap(px(4.0))
+                    .px(px(12.0))
+                    .text_size(px(TOOL_TEXT_SIZE))
+                    .text_color(theme.text_faint)
+                    .child("Image unavailable")
+                    .child(div().max_w_full().truncate().child(name)),
+            }
+        });
+        div()
+            .h(px(TOOL_IMAGE_STRIP_HEIGHT))
+            .flex_none()
+            .flex()
+            .flex_col()
+            .child(
+                div()
+                    .h(px(DETAIL_SEPARATOR))
+                    .flex_none()
+                    .when(!collapses, |line| line.bg(crate::theme::hairline(0.06))),
+            )
+            .child(
+                div()
+                    .id(SharedString::from(format!("{chip}-images")))
+                    .h(px(TOOL_IMAGE_HEIGHT + 2.0 * TOOL_IMAGE_PAD))
+                    .py(px(TOOL_IMAGE_PAD))
+                    .when(!collapses, |strip| strip.px(px(TOOL_IMAGE_PAD)))
+                    .flex()
+                    .flex_row()
+                    .gap(px(TOOL_IMAGE_PAD))
+                    .overflow_x_scroll()
+                    .children(frames),
+            )
+            .into_any_element()
+    }
+
+    /// Open the image menu at the pointer. `devices` are the candidate owners
+    /// of `path`, tried in order when copying the image.
+    fn open_image_menu(
+        &mut self,
+        path: String,
+        devices: Vec<String>,
+        position: Point<Pixels>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.image_menu.open(ImageMenu {
+            path,
+            devices,
+            position,
+            active: None,
+        });
+        window.focus(&self.image_menu_focus, cx);
+        cx.notify();
+    }
+
+    fn close_image_menu(&mut self, cx: &mut Context<Self>) {
+        if self.image_menu.begin_close() {
+            crate::popover::reap_popup(cx, |this: &mut Self| &mut this.image_menu);
+            cx.notify();
+        }
+    }
+
+    fn image_menu_key(&mut self, event: &gpui::KeyDownEvent, cx: &mut Context<Self>) {
+        use crate::popover::MenuKey;
+        let Some(menu) = self.image_menu.open_mut() else {
+            return;
+        };
+        match crate::popover::classify_key(
+            &event.keystroke.key,
+            event.keystroke.modifiers.platform,
+            event.keystroke.modifiers.control,
+        ) {
+            MenuKey::Escape => self.close_image_menu(cx),
+            MenuKey::Up => menu.active = crate::popover::menu_step(menu.active, 2, -1),
+            MenuKey::Down => menu.active = crate::popover::menu_step(menu.active, 2, 1),
+            MenuKey::Enter => {
+                if let Some(action) = menu.active {
+                    self.dispatch_image_menu(action, cx);
+                }
+            }
+            _ => return,
+        }
+        cx.stop_propagation();
+        cx.notify();
+    }
+
+    fn dispatch_image_menu(&mut self, action: usize, cx: &mut Context<Self>) {
+        let Some(menu) = self.image_menu.as_open() else {
+            return;
+        };
+        let (path, devices) = (menu.path.clone(), menu.devices.clone());
+        self.close_image_menu(cx);
+        match action {
+            0 => cx.write_to_clipboard(gpui::ClipboardItem::new_string(path)),
+            1 => self.copy_image(path, devices, cx),
+            _ => {}
+        }
+    }
+
+    /// Copy the original file (not the preview) from its owning device.
+    fn copy_image(&mut self, path: String, devices: Vec<String>, cx: &mut Context<Self>) {
+        let Some(engine) = self.state.read(cx).engine().cloned() else {
+            return;
+        };
+        let local = self.state.read(cx).local_device_id.clone();
+        self.image_copy = Some(cx.spawn(async move |this, cx| {
+            let executor = cx.background_executor().clone();
+            for device in &devices {
+                let target = (local.as_deref() != Some(device.as_str())).then_some(device.as_str());
+                if let Some((_, mime, bytes)) = crate::attachments::read_attachment_bytes(
+                    &engine, &executor, target, &path, None,
+                )
+                .await
+                {
+                    let format =
+                        gpui::ImageFormat::from_mime_type(&mime).unwrap_or(gpui::ImageFormat::Png);
+                    // SVG is markup an agent may have written: copy the parsed,
+                    // re-serialized tree (no scripts or external resources),
+                    // as previews render it.
+                    let bytes = if format == gpui::ImageFormat::Svg {
+                        let svg = executor.spawn(async move {
+                            usvg::Tree::from_data(&bytes, &crate::image_media::svg_options())
+                                .map(|tree| tree.to_string(&usvg::WriteOptions::default()))
+                        });
+                        let Ok(svg) = svg.await else {
+                            return;
+                        };
+                        svg.into_bytes()
+                    } else {
+                        bytes
+                    };
+                    let image = gpui::Image::from_bytes(format, bytes);
+                    this.update(cx, |this, cx| {
+                        cx.write_to_clipboard(gpui::ClipboardItem::new_image(&image));
+                        this.image_copy = None;
+                    })
+                    .ok();
+                    return;
+                }
+            }
+        }));
+    }
+
+    fn render_image_menu(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
+        let menu = self.image_menu.get()?;
+        let theme = Theme::of(cx).for_popup();
+        let mut card = crate::popover::popover_card(&theme)
+            .id("transcript-image-menu-card")
+            .track_focus(&self.image_menu_focus)
+            .role(gpui::Role::Menu)
+            .w(px(190.0))
+            .flex()
+            .flex_col()
+            .on_key_down(cx.listener(|this, event, _, cx| this.image_menu_key(event, cx)))
+            .on_mouse_down_out(cx.listener(|this, _, _, cx| this.close_image_menu(cx)))
+            .on_mouse_down(gpui::MouseButton::Left, |_, _, cx| cx.stop_propagation());
+        for (index, (label, icon)) in [
+            ("Copy path", crate::icons::COPY),
+            ("Copy image", crate::icons::FILE_IMAGE),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let id = SharedString::from(format!("transcript-image-menu-{index}"));
+            card = card.child(
+                crate::popover::menu_row(&theme, menu.active == Some(index), id.clone())
+                    .id(id)
+                    .role(gpui::Role::MenuItem)
+                    .aria_label(label)
+                    .on_click(
+                        cx.listener(move |this, _, _, cx| this.dispatch_image_menu(index, cx)),
+                    )
+                    .child(
+                        crate::icons::icon(icon)
+                            .size(px(16.0))
+                            .text_color(theme.text_muted),
+                    )
+                    .child(label),
+            );
+        }
+        Some(crate::popover::menu_at(
+            "transcript-image-menu",
+            menu.position,
+            card.into_any_element(),
+            self.image_menu.closing_since(),
+        ))
+    }
+
     /// The inside of a user bubble: the prompt text, clipped to
     /// [`USER_COLLAPSED_LINES`] until expanded, plus the expander chevron for
     /// prompts past the cap. Returns the bubble's children in order.
@@ -6211,7 +6602,21 @@ impl Transcript {
                     .min(1.0);
                 let preview =
                     crate::attachments::PreviewImage::new(name.to_owned(), loaded.image.clone());
+                let menu_path = path.to_owned();
                 frame
+                    .on_mouse_down(
+                        gpui::MouseButton::Right,
+                        cx.listener(move |this, event: &gpui::MouseDownEvent, window, cx| {
+                            cx.stop_propagation();
+                            this.open_image_menu(
+                                menu_path.clone(),
+                                devices.clone(),
+                                event.position,
+                                window,
+                                cx,
+                            );
+                        }),
+                    )
                     .w(px(dimensions.0 as f32 * scale))
                     .h(px(dimensions.1 as f32 * scale))
                     .role(gpui::Role::Button)
@@ -6438,8 +6843,22 @@ impl Transcript {
                         image.name.clone(),
                         image.image.clone(),
                     );
+                    let (menu_path, menu_devices) = (att.path.clone(), device_ids.clone());
                     frame
                         .id(SharedString::from(format!("{row_id}#att{aix}")))
+                        .on_mouse_down(
+                            gpui::MouseButton::Right,
+                            cx.listener(move |this, event: &gpui::MouseDownEvent, window, cx| {
+                                cx.stop_propagation();
+                                this.open_image_menu(
+                                    menu_path.clone(),
+                                    menu_devices.clone(),
+                                    event.position,
+                                    window,
+                                    cx,
+                                );
+                            }),
+                        )
                         .relative()
                         .border_1()
                         .border_color(crate::theme::hairline(0.11))
@@ -7450,7 +7869,13 @@ impl Transcript {
                 && fold
                     .toggled_at
                     .is_some_and(|at| at.elapsed() < TOOL_FOLD.total()));
-        let tools = if body_visible { tools.as_slice() } else { &[] };
+        let tools = if body_visible {
+            tools.as_slice()
+        } else {
+            self.tool_images
+                .release_row(row_id, Self::tool_images_of, cx);
+            &[]
+        };
         // Chips render their EFFECTIVE detail: the precomputed doc-resident
         // one, upgraded in place by a fetched sidecar blob (chat2-sync A3).
         // Resolved per paint (a HashMap probe per chip) so fetched content
@@ -7545,7 +7970,7 @@ impl Transcript {
             .zip(&invocations)
             .enumerate()
             .map(|(ix, (detail, invocation))| {
-                if detail.is_none() && invocation.is_none() {
+                if detail.is_none() && invocation.is_none() && !chip_has_images(&tools[ix]) {
                     return FoldState::default();
                 }
                 self.tool_details
@@ -7566,9 +7991,13 @@ impl Transcript {
                 // it: nothing inside the fold opens itself.
                 let default_open =
                     tool.kind == ToolItemKind::Thought && !tool.resolved && !self.compact_mode;
-                (detail.is_some() || invocation.is_some()) && fold.open.unwrap_or(default_open)
+                (detail.is_some() || invocation.is_some() || chip_has_images(tool))
+                    && fold.open.unwrap_or(default_open)
             })
             .collect();
+        // Image previews exist only while their chip's body is mounted (open,
+        // or tweening shut). Every other chip releases its pixels.
+        let chip_images = self.hold_tool_images(row_id, tools, &detail_opens, &detail_folds, cx);
         let detail_highlights: Vec<Option<Arc<crate::changes::DiffHighlights>>> = details
             .iter()
             .enumerate()
@@ -7591,36 +8020,44 @@ impl Transcript {
             .zip(&affordances)
             .zip(&detail_opens)
             .zip(&detail_folds)
-            .map(|((((detail, invocation), affordance), open), fold)| {
-                let target = if *open {
-                    base_row_height
-                        + invocation.as_deref().map_or(0.0, detail_height)
-                        + detail.as_deref().map_or(0.0, detail_height)
-                        + if affordance.is_some() {
-                            BLOB_AFFORDANCE_HEIGHT
-                        } else {
-                            0.0
-                        }
-                } else {
-                    base_row_height
-                };
-                if !cx.reduce_motion() {
-                    if let Some(at) = fold.toggled_at {
-                        let t = TOOL_FOLD
-                            .curve
-                            .eval(at.elapsed().as_secs_f32() / TOOL_FOLD.total().as_secs_f32());
-                        if t < 1.0 {
-                            motion_active = true;
+            .zip(tools.iter())
+            .map(
+                |(((((detail, invocation), affordance), open), fold), tool)| {
+                    let target = if *open {
+                        base_row_height
+                            + invocation.as_deref().map_or(0.0, detail_height)
+                            + if chip_has_images(tool) {
+                                TOOL_IMAGE_STRIP_HEIGHT
+                            } else {
+                                0.0
+                            }
+                            + detail.as_deref().map_or(0.0, detail_height)
+                            + if affordance.is_some() {
+                                BLOB_AFFORDANCE_HEIGHT
+                            } else {
+                                0.0
+                            }
+                    } else {
+                        base_row_height
+                    };
+                    if !cx.reduce_motion() {
+                        if let Some(at) = fold.toggled_at {
+                            let t = TOOL_FOLD
+                                .curve
+                                .eval(at.elapsed().as_secs_f32() / TOOL_FOLD.total().as_secs_f32());
+                            if t < 1.0 {
+                                motion_active = true;
+                            }
+                            return motion::lerp(
+                                fold.from + base_row_height - CHIP_CARD_HEIGHT,
+                                target,
+                                t,
+                            );
                         }
-                        return motion::lerp(
-                            fold.from + base_row_height - CHIP_CARD_HEIGHT,
-                            target,
-                            t,
-                        );
                     }
-                }
-                target
-            })
+                    target
+                },
+            )
             .collect();
         let reduce_motion = cx.reduce_motion();
         let now = Instant::now();
@@ -7820,7 +8257,7 @@ impl Transcript {
                 }
                 let detail = details[ix].clone();
                 let invocation = invocations[ix].clone();
-                if detail.is_none() && invocation.is_none() {
+                if detail.is_none() && invocation.is_none() && !chip_has_images(tool) {
                     return reveal_tool_row(
                         tool_chip(
                             tool,
@@ -7907,7 +8344,12 @@ impl Transcript {
                                     .flex_none()
                                     .when(!collapses, |line| line.bg(crate::theme::hairline(0.06))),
                             )
-                            .child(detail_body(invocation, None, theme));
+                            .child(detail_body(invocation, None, &format!("{key}-call"), theme));
+                    }
+                    if let Some(images) = chip_images[ix].clone() {
+                        panel = panel.child(
+                            self.render_tool_image_strip(&key, images, collapses, theme, cx),
+                        );
                     }
                     if let Some(detail) = detail.as_deref() {
                         panel = panel
@@ -7917,7 +8359,12 @@ impl Transcript {
                                     .flex_none()
                                     .when(!collapses, |line| line.bg(crate::theme::hairline(0.06))),
                             )
-                            .child(detail_body(detail, detail_highlights[ix].clone(), theme));
+                            .child(detail_body(
+                                detail,
+                                detail_highlights[ix].clone(),
+                                &format!("{key}-out"),
+                                theme,
+                            ));
                     }
                     if let Some(ChipAffordance { blob_ref, label }) = affordance {
                         let loading = matches!(
@@ -8600,9 +9047,36 @@ fn file_badge_name(path: &str) -> &str {
 fn detail_body(
     detail: &ToolDetail,
     diff_highlights: Option<Arc<crate::changes::DiffHighlights>>,
+    selection_key: &str,
     theme: &Theme,
 ) -> AnyElement {
     let body = div().w_full().min_w_0().flex().flex_col().overflow_hidden();
+    // Every line joins the transcript's selection, so paths, commands and
+    // output can be drag-selected (across lines too) and copied. Lines clip
+    // rather than ellipsize: selection maps the pointer onto the full text.
+    let selectable = |line_ix: usize, text: SharedString, runs: Vec<TextRun>| {
+        div()
+            .w_full()
+            .min_w_0()
+            .overflow_hidden()
+            .whitespace_nowrap()
+            .child(render::selectable_text_element(
+                format!("{selection_key}-{line_ix}").into(),
+                text,
+                runs,
+                theme.selection,
+            ))
+    };
+    let plain = |text: &SharedString, color: gpui::Hsla| {
+        vec![TextRun {
+            len: text.len(),
+            font: gpui::font(theme.font_mono.clone()),
+            color,
+            background_color: None,
+            underline: None,
+            strikethrough: None,
+        }]
+    };
     match detail {
         // No comment layer: an inline tool diff is a record of what the
         // agent already did, not a review surface.
@@ -8617,7 +9091,9 @@ fn detail_body(
             .py(px(6.0))
             .font_family(theme.font_mono.clone())
             .text_size(px(TOOL_TEXT_SIZE))
-            .children(stats.iter().map(|stat| {
+            .children(stats.iter().enumerate().map(|(stat_ix, stat)| {
+                let path = SharedString::from(stat.path.clone());
+                let runs = plain(&path, theme.text_faint);
                 div()
                     .h(px(OUTPUT_LINE_HEIGHT))
                     .w_full()
@@ -8637,9 +9113,7 @@ fn detail_body(
                         div()
                             .min_w_0()
                             .flex_1()
-                            .truncate()
-                            .text_color(theme.text_faint)
-                            .child(SharedString::from(stat.path.clone())),
+                            .child(selectable(stat_ix, path, runs)),
                     )
                     .child(
                         div()
@@ -8662,15 +9136,22 @@ fn detail_body(
             .py(px(6.0))
             .font_family(theme.font_mono.clone())
             .text_size(px(TOOL_TEXT_SIZE))
-            .children(lines.iter().map(|line| {
-                div()
+            .children(lines.iter().enumerate().map(|(line_ix, line)| {
+                let row = div()
                     .h(px(OUTPUT_LINE_HEIGHT))
                     .w_full()
                     .min_w_0()
                     .flex()
                     .items_center()
-                    .text_color(theme.text_faint)
-                    .child(div().w_full().min_w_0().truncate().child(line.clone()))
+                    .text_color(theme.text_faint);
+                if line.is_empty() {
+                    return row;
+                }
+                row.child(selectable(
+                    line_ix,
+                    line.clone(),
+                    plain(line, theme.text_faint),
+                ))
             }))
             .when(*truncated_by > 0, |block| {
                 block.child(more_lines_row(*truncated_by, theme))
@@ -8682,7 +9163,7 @@ fn detail_body(
         } => body
             .py(px(6.0))
             .text_size(px(TOOL_TEXT_SIZE))
-            .children(lines.iter().map(|line| {
+            .children(lines.iter().enumerate().map(|(line_ix, line)| {
                 let row = div()
                     .h(px(OUTPUT_LINE_HEIGHT))
                     .w_full()
@@ -8692,13 +9173,7 @@ fn detail_body(
                 let Some((text, runs)) = thought_line_text(line, theme) else {
                     return row; // blank separator row
                 };
-                row.child(
-                    div()
-                        .w_full()
-                        .min_w_0()
-                        .truncate()
-                        .child(StyledText::new(text).with_runs(runs)),
-                )
+                row.child(selectable(line_ix, text, runs))
             }))
             .when(*truncated_by > 0, |block| {
                 block.child(more_lines_row(*truncated_by, theme))
@@ -9663,6 +10138,7 @@ impl Render for Transcript {
             ))
             .child(content)
             .child(rail);
+        let root = root.children(self.render_image_menu(cx));
         // Full-size viewer for a clicked user-bubble thumbnail
         // (AttachmentPreviewDialog: bare lightbox, click closes).
         if let Some(preview) = self.attachment_preview.clone() {
@@ -11185,6 +11661,46 @@ mod tests {
         }
     }
 
+    #[gpui::test]
+    fn expanded_tool_call_text_drag_selects(cx: &mut gpui::TestAppContext) {
+        cx.update(|cx| {
+            gpui_base::init(cx);
+            cx.set_global(Theme::dark());
+        });
+        let command = "cat /workspace/src/main.rs";
+        struct Detail;
+        impl Render for Detail {
+            fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+                let theme = Theme::of(cx).clone();
+                div()
+                    .w(px(600.0))
+                    .child(render::selection_frame_reset_for(7))
+                    .child(detail_body(
+                        &ToolDetail::Output {
+                            lines: vec!["cat /workspace/src/main.rs".into()],
+                            truncated_by: 0,
+                        },
+                        None,
+                        "probe",
+                        &theme,
+                    ))
+            }
+        }
+        let (_, cx) = cx.add_window_view(|_, _| Detail);
+        cx.run_until_parked();
+        let bounds = render::selection_test_bounds("probe-0");
+        let start = bounds.origin + gpui::point(px(1.0), bounds.size.height / 2.0);
+        let end = start + gpui::point(bounds.size.width + px(40.0), px(0.0));
+        cx.simulate_mouse_down(start, MouseButton::Left, gpui::Modifiers::default());
+        cx.simulate_mouse_move(end, Some(MouseButton::Left), gpui::Modifiers::default());
+        cx.simulate_mouse_up(end, MouseButton::Left, gpui::Modifiers::default());
+        assert_eq!(
+            crate::markdown::selection::selected_text().as_deref(),
+            Some(command)
+        );
+        crate::markdown::selection::clear_if_owner("probe-0");
+    }
+
     #[gpui::test]
     fn generated_image_click_opens_lightbox_and_escape_restores_focus(
         cx: &mut gpui::TestAppContext,
@@ -14729,6 +15245,21 @@ mod tests {
         assert_eq!(truncated_by, 40 - OUTPUT_DETAIL_MAX_LINES);
         assert_eq!(lines[0].as_ref(), "    indented 0");
 
+        // A minified megabyte line is cut on a char boundary before shaping,
+        // in the summary and in a fetched full output alike.
+        let long = format!("{}\nshort", "é".repeat(1024 * 1024));
+        for detail in [
+            tool_detail(Some(&long), None, None),
+            blob_detail(&long, false),
+        ] {
+            let Some(ToolDetail::Output { lines, .. }) = detail else {
+                panic!("expected output detail");
+            };
+            assert_eq!(lines[0].chars().count(), OUTPUT_LINE_MAX_CHARS + 1);
+            assert!(lines[0].ends_with("é…"));
+            assert_eq!(lines[1].as_ref(), "short");
+        }
+
         // Nothing → no affordance.
         assert!(tool_detail(None, None, None).is_none());
         assert!(tool_detail(Some("\n\n"), None, None).is_none());
@@ -14750,6 +15281,7 @@ mod tests {
             subagent_status: None,
             subagent_tail: None,
             kind: ToolItemKind::Call,
+            images: Arc::new([]),
         };
         let edit = |p: &str| ToolItem {
             part_id: "fixture".into(),
@@ -14769,6 +15301,7 @@ mod tests {
             subagent_status: None,
             subagent_tail: None,
             kind: ToolItemKind::Call,
+            images: Arc::new([]),
         };
         let tools = vec![
             exec("ls"),
@@ -14804,6 +15337,7 @@ mod tests {
                 subagent_status: None,
                 subagent_tail: None,
                 kind: ToolItemKind::Call,
+                images: Arc::new([]),
             },
             ToolItem {
                 part_id: "fixture".into(),
@@ -14821,6 +15355,7 @@ mod tests {
                 subagent_status: None,
                 subagent_tail: None,
                 kind: ToolItemKind::Call,
+                images: Arc::new([]),
             },
             ToolItem {
                 part_id: "fixture".into(),
@@ -14836,6 +15371,7 @@ mod tests {
                 subagent_status: None,
                 subagent_tail: None,
                 kind: ToolItemKind::Call,
+                images: Arc::new([]),
             },
         ];
         assert_eq!(tool_group_summary(&tools), "Read 1 file · searched 2 times");
@@ -15278,4 +15814,48 @@ impl Transcript {
         self.list.scroll_to(gpui::ListOffset::default());
         cx.notify();
     }
+
+    /// Open or close every tool group and image chip, as clicks would.
+    pub fn fixture_tool_images(&mut self, open: bool, cx: &mut Context<Self>) {
+        let now = Instant::now();
+        for row in &self.rows {
+            let RowKind::ToolGroup { tools, .. } = &row.kind else {
+                continue;
+            };
+            let fold = self.folds.entry(row.id.clone()).or_default();
+            fold.open = Some(open);
+            for (ix, tool) in tools.iter().enumerate() {
+                if chip_has_images(tool) {
+                    let chip = self
+                        .tool_details
+                        .entry(SharedString::from(format!("{}#d{ix}", row.id)))
+                        .or_default();
+                    chip.open = Some(open);
+                    chip.epoch += 1;
+                    chip.toggled_at = Some(now);
+                }
+            }
+        }
+        self.list.remeasure();
+        cx.notify();
+    }
+
+    /// `(previews resident, retained bytes)`.
+    pub fn fixture_tool_image_stats(&self) -> (usize, usize) {
+        self.tool_images.stats()
+    }
+
+    pub fn fixture_image_menu(
+        &mut self,
+        path: String,
+        action: Option<usize>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let devices = self.image_host(cx).0.into_iter().collect();
+        self.open_image_menu(path, devices, gpui::point(px(420.), px(260.)), window, cx);
+        if let Some(action) = action {
+            self.dispatch_image_menu(action, cx);
+        }
+    }
 }
diff --git a/docs/image-preview.md b/docs/image-preview.md
index 2a060fa70c..d243bd823c 100644
--- a/docs/image-preview.md
+++ b/docs/image-preview.md
@@ -21,6 +21,16 @@ The existing transport limits remain: at most 8 MiB of image bytes, 384 KiB chun
 
 Each Files image surface admits at most 64 MiB of retained image resources, including its panel rendering variants. A generation guard rejects obsolete work. Collapsing the right panel or switching files, tabs or chats suspends image loads, clears media and schedules asset/atlas eviction. Resuming reloads from the owning workspace. Watcher updates do not reload hidden images; modifications, deletion and renaming invalidate the relevant image. Changing the target suspends the old view before clearing documents. Closing/disposal releases the image preview resources. Text documents retain their existing cache and editing lifecycle. Renaming an edited text file to an image extension preserves its buffer and pending save; image conversion waits until those edits are resolved. Watcher events continue through text conflict handling while edits remain.
 
+## Tool-call image previews
+
+A tool chip whose call or output names an image file (PNG, JPEG, GIF, WebP, BMP, SVG, TIFF; at most four per chip) previews it when the chip is expanded. Relative paths resolve against the chat's cwd on the owning host. Bytes arrive through `ReadAttachmentChunk`, so its jail applies: the owning host's uploads directory (plus any read-only legacy uploads roots) and the working directory of every chat in the workspace on that host, not just the chat that ran the tool. A projectless chat's working directory is the home directory, so any image under home on that host is readable. Other paths show *Image unavailable*. Network and device paths (UNC `\\host\share`, `//host/share`, `\\?\UNC\…`, `\\.\…`) and drive-relative paths (`C:x.png`) are never previewed. The engine also jails each path lexically, resolving `.`/`..` without touching the filesystem, before it canonicalizes the path, so a path outside every root is refused without being opened.
+
+`tool_images.rs` decodes one static frame on the background executor within the shared raster limits (4096 pixels per side, 64 MiB decoder allocation), downsamples it to at most 1120×440 and hands BGRA pixels straight to GPUI as a `RenderImage` (no re-encode, no asset cache). Nothing is read or decoded for collapsed chips or hidden groups. Collapsing starts a 600 ms grace; then the CPU frame and the sprite-atlas tiles are released. Reopening inside the grace reuses the texture, so rapid toggling never re-reads or re-decodes. Previews that are expanded but unpainted for 2 s count against a 64 MiB budget; painted ones are never evicted. Chat switches and transcript disposal release everything.
+
+Right-clicking a tool preview, a user attachment thumbnail or a generated image opens **Copy path** / **Copy image**. Copy image fetches the original file from its owning device, not the preview; SVG is copied as the sanitized, re-serialized tree.
+
+`cargo run --locked -p zeron-ui --example tool-images-fixture --features appshots-fixture` opens an isolated session with mock images. `-- --capture <dir>` runs the automated expand / toggle-spam / collapse / copy check instead.
+
 ## Verification
 
 Automated coverage includes image format selection, owner-routed loading with and without synced checkout metadata, malformed/repeated/inconsistent/oversized chunks, bounded decoding, SVG sanitization, animation flattening, stale completion rejection, cancellation, disposal, and zoom geometry. A headless GPUI test dispatches actual wheel, pinch, drag, click and Escape events through the rendered lightbox. A rendered Files test loads through the owning-device client and verifies that clicking the image retains panel focus and that subsequent zoom still targets the file panel. Existing Markdown lightbox tests also verify opening and focus restoration. Regression coverage checks edited text renamed to an image extension across reopen, watcher and pending-save paths; suspension during panel collapse; wheel direction; and reuse of an unrelated cached view during zoom.
diff --git a/docs/reference/windows-development.md b/docs/reference/windows-development.md
index 49a92bbc83..a5b4f4be94 100644
--- a/docs/reference/windows-development.md
+++ b/docs/reference/windows-development.md
@@ -63,6 +63,30 @@ shutdown/drop log failures. Processes started through external services or
 brokers are outside this ownership. Closing a terminal or exiting its shell also
 terminates processes detached inside that job (including `start` children).
 
+## Embedded browser
+
+Browser tabs embed Microsoft Edge WebView2 (the Evergreen runtime ships with
+Windows 10/11) in visual-hosting mode. Each page is a DirectComposition visual
+mounted in the zui overlay plane's native layer: GPUI's base content, then the
+page, then deferred GPUI content (menus, tooltips, prompts) in a second swap
+chain. DWM composites the page directly, without copies or child windows. A
+frame without deferred content detaches the overlay and draws nothing extra.
+
+GPUI receives all pointer input, so anything drawn above the page occludes it
+naturally; presses, moves and wheel events that reach the page element are
+forwarded with `SendMouseInput`. The page owns the keyboard while focused;
+browser and app shortcuts are intercepted with `AcceleratorKeyPressed` and
+dispatched to GPUI. A press on GPUI content, or an interactive overlay opening,
+returns keyboard focus to the window.
+
+All tabs of a window share one InPrivate environment (one browser process).
+Hidden tabs are unmounted and set invisible, so Chromium throttles them. The
+user-data folder (`%TEMP%\zeron-webview2`) holds only runtime caches; when
+another process still holds it (a second Zeron, or one shutting down after a
+quick restart), the window falls back to its own folder, and stale ones are
+swept in the background. Per-frame updates touch WebView2 only when geometry
+or visibility changed.
+
 Frosted window chrome uses native Acrylic and requires Windows **Settings >
 Personalization > Colors > Transparency effects**. Content cards and popovers
 remain opaque because in-app backdrop blur is not supported. The pinned
@@ -103,5 +127,5 @@ captures only its synthetic window. Results go to ignored
 `target/windows-lifecycle-*` and `target/windows-render-*` directories.
 
 Remaining acceptance work includes authenticated provider runs and shutdown,
-broader GPU/DPI coverage, accessibility, native browser and cross-device parity,
+broader GPU/DPI coverage, accessibility, cross-device parity,
 concurrent-launch log rotation, and invalid-window teardown diagnostics.

From 037f4c10d67a38175b2386e776aba54355b4e941 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Thu, 8 Oct 2026 00:02:26 -0700
Subject: [PATCH 63/74] Engine: keep turn snapshots out of the checkout's
 object database (#820)

* engine: turn snapshots stay out of the checkout's object database

The "Latest turn" snapshot ran `git add -A` under a throwaway index, which
writes a blob for every unignored file into the checkout's own .git/objects.
Nothing referenced those blobs, nothing bounded them, and the git add had no
timeout. A checkout with unignored build directories collected 20 GB of loose
objects that way, and git's auto-maintenance then tried to repack them after
every agent commit: 23 concurrent pack-objects holding 117 GB on a 24 GB
machine.

Each snapshot now writes into its own object directory under the data dir,
with the checkout's database as a read-only alternate, and that directory is
deleted with the snapshot. A turn-diff capture layers its snapshot on the
turn's, so it only writes what changed. Stores left by earlier runs are swept
at start.

Snapshots are also bounded: untracked files over 8 MiB and untracked
directories over 10,000 files or 256 MiB are left out, and the whole snapshot
runs under a 120 s timeout with kill-on-drop children.

* Address review: partial budget, stable layered diffs, snapshot lifetime

- Over the untracked budget, leave out the largest units until the rest
  fits instead of every untracked path: one big directory or a pile of
  assets no longer hides the files a turn creates.
- Layer the "Latest turn" capture on the turn-start tree (read-tree into
  the throwaway index) and leave out what either side left out, so a
  directory crossing the budget mid-turn keeps its turn-start state
  instead of diffing as thousands of added or deleted files.
- Drop a chat's turn snapshot (and its on-disk store) when the chat is
  gone or archived without a viewer, and when a new turn's snapshot
  fails or its cwd is no longer a checkout, instead of diffing against
  an older turn.
- capture_git children are kill_on_drop (all read-only), so a timed-out
  snapshot takes its ls-files calls down too.
- Store paths are absolute: git resolves GIT_OBJECT_DIRECTORY against
  the checkout, so a relative data dir broke every snapshot.

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

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/diff_sync.rs                |  164 +--
 crates/engine/src/diff_sync/turn_snapshot.rs  | 1069 +++++++++++++++++
 crates/engine/src/lib.rs                      |    2 +-
 crates/engine/src/rpc.rs                      |   27 +-
 .../engine/tests/m5_repos_diffs_terminals.rs  |    2 +-
 5 files changed, 1184 insertions(+), 80 deletions(-)
 create mode 100644 crates/engine/src/diff_sync/turn_snapshot.rs

diff --git a/crates/engine/src/diff_sync.rs b/crates/engine/src/diff_sync.rs
index a81dd9b50b..cdd8058331 100644
--- a/crates/engine/src/diff_sync.rs
+++ b/crates/engine/src/diff_sync.rs
@@ -36,10 +36,12 @@
 //! `GetCheckoutDiff` captures for the Changes pane's scopes: *branch changes*
 //! (vs `merge-base(baseRef, HEAD)`, same capture path with the base overridden)
 //! and *latest turn* (vs a temp-index `write-tree` snapshot taken when a turn
-//! dispatches — see [`CheckoutDiffSync::note_turn_start`]).
+//! dispatches — see [`CheckoutDiffSync::note_turn_start`]). Those snapshots
+//! live in Zeron's own object store, never the checkout's — see
+//! [`turn_snapshot`].
 
 use std::collections::{HashMap, HashSet};
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
 use std::path::{Component, Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, MutexGuard, PoisonError, Weak};
@@ -60,6 +62,9 @@ use crate::repos::{CheckoutIdentity, Repos};
 use crate::workspace_host::WorkspaceHost;
 
 mod git_status;
+mod turn_snapshot;
+
+pub use turn_snapshot::{TreeSnapshot, snapshot_tree};
 
 /// Hard cap on the unified patch (plus untracked hunks) — "Partial snapshot".
 pub const MAX_PATCH_BYTES: usize = 3 * 1024 * 1024;
@@ -157,8 +162,9 @@ struct CheckoutEntry {
 pub struct TurnSnapshot {
     /// Canonical checkout root the tree was captured in.
     pub root: PathBuf,
-    /// `git write-tree` sha of the tracked + untracked (unignored) tree.
-    pub tree: String,
+    /// The tracked + untracked (unignored) tree, with the object store that
+    /// holds it. Replacing or dropping the snapshot deletes that store.
+    pub tree: TreeSnapshot,
     pub at: chrono::DateTime<chrono::Utc>,
 }
 
@@ -321,6 +327,9 @@ impl CheckoutDiffSync {
         interest_linger: Duration,
     ) -> Self {
         let (diffs_tx, _) = watch::channel(Vec::new());
+        // Turn snapshots are in-memory state: whatever an earlier run left on
+        // disk is unreachable now.
+        turn_snapshot::sweep_stale_stores(repos.data_dir());
         let sync = Self {
             inner: Arc::new(DiffSyncInner {
                 repos,
@@ -451,9 +460,13 @@ impl CheckoutDiffSync {
             let Some(inner) = inner.upgrade() else { return };
             let identity = match inner.repos.checkout_identity(&cwd).await {
                 Ok(identity) => identity,
-                Err(_) => return, // not a checkout
+                Err(_) => {
+                    // Not a checkout: no turn to diff, not the previous one.
+                    lock(&inner.turn_trees).remove(&chat_id);
+                    return;
+                }
             };
-            match snapshot_tree(&identity.root).await {
+            match snapshot_tree(&inner.repos, &identity.root).await {
                 Ok(tree) => {
                     lock(&inner.turn_trees).insert(
                         chat_id,
@@ -465,6 +478,8 @@ impl CheckoutDiffSync {
                     );
                 }
                 Err(err) => {
+                    // Keeping the previous base would silently diff two turns.
+                    lock(&inner.turn_trees).remove(&chat_id);
                     tracing::debug!(chat = %chat_id, error = %err,
                         "diff-sync: turn snapshot failed");
                 }
@@ -617,6 +632,19 @@ async fn reconcile(inner: &Arc<DiffSyncInner>, chats: Vec<Chat>, fresh: bool) {
             .1
             .push(chat);
     }
+    // A turn snapshot holds an object store on disk: keep it only for chats
+    // that can still show "Latest turn". Judged on the current rows, not this
+    // pass's (possibly older) list, so a chat created meanwhile keeps its own.
+    {
+        let current = inner.workspace.watch_chats();
+        let current = current.borrow();
+        let live: HashSet<&str> = current
+            .iter()
+            .filter(|chat| !chat.archived || interested.contains(&chat.id))
+            .map(|chat| chat.id.as_str())
+            .collect();
+        lock(&inner.turn_trees).retain(|chat_id, _| live.contains(chat_id.as_str()));
+    }
 
     // Close entries whose checkout has had no chats for a full grace period;
     // drop their published diff. A single pass that misses a checkout only
@@ -1022,7 +1050,25 @@ struct Capture {
 
 /// Run git capturing stdout under a hard byte ceiling — the child is killed once
 /// the cap is hit, so an arbitrarily large repository diff never buffers fully.
-async fn capture_git(cwd: &Path, args: &[&str], max_bytes: usize) -> Result<Capture, EngineError> {
+///
+/// Not an `async fn`: a wrapping future would add a poll frame, and a copy of
+/// the 64 KiB read buffer, to every capture on the RPC worker's stack.
+fn capture_git<'a, S: AsRef<OsStr>>(
+    cwd: &'a Path,
+    args: &'a [S],
+    max_bytes: usize,
+) -> impl Future<Output = Result<Capture, EngineError>> + 'a {
+    capture_git_in(cwd, args, max_bytes, None)
+}
+
+/// [`capture_git`] that can also see a turn snapshot's objects, which exist
+/// only in that snapshot's store.
+async fn capture_git_in<S: AsRef<OsStr>>(
+    cwd: &Path,
+    args: &[S],
+    max_bytes: usize,
+    snapshot: Option<&TreeSnapshot>,
+) -> Result<Capture, EngineError> {
     let mut cmd = tokio::process::Command::new("git");
     #[cfg(windows)]
     {
@@ -1030,6 +1076,12 @@ async fn capture_git(cwd: &Path, args: &[&str], max_bytes: usize) -> Result<Capt
         cmd.as_std_mut().creation_flags(0x08000000);
     }
     cmd.arg("-C").arg(cwd).args(args);
+    if let Some(snapshot) = snapshot {
+        snapshot.apply_to(&mut cmd);
+    }
+    // Read-only commands: a caller that gives up (a timed-out snapshot, a
+    // dropped request) takes its git child down with it.
+    cmd.kill_on_drop(true);
     cmd.stdin(std::process::Stdio::null());
     cmd.stdout(std::process::Stdio::piped());
     cmd.stderr(std::process::Stdio::piped());
@@ -1283,9 +1335,20 @@ async fn read_worktree_source(root: &Path, path: &Path) -> Result<Capture, Engin
     })
 }
 
-async fn read_git_source(root: &Path, revision: &str, path: &Path) -> Result<Capture, EngineError> {
+async fn read_git_source(
+    root: &Path,
+    revision: &str,
+    snapshot: Option<&TreeSnapshot>,
+    path: &Path,
+) -> Result<Capture, EngineError> {
     let spec = format!("{revision}:{}", path.to_string_lossy());
-    capture_git(root, &["cat-file", "blob", &spec], MAX_DIFF_SOURCE_BYTES).await
+    capture_git_in(
+        root,
+        &["cat-file", "blob", &spec],
+        MAX_DIFF_SOURCE_BYTES,
+        snapshot,
+    )
+    .await
 }
 
 /// Read the exact old/new documents for one file in a previously captured diff.
@@ -1296,15 +1359,18 @@ pub async fn read_diff_file_text(
     base: &str,
     file: &DiffFileSummary,
 ) -> Result<DiffFileTextPair, EngineError> {
-    read_diff_file_text_at(root, base, None, file).await
+    read_diff_file_text_at(root, base, None, None, file).await
 }
 
 /// Read the exact old/new documents for one file in a diff between `base` and
 /// an optional committed target. Without a target, the new source is the live
-/// working tree; with one, both sources are immutable Git blobs.
+/// working tree; with one, both sources are immutable Git blobs. A `base` that
+/// is a turn snapshot's tree needs that snapshot as `base_snapshot`: its
+/// objects are not in the checkout.
 pub(crate) async fn read_diff_file_text_at(
     root: &Path,
     base: &str,
+    base_snapshot: Option<&TreeSnapshot>,
     target: Option<&str>,
     file: &DiffFileSummary,
 ) -> Result<DiffFileTextPair, EngineError> {
@@ -1314,12 +1380,12 @@ pub(crate) async fn read_diff_file_text_at(
     let old = if file.status == "added" {
         None
     } else {
-        Some(read_git_source(root, base, old_path).await?)
+        Some(read_git_source(root, base, base_snapshot, old_path).await?)
     };
     let new = if file.status == "deleted" {
         None
     } else if let Some(target) = target {
-        Some(read_git_source(root, target, new_path).await?)
+        Some(read_git_source(root, target, None, new_path).await?)
     } else {
         Some(read_worktree_source(root, new_path).await?)
     };
@@ -1915,65 +1981,22 @@ pub async fn merge_base(root: &Path, base_ref: &str) -> Result<String, EngineErr
     Ok(sha)
 }
 
-/// Write the checkout's current tracked + untracked (unignored) tree into the
-/// object db via a throwaway index: `git add -A` under `GIT_INDEX_FILE`, then
-/// `git write-tree`. The real index is never touched. Costs one full hash pass
-/// over the working tree (no stat cache in a fresh index) — run once per turn
-/// dispatch, that is the same cost class as the untracked-file reads the watch
-/// capture already does.
-pub async fn snapshot_tree(root: &Path) -> Result<String, EngineError> {
-    let index = std::env::temp_dir().join(format!(
-        "zeron-turn-index-{}-{}",
-        std::process::id(),
-        chrono::Utc::now().timestamp_micros()
-    ));
-    let run = |args: &[&str]| {
-        let mut cmd = tokio::process::Command::new("git");
-        #[cfg(windows)]
-        {
-            use std::os::windows::process::CommandExt;
-            cmd.as_std_mut().creation_flags(0x08000000);
-        }
-        cmd.arg("-C").arg(root).args(args);
-        cmd.env("GIT_INDEX_FILE", &index);
-        cmd.stdin(std::process::Stdio::null());
-        cmd.output()
-    };
-    let added = run(&["add", "-A", "--ignore-errors", "."])
-        .await
-        .map_err(|e| EngineError::Other(format!("git add failed: {e}")))?;
-    if !added.status.success() {
-        let _ = tokio::fs::remove_file(&index).await;
-        return Err(EngineError::Other(format!(
-            "git add: {}",
-            String::from_utf8_lossy(&added.stderr).trim()
-        )));
-    }
-    let written = run(&["write-tree"])
-        .await
-        .map_err(|e| EngineError::Other(format!("git write-tree failed: {e}")));
-    let _ = tokio::fs::remove_file(&index).await;
-    let written = written?;
-    if !written.status.success() {
-        return Err(EngineError::Other(format!(
-            "git write-tree: {}",
-            String::from_utf8_lossy(&written.stderr).trim()
-        )));
-    }
-    Ok(String::from_utf8_lossy(&written.stdout).trim().to_string())
-}
-
 /// "Latest turn" capture: tree-to-tree diff from the turn-start snapshot to a
 /// fresh [`snapshot_tree`] of the current state. Both trees carry untracked
 /// (unignored) files, so no synthesis is needed and a file that was already
 /// untracked at turn start diffs correctly (the watch capture's synthesis
 /// would misreport it as entirely new).
+///
+/// The fresh snapshot is layered on the turn's store, so it only writes the
+/// files that changed since, and it is deleted again when this returns.
 pub async fn capture_turn_diff(
     repos: &Repos,
     root: &Path,
-    turn_tree: &str,
+    turn: &TreeSnapshot,
 ) -> Result<DiffSnapshot, EngineError> {
-    let current = snapshot_tree(root).await?;
+    let current = turn_snapshot::snapshot_tree_onto(repos, root, Some(turn)).await?;
+    let turn_tree = turn.tree();
+    let current_tree = current.tree();
     let head = capture_git(root, &["rev-parse", "--verify", "HEAD"], 256)
         .await
         .map(|c| String::from_utf8_lossy(&c.stdout).trim().to_string())
@@ -1983,7 +2006,7 @@ pub async fn capture_turn_diff(
         .await
         .unwrap_or_else(|_| "HEAD".into());
 
-    let names = capture_git(
+    let names = capture_git_in(
         root,
         &[
             "diff",
@@ -1991,13 +2014,14 @@ pub async fn capture_turn_diff(
             "-z",
             "--find-renames",
             turn_tree,
-            &current,
+            current_tree,
             "--",
         ],
         2 * 1024 * 1024,
+        Some(&current),
     )
     .await?;
-    let nums = capture_git(
+    let nums = capture_git_in(
         root,
         &[
             "diff",
@@ -2005,13 +2029,14 @@ pub async fn capture_turn_diff(
             "-z",
             "--find-renames",
             turn_tree,
-            &current,
+            current_tree,
             "--",
         ],
         2 * 1024 * 1024,
+        Some(&current),
     )
     .await?;
-    let tracked = capture_git(
+    let tracked = capture_git_in(
         root,
         &[
             "diff",
@@ -2020,10 +2045,11 @@ pub async fn capture_turn_diff(
             "--find-renames",
             "--unified=3",
             turn_tree,
-            &current,
+            current_tree,
             "--",
         ],
         MAX_PATCH_BYTES,
+        Some(&current),
     )
     .await?;
 
diff --git a/crates/engine/src/diff_sync/turn_snapshot.rs b/crates/engine/src/diff_sync/turn_snapshot.rs
new file mode 100644
index 0000000000..750d1f3077
--- /dev/null
+++ b/crates/engine/src/diff_sync/turn_snapshot.rs
@@ -0,0 +1,1069 @@
+//! Working-tree snapshots for the "Latest turn" scope, kept out of the
+//! checkout's object database.
+//!
+//! A snapshot is `git add -A` into a throwaway index followed by `git
+//! write-tree`, and `git add` writes a blob for every file it hashes. Those
+//! blobs used to land in the checkout's own `.git/objects`, where nothing ever
+//! referenced them. A checkout with an unignored build directory collected
+//! ~20 GB of loose objects that way, and git's auto-maintenance (run after
+//! every commit, merge and fetch) then tried to delta-compress them: one
+//! multi-gigabyte `pack-objects` per agent commit, 23 at once on the machine
+//! that reported it.
+//!
+//! Two rules keep that from happening again:
+//!
+//! - **Zeron's objects stay in Zeron's directory.** Each snapshot writes into
+//!   its own object directory under the data dir (`GIT_OBJECT_DIRECTORY`) and
+//!   reads the checkout's objects as an alternate. The checkout's database is
+//!   never written to, and the directory is deleted with the snapshot.
+//! - **The work is bounded.** Untracked files past [`MAX_UNTRACKED_FILE_BYTES`]
+//!   and untracked directories past the untracked budget are left out, and the
+//!   whole snapshot runs under [`SNAPSHOT_TIMEOUT`]. A left-out path simply
+//!   never shows in the turn diff; tracked files are always snapshotted.
+//!
+//! Git still refreshes the mtime of checkout objects a snapshot finds there
+//! instead of writing them (as it did before), so pruning the checkout while
+//! a turn is open can make that turn's diff unreadable until the next turn.
+
+use std::ffi::{OsStr, OsString};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, OnceLock};
+use std::time::Duration;
+
+use tokio::io::AsyncWriteExt;
+use tokio_util::sync::CancellationToken;
+
+use super::{MAX_PATH_ARGUMENT_BYTES, capture_git, path_argument, path_batches};
+use crate::EngineError;
+use crate::repos::Repos;
+
+/// Snapshot stores live in `{data_dir}/turn-snapshots/{run}/{snapshot}`.
+const STORE_DIR: &str = "turn-snapshots";
+/// Largest untracked file a snapshot carries. The Changes pane cannot render
+/// more than [`super::MAX_DIFF_SOURCE_BYTES`] of a file anyway; the headroom
+/// keeps ordinary binary assets (screenshots, fonts) in the file list.
+const MAX_UNTRACKED_FILE_BYTES: u64 = 8 * 1024 * 1024;
+/// Budget for untracked content, applied to each untracked directory on its
+/// own and then to everything that is left. Source-sized trees fit with room
+/// to spare; build output, dependency trees and datasets do not.
+const MAX_UNTRACKED_FILES: usize = 10_000;
+const MAX_UNTRACKED_BYTES: u64 = 256 * 1024 * 1024;
+/// Cap on one untracked listing from git.
+const MAX_UNTRACKED_LISTING_BYTES: usize = 8 * 1024 * 1024;
+/// Backstop for a whole snapshot (a wedged mount, a hung clean filter). The
+/// budgets above keep a healthy checkout far below it.
+const SNAPSHOT_TIMEOUT: Duration = Duration::from_secs(120);
+
+#[cfg(windows)]
+const ALTERNATES_SEPARATOR: char = ';';
+#[cfg(not(windows))]
+const ALTERNATES_SEPARATOR: char = ':';
+
+/// A working tree written as a git tree, together with the private object
+/// store that holds it. Cloning shares the store; the last clone to drop
+/// deletes it.
+#[derive(Debug, Clone)]
+pub struct TreeSnapshot {
+    tree: String,
+    store: Arc<ObjectStore>,
+    /// Untracked paths left out of `tree` (git's spelling, from the root).
+    /// A snapshot layered on this one leaves them as they are here.
+    skipped: Arc<Vec<Vec<u8>>>,
+}
+
+impl TreeSnapshot {
+    /// `git write-tree` sha of the tracked + untracked (unignored) tree.
+    pub fn tree(&self) -> &str {
+        &self.tree
+    }
+
+    /// Point a git command at this snapshot's objects. Without it the tree
+    /// does not exist as far as the checkout is concerned.
+    pub(super) fn apply_to(&self, cmd: &mut tokio::process::Command) {
+        self.store.apply_to(cmd);
+    }
+}
+
+/// One snapshot's object directory.
+#[derive(Debug)]
+struct ObjectStore {
+    dir: PathBuf,
+    /// `GIT_ALTERNATE_OBJECT_DIRECTORIES`: the checkout's objects, behind the
+    /// base snapshot's when there is one.
+    alternates: OsString,
+    /// A layered snapshot reads through its base's directory, so the base
+    /// has to outlive it.
+    _base: Option<Arc<ObjectStore>>,
+}
+
+impl ObjectStore {
+    async fn create(
+        repos: &Repos,
+        root: &Path,
+        base: Option<&Arc<ObjectStore>>,
+    ) -> Result<Self, EngineError> {
+        let alternates = match base {
+            Some(base) => {
+                let mut value = alternates_value(&[&base.objects_dir()]);
+                value.push(ALTERNATES_SEPARATOR.to_string());
+                value.push(&base.alternates);
+                value
+            }
+            None => {
+                // `--git-path` resolves linked worktrees to the shared database.
+                let listed = capture_git(
+                    root,
+                    &[
+                        "rev-parse",
+                        "--path-format=absolute",
+                        "--git-path",
+                        "objects",
+                    ],
+                    16 * 1024,
+                )
+                .await?;
+                let mut path = listed.stdout.as_slice();
+                while let Some(rest) = path
+                    .strip_suffix(b"\n")
+                    .or_else(|| path.strip_suffix(b"\r"))
+                {
+                    path = rest;
+                }
+                if path.is_empty() {
+                    return Err(EngineError::Other("git object directory unknown".into()));
+                }
+                let mut value = alternates_value(&[Path::new(&path_argument(path))]);
+                // A checkout that already borrows objects this way keeps doing so.
+                if let Some(inherited) = std::env::var_os("GIT_ALTERNATE_OBJECT_DIRECTORIES")
+                    .filter(|inherited| !inherited.is_empty())
+                {
+                    value.push(ALTERNATES_SEPARATOR.to_string());
+                    value.push(inherited);
+                }
+                value
+            }
+        };
+        // Absolute: git resolves `GIT_OBJECT_DIRECTORY` against the checkout
+        // (`-C`), not against this process's directory.
+        let dir = std::path::absolute(store_root(repos.data_dir()))
+            .map_err(|error| EngineError::Other(format!("turn snapshot store: {error}")))?
+            .join(uuid::Uuid::new_v4().to_string());
+        let objects = dir.join("objects");
+        tokio::fs::create_dir_all(&objects)
+            .await
+            .map_err(|error| EngineError::Other(format!("turn snapshot store: {error}")))?;
+        Ok(Self {
+            dir,
+            alternates,
+            _base: base.cloned(),
+        })
+    }
+
+    fn objects_dir(&self) -> PathBuf {
+        self.dir.join("objects")
+    }
+
+    fn apply_to(&self, cmd: &mut tokio::process::Command) {
+        cmd.env("GIT_OBJECT_DIRECTORY", self.objects_dir());
+        cmd.env("GIT_ALTERNATE_OBJECT_DIRECTORIES", &self.alternates);
+    }
+}
+
+impl Drop for ObjectStore {
+    fn drop(&mut self) {
+        let dir = std::mem::take(&mut self.dir);
+        // A store can hold thousands of loose objects: delete it off the
+        // runtime's worker threads.
+        match tokio::runtime::Handle::try_current() {
+            Ok(runtime) => {
+                runtime.spawn_blocking(move || {
+                    let _ = std::fs::remove_dir_all(dir);
+                });
+            }
+            Err(_) => {
+                let _ = std::fs::remove_dir_all(dir);
+            }
+        }
+    }
+}
+
+/// Encode directories for `GIT_ALTERNATE_OBJECT_DIRECTORIES`. Git splits the
+/// value on the platform's path-list separator, and reads an entry that
+/// starts with `"` as a C-quoted path, which is the only way to name a
+/// directory containing that separator.
+fn alternates_value(dirs: &[&Path]) -> OsString {
+    let mut value = OsString::new();
+    for (index, dir) in dirs.iter().enumerate() {
+        if index > 0 {
+            value.push(ALTERNATES_SEPARATOR.to_string());
+        }
+        match dir.to_str() {
+            Some(text) if text.contains(ALTERNATES_SEPARATOR) || text.starts_with('"') => {
+                value.push("\"");
+                value.push(text.replace('\\', "\\\\").replace('"', "\\\""));
+                value.push("\"");
+            }
+            _ => value.push(dir.as_os_str()),
+        }
+    }
+    value
+}
+
+/// This process's stores. An engine holds its data dir exclusively
+/// ([`crate::InstanceLock`]), so any sibling directory was left by a run that
+/// is gone — see [`sweep_stale_stores`].
+fn store_root(data_dir: &Path) -> PathBuf {
+    data_dir.join(STORE_DIR).join(run_id())
+}
+
+fn run_id() -> &'static str {
+    static RUN_ID: OnceLock<String> = OnceLock::new();
+    RUN_ID.get_or_init(|| {
+        format!(
+            "{}-{}",
+            std::process::id(),
+            chrono::Utc::now().timestamp_micros()
+        )
+    })
+}
+
+/// Delete the stores of earlier engine runs. Snapshots are in-memory state, so
+/// nothing on disk from a previous run is reachable; a run that was killed, or
+/// exited without unwinding, leaves its stores behind for this to collect.
+/// Requires a tokio runtime.
+pub(super) fn sweep_stale_stores(data_dir: &Path) {
+    let parent = data_dir.join(STORE_DIR);
+    tokio::task::spawn_blocking(move || remove_other_runs(&parent, OsStr::new(run_id())));
+}
+
+fn remove_other_runs(parent: &Path, current: &OsStr) {
+    let Ok(entries) = std::fs::read_dir(parent) else {
+        return;
+    };
+    for entry in entries.flatten() {
+        if entry.file_name() == current {
+            continue;
+        }
+        let path = entry.path();
+        if std::fs::remove_dir_all(&path).is_err() {
+            let _ = std::fs::remove_file(&path);
+        }
+    }
+}
+
+/// Write the checkout's current tracked + untracked (unignored) tree into a
+/// private object store: `git add -A` under a throwaway `GIT_INDEX_FILE`, then
+/// `git write-tree`. Neither the real index nor the checkout's object database
+/// is touched. Costs one hash pass over the tracked files and the untracked
+/// files within budget (no stat cache in a fresh index).
+pub async fn snapshot_tree(repos: &Repos, root: &Path) -> Result<TreeSnapshot, EngineError> {
+    snapshot_tree_onto(repos, root, None).await
+}
+
+/// [`snapshot_tree`] layered on `base`: objects the base already holds are
+/// read from its store instead of being written again, so the new store only
+/// carries what changed since. The result keeps `base` alive.
+pub(super) async fn snapshot_tree_onto(
+    repos: &Repos,
+    root: &Path,
+    base: Option<&TreeSnapshot>,
+) -> Result<TreeSnapshot, EngineError> {
+    // The git children are `kill_on_drop`: timing out takes them down too.
+    // Boxed because the future embeds several 64 KiB git read buffers, which
+    // callers would otherwise carry inline in their own frames.
+    let snapshot = Box::pin(write_snapshot(repos, root, base));
+    match tokio::time::timeout(SNAPSHOT_TIMEOUT, snapshot).await {
+        Ok(result) => result,
+        Err(_) => Err(EngineError::Other(format!(
+            "turn snapshot timed out after {}s",
+            SNAPSHOT_TIMEOUT.as_secs()
+        ))),
+    }
+}
+
+async fn write_snapshot(
+    repos: &Repos,
+    root: &Path,
+    base: Option<&TreeSnapshot>,
+) -> Result<TreeSnapshot, EngineError> {
+    let store = Arc::new(ObjectStore::create(repos, root, base.map(|base| &base.store)).await?);
+    let mut skipped = untracked_to_skip(root).await?;
+    let index = store.dir.join("index");
+    if let Some(base) = base {
+        // Start from the base tree and leave out what either side left out:
+        // a path skipped on one side only (a directory that crossed the
+        // budget mid-turn) then keeps its base state instead of showing as
+        // thousands of added or deleted files.
+        let read = snapshot_git(root, &store, &index, &["read-tree", base.tree()], None)
+            .await
+            .map_err(|e| EngineError::Other(format!("git read-tree failed: {e}")))?;
+        if !read.status.success() {
+            return Err(EngineError::Other(format!(
+                "git read-tree: {}",
+                String::from_utf8_lossy(&read.stderr).trim()
+            )));
+        }
+        let known: std::collections::HashSet<&[u8]> = skipped.iter().map(Vec::as_slice).collect();
+        let inherited: Vec<Vec<u8>> = base
+            .skipped
+            .iter()
+            .filter(|path| !known.contains(path.as_slice()))
+            .cloned()
+            .collect();
+        skipped.extend(inherited);
+    }
+    // NUL-separated pathspecs on stdin: no argv limit, no quoting.
+    let mut pathspecs = b".\0".to_vec();
+    for path in &skipped {
+        pathspecs.extend_from_slice(b":(top,exclude,literal)");
+        pathspecs.extend_from_slice(path);
+        pathspecs.push(0);
+    }
+    let added = snapshot_git(
+        root,
+        &store,
+        &index,
+        &[
+            "add",
+            "-A",
+            "--ignore-errors",
+            "--pathspec-from-file=-",
+            "--pathspec-file-nul",
+        ],
+        Some(pathspecs),
+    )
+    .await
+    .map_err(|e| EngineError::Other(format!("git add failed: {e}")))?;
+    if !added.status.success() {
+        return Err(EngineError::Other(format!(
+            "git add: {}",
+            String::from_utf8_lossy(&added.stderr).trim()
+        )));
+    }
+    let written = snapshot_git(root, &store, &index, &["write-tree"], None)
+        .await
+        .map_err(|e| EngineError::Other(format!("git write-tree failed: {e}")));
+    // The tree is all that is kept; the index can run to tens of megabytes.
+    let _ = tokio::fs::remove_file(&index).await;
+    let written = written?;
+    if !written.status.success() {
+        return Err(EngineError::Other(format!(
+            "git write-tree: {}",
+            String::from_utf8_lossy(&written.stderr).trim()
+        )));
+    }
+    Ok(TreeSnapshot {
+        tree: String::from_utf8_lossy(&written.stdout).trim().to_string(),
+        store,
+        skipped: Arc::new(skipped),
+    })
+}
+
+async fn snapshot_git(
+    root: &Path,
+    store: &ObjectStore,
+    index: &Path,
+    args: &[&str],
+    stdin: Option<Vec<u8>>,
+) -> std::io::Result<std::process::Output> {
+    let mut cmd = tokio::process::Command::new("git");
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        cmd.as_std_mut().creation_flags(0x08000000);
+    }
+    cmd.arg("-C").arg(root).args(args);
+    cmd.env("GIT_INDEX_FILE", index);
+    store.apply_to(&mut cmd);
+    cmd.stdin(if stdin.is_some() {
+        std::process::Stdio::piped()
+    } else {
+        std::process::Stdio::null()
+    });
+    cmd.stdout(std::process::Stdio::piped());
+    cmd.stderr(std::process::Stdio::piped());
+    cmd.kill_on_drop(true);
+    let mut child = cmd.spawn()?;
+    if let Some(input) = stdin
+        && let Some(mut pipe) = child.stdin.take()
+    {
+        // A short pathspec list would drop exclusions, so a failed write is
+        // an error rather than something to carry on from.
+        pipe.write_all(&input).await?;
+        pipe.shutdown().await?;
+    }
+    child.wait_with_output().await
+}
+
+/// The untracked paths `git add` must leave out, as git spells them relative
+/// to the checkout root.
+///
+/// Git lists untracked content as units: a file, or a wholly untracked
+/// directory. A directory over the untracked budget goes as one unit (a build
+/// tree is useless in part); inside the directories that fit, and among loose
+/// files, only files past [`MAX_UNTRACKED_FILE_BYTES`] go. If what remains
+/// still exceeds the budget, every untracked unit goes and the snapshot covers
+/// tracked files only.
+async fn untracked_to_skip(root: &Path) -> Result<Vec<Vec<u8>>, EngineError> {
+    let listing = capture_git(
+        root,
+        &[
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+            "--directory",
+            "-z",
+        ],
+        MAX_UNTRACKED_LISTING_BYTES,
+    )
+    .await?;
+    if listing.truncated {
+        return Err(EngineError::Other(
+            "too many untracked paths to snapshot".into(),
+        ));
+    }
+    let units = split_nul(&listing.stdout);
+    if units.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    // Budget-check directories with a walk that stops at the budget, before
+    // asking git to enumerate them: git lists a directory in full or not at
+    // all, which takes seconds on a build tree. The walk runs on a blocking
+    // thread, which outlives this future if the snapshot times out, so the
+    // guard tells it to stop.
+    let cancel = CancellationToken::new();
+    let _stop_walk = cancel.clone().drop_guard();
+    let walk_root = root.to_path_buf();
+    let walk_units = units.clone();
+    let (mut skipped, dirs, files) =
+        tokio::task::spawn_blocking(move || triage_units(&walk_root, walk_units, &cancel))
+            .await
+            .map_err(|error| EngineError::Other(format!("untracked walk: {error}")))?;
+
+    // Files inside the directories that fit, in git's own spelling: only git
+    // knows which of them are ignored, and the names go back to git as
+    // pathspecs. Loose files are units of their own.
+    let mut measured: Vec<Unit> = files
+        .into_iter()
+        .map(|path| Unit {
+            files: vec![path.clone()],
+            path,
+        })
+        .collect();
+    let dir_units: std::collections::HashMap<Vec<u8>, usize> = dirs
+        .iter()
+        .enumerate()
+        .map(|(index, dir)| (dir.clone(), measured.len() + index))
+        .collect();
+    measured.extend(dirs.iter().map(|dir| Unit {
+        path: dir.clone(),
+        files: Vec::new(),
+    }));
+    for batch in path_batches(&dirs, MAX_PATH_ARGUMENT_BYTES) {
+        let mut args: Vec<OsString> = [
+            "--literal-pathspecs",
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+            "-z",
+            "--",
+        ]
+        .into_iter()
+        .map(OsString::from)
+        .collect();
+        args.extend(batch.iter().map(|dir| path_argument(dir)));
+        let listed = capture_git(root, &args, MAX_UNTRACKED_LISTING_BYTES).await?;
+        if listed.truncated {
+            // Unmeasurable: leave every directory out, keep the loose files.
+            skipped.extend(dirs);
+            return Ok(skipped);
+        }
+        for file in split_nul(&listed.stdout) {
+            // Git's untracked units never nest: the file belongs to the one
+            // listed directory among its ancestors.
+            let owner = file
+                .iter()
+                .enumerate()
+                .filter(|(_, byte)| **byte == b'/')
+                .find_map(|(end, _)| dir_units.get(&file[..=end]));
+            if let Some(&owner) = owner {
+                measured[owner].files.push(file);
+            }
+        }
+    }
+
+    let stat_root = root.to_path_buf();
+    let (oversized, excess) = tokio::task::spawn_blocking(move || fit_units(&stat_root, measured))
+        .await
+        .map_err(|error| EngineError::Other(format!("untracked stat: {error}")))?;
+    skipped.extend(oversized);
+    skipped.extend(excess);
+    Ok(skipped)
+}
+
+/// An untracked unit (a loose file, or a wholly untracked directory) and the
+/// files it holds, as git spells them.
+struct Unit {
+    path: Vec<u8>,
+    files: Vec<Vec<u8>>,
+}
+
+fn split_nul(bytes: &[u8]) -> Vec<Vec<u8>> {
+    bytes
+        .split(|byte| *byte == 0)
+        .filter(|path| !path.is_empty())
+        .map(<[u8]>::to_vec)
+        .collect()
+}
+
+/// Sort untracked units into directories over budget (skipped whole),
+/// directories that fit, and loose files. Git marks a directory with a
+/// trailing slash.
+#[allow(clippy::type_complexity)]
+fn triage_units(
+    root: &Path,
+    units: Vec<Vec<u8>>,
+    cancel: &CancellationToken,
+) -> (Vec<Vec<u8>>, Vec<Vec<u8>>, Vec<Vec<u8>>) {
+    let mut skipped = Vec::new();
+    let mut dirs = Vec::new();
+    let mut files = Vec::new();
+    for unit in units {
+        if cancel.is_cancelled() {
+            break;
+        }
+        if !unit.ends_with(b"/") {
+            files.push(unit);
+        } else if dir_exceeds_budget(&root.join(path_argument(&unit))) {
+            skipped.push(unit);
+        } else {
+            dirs.push(unit);
+        }
+    }
+    (skipped, dirs, files)
+}
+
+/// True once `dir` holds more unignored content than the untracked budget.
+/// Stops at the budget, so the cost is bounded however large the directory
+/// is. Files past the per-file cap count as files but not as bytes: they are
+/// left out one by one, and must not condemn the directory around them.
+fn dir_exceeds_budget(dir: &Path) -> bool {
+    let mut files = 0usize;
+    let mut bytes = 0u64;
+    let walk = ignore::WalkBuilder::new(dir)
+        .hidden(false)
+        .ignore(false)
+        .git_ignore(true)
+        .git_global(true)
+        .git_exclude(true)
+        .filter_entry(|entry| entry.file_name() != ".git")
+        .build();
+    for entry in walk.flatten() {
+        let Some(kind) = entry.file_type() else {
+            continue;
+        };
+        if kind.is_dir() {
+            continue;
+        }
+        files += 1;
+        if kind.is_file()
+            && let Ok(metadata) = entry.metadata()
+            && metadata.len() <= MAX_UNTRACKED_FILE_BYTES
+        {
+            bytes += metadata.len();
+        }
+        if files > MAX_UNTRACKED_FILES || bytes > MAX_UNTRACKED_BYTES {
+            return true;
+        }
+    }
+    false
+}
+
+/// Files past the per-file cap, then the units to leave out so the rest fits
+/// the untracked budget: the largest go first, so one big directory or a
+/// pile of assets costs only itself and new source files keep showing. A
+/// path that vanished since git listed it costs nothing; `git add
+/// --ignore-errors` copes with it.
+fn fit_units(root: &Path, units: Vec<Unit>) -> (Vec<Vec<u8>>, Vec<Vec<u8>>) {
+    let mut oversized = Vec::new();
+    // (path, files, bytes) of what each unit would add.
+    let mut costs = Vec::with_capacity(units.len());
+    for unit in units {
+        let (mut files, mut bytes) = (0usize, 0u64);
+        for file in unit.files {
+            let Ok(metadata) = std::fs::symlink_metadata(root.join(path_argument(&file))) else {
+                continue;
+            };
+            if metadata.is_file() && metadata.len() > MAX_UNTRACKED_FILE_BYTES {
+                oversized.push(file);
+                continue;
+            }
+            files += 1;
+            if metadata.is_file() {
+                bytes += metadata.len();
+            }
+        }
+        costs.push((unit.path, files, bytes));
+    }
+    let mut files: usize = costs.iter().map(|(_, files, _)| files).sum();
+    let mut bytes: u64 = costs.iter().map(|(_, _, bytes)| bytes).sum();
+    let mut excess = Vec::new();
+    if files <= MAX_UNTRACKED_FILES && bytes <= MAX_UNTRACKED_BYTES {
+        return (oversized, excess);
+    }
+    // Largest first, measured against the budget it overruns most.
+    let weight = |unit_files: usize, unit_bytes: u64| {
+        (unit_files as f64 / MAX_UNTRACKED_FILES as f64)
+            .max(unit_bytes as f64 / MAX_UNTRACKED_BYTES as f64)
+    };
+    costs.sort_by(|a, b| weight(b.1, b.2).total_cmp(&weight(a.1, a.2)));
+    for (path, unit_files, unit_bytes) in costs {
+        if files <= MAX_UNTRACKED_FILES && bytes <= MAX_UNTRACKED_BYTES {
+            break;
+        }
+        files -= unit_files;
+        bytes -= unit_bytes;
+        // A loose file's oversized self is already left out.
+        if unit_files > 0 || unit_bytes > 0 {
+            excess.push(path);
+        }
+    }
+    (oversized, excess)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+    use std::path::{Path, PathBuf};
+
+    use super::{
+        MAX_UNTRACKED_BYTES, MAX_UNTRACKED_FILE_BYTES, MAX_UNTRACKED_FILES, STORE_DIR,
+        TreeSnapshot, alternates_value, remove_other_runs, run_id, snapshot_tree,
+    };
+    use crate::repos::Repos;
+
+    async fn git(cwd: &Path, args: &[&str]) {
+        let output = tokio::process::Command::new("git")
+            .args(args)
+            .current_dir(cwd)
+            .env("GIT_AUTHOR_NAME", "test")
+            .env("GIT_AUTHOR_EMAIL", "test@test")
+            .env("GIT_COMMITTER_NAME", "test")
+            .env("GIT_COMMITTER_EMAIL", "test@test")
+            .output()
+            .await
+            .expect("git spawns");
+        assert!(
+            output.status.success(),
+            "git {:?} failed: {}",
+            args,
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    /// A repo with one committed file `a.txt`, and a `Repos` whose data dir
+    /// sits next to it.
+    async fn fixture(tmp: &Path) -> (PathBuf, Repos, PathBuf) {
+        let root = tmp.join("repo");
+        std::fs::create_dir_all(&root).expect("repo dir");
+        git(&root, &["init", "-b", "main"]).await;
+        std::fs::write(root.join("a.txt"), "one\ntwo\n").expect("write a.txt");
+        git(&root, &["add", "."]).await;
+        git(&root, &["commit", "-m", "initial"]).await;
+        let data_dir = tmp.join("data");
+        let repos =
+            Repos::with_worktrees_root(&data_dir, "device-test", data_dir.join("worktrees"));
+        (root, repos, data_dir)
+    }
+
+    /// Every file under the checkout's object database, relative to it.
+    fn checkout_objects(root: &Path) -> BTreeSet<PathBuf> {
+        fn collect(dir: &Path, base: &Path, out: &mut BTreeSet<PathBuf>) {
+            for entry in std::fs::read_dir(dir).expect("read objects dir").flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    collect(&path, base, out);
+                } else {
+                    out.insert(path.strip_prefix(base).expect("under base").to_path_buf());
+                }
+            }
+        }
+        let objects = root.join(".git").join("objects");
+        let mut out = BTreeSet::new();
+        collect(&objects, &objects, &mut out);
+        out
+    }
+
+    /// Paths in the snapshot's tree, read through the snapshot's own store.
+    async fn tree_paths(root: &Path, snapshot: &TreeSnapshot) -> BTreeSet<String> {
+        let mut cmd = tokio::process::Command::new("git");
+        cmd.arg("-C")
+            .arg(root)
+            .args(["ls-tree", "-r", "--name-only", "-z", snapshot.tree()]);
+        snapshot.apply_to(&mut cmd);
+        let output = cmd.output().await.expect("git ls-tree spawns");
+        assert!(
+            output.status.success(),
+            "ls-tree failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        output
+            .stdout
+            .split(|byte| *byte == 0)
+            .filter(|path| !path.is_empty())
+            .map(|path| String::from_utf8_lossy(path).into_owned())
+            .collect()
+    }
+
+    /// A file of `len` zero bytes. Sparse where the filesystem allows, so the
+    /// budget tests do not write hundreds of megabytes.
+    fn many_files(dir: &Path, count: usize) {
+        std::fs::create_dir_all(dir).expect("dir");
+        for i in 0..count {
+            std::fs::write(dir.join(format!("f{i}.txt")), "x").expect("file");
+        }
+    }
+
+    fn sized_file(path: &Path, len: u64) {
+        std::fs::File::create(path)
+            .and_then(|file| file.set_len(len))
+            .expect("sized file");
+    }
+
+    fn store_dirs(data_dir: &Path) -> Vec<PathBuf> {
+        std::fs::read_dir(data_dir.join(STORE_DIR).join(run_id()))
+            .map(|entries| entries.flatten().map(|entry| entry.path()).collect())
+            .unwrap_or_default()
+    }
+
+    /// The incident this module exists for: snapshot blobs written into the
+    /// checkout's `.git/objects`, where auto-maintenance later repacked them.
+    #[tokio::test]
+    async fn snapshot_writes_nothing_into_the_checkout_object_database() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, data_dir) = fixture(tmp.path()).await;
+        std::fs::write(root.join("a.txt"), "one\ntwo\nedited\n").expect("edit a.txt");
+        std::fs::create_dir_all(root.join("build")).expect("build dir");
+        std::fs::write(root.join("build/out.bin"), vec![7u8; 64 * 1024]).expect("out.bin");
+        let before = checkout_objects(&root);
+
+        let turn = snapshot_tree(&repos, &root).await.expect("snapshot");
+        std::fs::write(root.join("later.txt"), "after the snapshot\n").expect("later.txt");
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &turn)
+            .await
+            .expect("turn diff");
+
+        assert_eq!(
+            checkout_objects(&root),
+            before,
+            "snapshot objects leaked into the checkout's object database"
+        );
+        // The snapshot still saw everything, from its own store.
+        assert_eq!(
+            tree_paths(&root, &turn).await,
+            BTreeSet::from(["a.txt".to_string(), "build/out.bin".to_string()])
+        );
+        assert_eq!(diff.files.len(), 1);
+        assert_eq!(diff.files[0].path, "later.txt");
+        // And the tree is invisible to the checkout without that store.
+        let plain = tokio::process::Command::new("git")
+            .arg("-C")
+            .arg(&root)
+            .args(["cat-file", "-e", turn.tree()])
+            .output()
+            .await
+            .expect("git cat-file spawns");
+        assert!(!plain.status.success());
+
+        // The store lives exactly as long as the snapshot.
+        assert_eq!(store_dirs(&data_dir).len(), 1);
+        drop(turn);
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+        while !store_dirs(&data_dir).is_empty() {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "snapshot store was not deleted: {:?}",
+                store_dirs(&data_dir)
+            );
+            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+        }
+    }
+
+    #[tokio::test]
+    async fn oversized_untracked_files_are_left_out() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        std::fs::write(root.join("notes.txt"), "small\n").expect("notes.txt");
+        sized_file(&root.join("dump.bin"), MAX_UNTRACKED_FILE_BYTES + 1);
+        std::fs::create_dir_all(root.join("assets")).expect("assets dir");
+        std::fs::write(root.join("assets/logo.svg"), "<svg/>\n").expect("logo.svg");
+        sized_file(&root.join("assets/video.mov"), MAX_UNTRACKED_FILE_BYTES + 1);
+
+        let snapshot = snapshot_tree(&repos, &root).await.expect("snapshot");
+        assert_eq!(
+            tree_paths(&root, &snapshot).await,
+            BTreeSet::from([
+                "a.txt".to_string(),
+                "assets/logo.svg".to_string(),
+                "notes.txt".to_string(),
+            ])
+        );
+    }
+
+    #[tokio::test]
+    async fn untracked_directory_over_budget_is_left_out_whole() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        std::fs::write(root.join("a.txt"), "one\ntwo\nedited\n").expect("edit a.txt");
+        std::fs::write(root.join("notes.txt"), "small\n").expect("notes.txt");
+        // An unignored build tree: every file fits the per-file cap, the
+        // directory as a whole does not fit the budget.
+        std::fs::create_dir_all(root.join("target-app/debug")).expect("build dir");
+        for i in 0..=MAX_UNTRACKED_BYTES / MAX_UNTRACKED_FILE_BYTES {
+            sized_file(
+                &root.join(format!("target-app/debug/lib{i}.rlib")),
+                MAX_UNTRACKED_FILE_BYTES,
+            );
+        }
+
+        let snapshot = snapshot_tree(&repos, &root).await.expect("snapshot");
+        assert_eq!(
+            tree_paths(&root, &snapshot).await,
+            BTreeSet::from(["a.txt".to_string(), "notes.txt".to_string()])
+        );
+        // More build output during the turn stays out of the turn diff.
+        sized_file(
+            &root.join("target-app/debug/late.rlib"),
+            MAX_UNTRACKED_FILE_BYTES,
+        );
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &snapshot)
+            .await
+            .expect("turn diff");
+        assert!(diff.files.is_empty(), "unexpected: {:?}", diff.files);
+    }
+
+    #[tokio::test]
+    async fn untracked_over_budget_leaves_out_the_largest_units_first() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        std::fs::write(root.join("a.txt"), "one\ntwo\nedited\n").expect("edit a.txt");
+        std::fs::create_dir_all(root.join("docs")).expect("docs dir");
+        std::fs::write(root.join("docs/readme.md"), "small\n").expect("readme.md");
+        // One file-sized unit past the byte budget.
+        let captures = MAX_UNTRACKED_BYTES / MAX_UNTRACKED_FILE_BYTES + 1;
+        for i in 0..captures {
+            sized_file(
+                &root.join(format!("capture-{i}.raw")),
+                MAX_UNTRACKED_FILE_BYTES,
+            );
+        }
+
+        let snapshot = snapshot_tree(&repos, &root).await.expect("snapshot");
+        let paths = tree_paths(&root, &snapshot).await;
+        assert!(paths.contains("a.txt"));
+        assert!(
+            paths.contains("docs/readme.md"),
+            "small files stay: {paths:?}"
+        );
+        let kept = paths
+            .iter()
+            .filter(|path| path.starts_with("capture-"))
+            .count();
+        // 32 captures fill the budget exactly, so the readme's bytes push
+        // one more out: only the excess goes, largest first.
+        assert_eq!(kept as u64, captures - 2, "only the excess is left out");
+        // The tracked edit is still in the tree.
+        let mut cmd = tokio::process::Command::new("git");
+        cmd.arg("-C")
+            .arg(&root)
+            .args(["cat-file", "blob", &format!("{}:a.txt", snapshot.tree())]);
+        snapshot.apply_to(&mut cmd);
+        let output = cmd.output().await.expect("git cat-file spawns");
+        assert_eq!(
+            String::from_utf8_lossy(&output.stdout),
+            "one\ntwo\nedited\n"
+        );
+    }
+
+    /// Directories that each fit but together overrun the budget cost only
+    /// the largest of them: a file the agent adds still shows in the turn.
+    #[tokio::test]
+    async fn new_files_show_when_untracked_directories_overrun_the_budget() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        let per_dir = MAX_UNTRACKED_FILES * 2 / 5;
+        for (dir, count) in [("a", per_dir + 2), ("b", per_dir + 1), ("c", per_dir)] {
+            many_files(&root.join(dir), count);
+        }
+        let turn = snapshot_tree(&repos, &root).await.expect("turn snapshot");
+        std::fs::write(root.join("new.rs"), "fn main() {}\n").expect("new.rs");
+
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &turn)
+            .await
+            .expect("turn diff");
+        let paths: Vec<&str> = diff.files.iter().map(|file| file.path.as_str()).collect();
+        assert_eq!(paths, ["new.rs"]);
+    }
+
+    /// A directory that crosses the budget during a turn keeps its turn-start
+    /// state on both sides instead of diffing as a mass add or delete.
+    #[tokio::test]
+    async fn a_directory_crossing_the_budget_mid_turn_is_not_a_mass_change() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        let gen_dir = root.join("gen");
+
+        // Fits at turn start, over budget after one more file.
+        many_files(&gen_dir, MAX_UNTRACKED_FILES);
+        let turn = snapshot_tree(&repos, &root).await.expect("turn snapshot");
+        std::fs::write(gen_dir.join("extra.txt"), "x").expect("extra");
+        std::fs::write(root.join("a.txt"), "one\ntwo\nthree\n").expect("edit a.txt");
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &turn)
+            .await
+            .expect("turn diff");
+        let paths: Vec<&str> = diff.files.iter().map(|file| file.path.as_str()).collect();
+        assert_eq!(paths, ["a.txt"], "grew past the budget");
+
+        // Over budget at turn start, fits after the turn removed files.
+        let turn = snapshot_tree(&repos, &root).await.expect("turn snapshot");
+        std::fs::remove_file(gen_dir.join("extra.txt")).expect("remove extra");
+        std::fs::remove_file(gen_dir.join("f0.txt")).expect("remove f0");
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &turn)
+            .await
+            .expect("turn diff");
+        assert!(
+            diff.files.is_empty(),
+            "shrank under the budget: {:?}",
+            diff.files.len()
+        );
+    }
+
+    /// The Changes pane reads a file's turn-start text straight from the
+    /// snapshot tree, which only the snapshot's store can resolve.
+    #[tokio::test]
+    async fn turn_start_text_is_read_from_the_snapshot_store() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        std::fs::write(root.join("pre.txt"), "before the turn\n").expect("pre.txt");
+        let turn = snapshot_tree(&repos, &root).await.expect("snapshot");
+        std::fs::write(root.join("pre.txt"), "before the turn\nedited in turn\n")
+            .expect("edit pre.txt");
+
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &turn)
+            .await
+            .expect("turn diff");
+        let file = diff
+            .files
+            .iter()
+            .find(|file| file.path == "pre.txt")
+            .expect("pre.txt summary");
+        let pair =
+            crate::diff_sync::read_diff_file_text_at(&root, turn.tree(), Some(&turn), None, file)
+                .await
+                .expect("file text");
+        assert_eq!(pair.old_text.as_deref(), Some("before the turn\n"));
+        assert_eq!(
+            pair.new_text.as_deref(),
+            Some("before the turn\nedited in turn\n")
+        );
+    }
+
+    #[tokio::test]
+    async fn repository_without_commits_or_files_snapshots_to_the_empty_tree() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let root = tmp.path().join("repo");
+        std::fs::create_dir_all(&root).expect("repo dir");
+        git(&root, &["init", "-b", "main"]).await;
+        let data_dir = tmp.path().join("data");
+        let repos =
+            Repos::with_worktrees_root(&data_dir, "device-test", data_dir.join("worktrees"));
+
+        let snapshot = snapshot_tree(&repos, &root).await.expect("snapshot");
+        assert_eq!(snapshot.tree(), crate::diff_sync::EMPTY_TREE_SHA);
+    }
+
+    /// A linked worktree keeps its objects in the main checkout's database.
+    /// The snapshot has to borrow from there: `a.txt` is unchanged at turn
+    /// start, so its blob exists nowhere else.
+    #[tokio::test]
+    async fn linked_worktree_snapshot_borrows_the_shared_object_database() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, repos, _data_dir) = fixture(tmp.path()).await;
+        let linked = tmp.path().join("linked");
+        git(
+            &root,
+            &["worktree", "add", "-b", "side", &linked.to_string_lossy()],
+        )
+        .await;
+        let before = checkout_objects(&root);
+
+        let turn = snapshot_tree(&repos, &linked).await.expect("snapshot");
+        std::fs::write(linked.join("a.txt"), "one\ntwo\nedited in turn\n").expect("edit a.txt");
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &linked, &turn)
+            .await
+            .expect("turn diff");
+        assert_eq!(diff.files.len(), 1);
+        let pair = crate::diff_sync::read_diff_file_text_at(
+            &linked,
+            turn.tree(),
+            Some(&turn),
+            None,
+            &diff.files[0],
+        )
+        .await
+        .expect("file text");
+        assert_eq!(pair.old_text.as_deref(), Some("one\ntwo\n"));
+        assert_eq!(checkout_objects(&root), before);
+    }
+
+    /// The store's path travels in an environment list that git splits on
+    /// `:`; a layered snapshot can only find its base if that survives.
+    #[cfg(not(windows))]
+    #[tokio::test]
+    async fn snapshot_works_from_a_data_dir_containing_the_list_separator() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let (root, _repos, _data_dir) = fixture(tmp.path()).await;
+        let data_dir = tmp.path().join("da:ta");
+        let repos =
+            Repos::with_worktrees_root(&data_dir, "device-test", data_dir.join("worktrees"));
+        std::fs::write(root.join("pre.txt"), "before the turn\n").expect("pre.txt");
+        let turn = snapshot_tree(&repos, &root).await.expect("snapshot");
+        std::fs::write(root.join("pre.txt"), "before the turn\nedited in turn\n")
+            .expect("edit pre.txt");
+
+        let diff = crate::diff_sync::capture_turn_diff(&repos, &root, &turn)
+            .await
+            .expect("turn diff");
+        assert!(diff.patch.contains("+edited in turn"));
+        assert!(!diff.patch.contains("+before the turn"));
+    }
+
+    #[test]
+    fn stale_run_stores_are_removed_and_the_current_run_is_kept() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let parent = tmp.path().join(STORE_DIR);
+        let stale = parent.join("4242-1700000000000000").join("snapshot");
+        let current = parent.join(run_id()).join("snapshot");
+        std::fs::create_dir_all(stale.join("objects")).expect("stale store");
+        std::fs::write(stale.join("objects").join("blob"), "left behind").expect("stale blob");
+        std::fs::create_dir_all(current.join("objects")).expect("current store");
+
+        remove_other_runs(&parent, std::ffi::OsStr::new(run_id()));
+        assert!(!parent.join("4242-1700000000000000").exists());
+        assert!(current.join("objects").is_dir());
+        // A data dir that never held a store is fine too.
+        remove_other_runs(&tmp.path().join("missing"), std::ffi::OsStr::new(run_id()));
+    }
+
+    #[cfg(not(windows))]
+    #[test]
+    fn alternates_quote_a_directory_containing_the_separator() {
+        let plain = Path::new("/repo/.git/objects");
+        let colon = Path::new("/data:dir/say \"hi\"/objects");
+        assert_eq!(
+            alternates_value(&[colon, plain]),
+            std::ffi::OsString::from("\"/data:dir/say \\\"hi\\\"/objects\":/repo/.git/objects")
+        );
+    }
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 292d8eddea..4d47d3bc2c 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -49,7 +49,7 @@ pub use agent_accounts::{AgentAccounts, AgentAccountsConfig};
 pub use auth::{Auth, AuthConfig, AuthState, AuthUser, OrgMembership};
 pub use change_requests::{ChangeRequestCacheKey, CheckoutChangeRequests};
 pub use diff_sync::{
-    CheckoutDiffSync, DiffFileTextPair, DiffSidecar, DiffSnapshot, TurnSnapshot,
+    CheckoutDiffSync, DiffFileTextPair, DiffSidecar, DiffSnapshot, TreeSnapshot, TurnSnapshot,
     capture_commit_diff, capture_diff, capture_diff_against, capture_turn_diff,
     discard_working_tree, merge_base, read_diff_file_text, snapshot_tree, working_diff_base,
 };
diff --git a/crates/engine/src/rpc.rs b/crates/engine/src/rpc.rs
index d26f7046d3..db850aa8f1 100644
--- a/crates/engine/src/rpc.rs
+++ b/crates/engine/src/rpc.rs
@@ -2710,6 +2710,9 @@ impl RpcService for EngineRpc {
                         return Err(RpcError::Failed("checkoutId does not match cwd".into()));
                     }
                     let root = identity.root.as_path();
+                    // A turn's base tree lives in the snapshot's own object
+                    // store, so the snapshot rides along with its sha.
+                    let mut turn_snapshot = None;
                     let (snapshot, base, target) = match p.mode.as_str() {
                         "branch" => {
                             let base_ref = p
@@ -2761,7 +2764,9 @@ impl RpcService for EngineRpc {
                             ))
                             .await
                             .map_err(|error| RpcError::Failed(error.to_string()))?;
-                            (snapshot, turn.tree, None)
+                            let base = turn.tree.tree().to_string();
+                            turn_snapshot = Some(turn.tree);
+                            (snapshot, base, None)
                         }
                         _ => {
                             let base = Box::pin(crate::diff_sync::working_diff_base(root))
@@ -2797,6 +2802,7 @@ impl RpcService for EngineRpc {
                     let pair = Box::pin(crate::diff_sync::read_diff_file_text_at(
                         root,
                         &base,
+                        turn_snapshot.as_ref(),
                         target.as_deref(),
                         file,
                     ))
@@ -2811,14 +2817,17 @@ impl RpcService for EngineRpc {
                             ))
                             .await
                         }
-                        "turn" => {
-                            Box::pin(crate::diff_sync::capture_turn_diff(
-                                &self.repos,
-                                root,
-                                &base,
-                            ))
-                            .await
-                        }
+                        "turn" => match turn_snapshot.as_ref() {
+                            Some(turn) => {
+                                Box::pin(crate::diff_sync::capture_turn_diff(
+                                    &self.repos,
+                                    root,
+                                    turn,
+                                ))
+                                .await
+                            }
+                            None => Err(crate::EngineError::Other("no turn recorded".into())),
+                        },
                         "commit" => {
                             let sha = p
                                 .commit_sha
diff --git a/crates/engine/tests/m5_repos_diffs_terminals.rs b/crates/engine/tests/m5_repos_diffs_terminals.rs
index bf6f481f0b..3818fcb09b 100644
--- a/crates/engine/tests/m5_repos_diffs_terminals.rs
+++ b/crates/engine/tests/m5_repos_diffs_terminals.rs
@@ -1366,7 +1366,7 @@ async fn turn_diff_captures_only_changes_since_snapshot() {
     // Pre-turn state: a tracked edit and an untracked file already exist.
     std::fs::write(repo_dir.join("a.txt"), "one\ntwo\npre-turn\n").expect("edit a.txt");
     std::fs::write(repo_dir.join("pre.txt"), "before the turn\n").expect("pre.txt");
-    let turn_tree = snapshot_tree(&repo_dir).await.expect("snapshot");
+    let turn_tree = snapshot_tree(&repos, &repo_dir).await.expect("snapshot");
 
     // Nothing changed yet: the turn diff is empty (pre-existing untracked
     // files must NOT reappear as new).

From 91fd851c7c676e1d50d526340f64b7963f548fb6 Mon Sep 17 00:00:00 2001
From: Wing <44917547+wingleeio@users.noreply.github.com>
Date: Thu, 8 Oct 2026 09:57:31 -0700
Subject: [PATCH 64/74] Harden Claude/Codex adapters: no early "done", Stop
 kills, sends never do (#748)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Harden the Claude and Codex adapters: no early "done", Stop kills, sends never do

Builds on the unmerged runtime-survival work (6b25087c, branch
zeron/prevent-sub-agent-collapse): Cancel/sends no longer tear down the
agent process, perTaskStopAffordance, images ride the steering mailbox,
background work holds the idle reaper.

Premature "done" (sound + notification mid-turn), two Claude causes
reproduced live on CLI 2.1.286 and seen 27 times in real journals:
- a `now` steer aborts the turn and the CLI emits a result for it; that
  result was held, then released by a 5s quiet timer while the steered
  turn ran a long tool.
- `--resume` of a session whose background tasks died emits two empty
  results while the new prompt is still queued.
Every stdin user line now carries a uuid and the CLI's command_lifecycle
frames decide the turn end: a result while one of our messages is still
written/queued is a boundary, superseded when that message starts.

Codex: only the turn in flight settles (stale/duplicate completions are
ignored), steers confirm on their userMessage item via
clientUserMessageId, a stop waits for turn/started (an earlier
turn/interrupt is rejected and the turn ran on), and commands still
running past their turn report as background work.

Stop is the one teardown: the user's Stop ends the turn and the whole
runtime, including shells the CLIs start in their own process groups
(snapshot the descendant tree, kill it after the agent). Sends, steers,
"send now" and model/effort switches keep the runtime: Claude adopts new
config with set_model/apply_flag_settings, Codex on the next turn/start.

Stop/Send ordering (found by the new chaos suite, every harness): a Stop
could run before the send queued ahead of it (ignored, or the earlier
steer re-ran after it), and a send after Stop landed in the dying
runtime and was dropped. Commands now act in the order sent, and a
runtime being torn down takes no prompt (late arrivals re-dispatch).

Also: no false "limit reached" error when overage carries a rejected
window.

Tests: fake-CLI scenarios captured from live traffic (each fails on the
old code), mock-engine race tests, and opt-in live suites against the
real CLIs: runtime_survival_live and adapter_chaos_live (10 invariant-
checked scenarios; 30/30 Claude Sonnet 5.5, 30/30 Codex gpt-6-luna).

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

* Address review: OpenCode stop/attachments, Codex config, orphan replay, parked Stop

- OpenCode: a turn stop the server rejects or never acknowledges tears the
  runtime down (mailbox closed first) instead of reporting the turn stopped
  while it may still run. The stopped-turn idle check now unwraps v1's
  /global/event envelope; it never matched, so every stop and interrupt
  waited out the 2s grace.
- OpenCode: messages queued mid-turn keep their images.
- Codex: a message carrying a new model/effort/tier mid-turn waits for its
  own turn/start with that configuration; turn/steer carries none.
- Engine: an accepted-but-unconfirmed message replays with the request it
  was sent with (images, configuration, id), not the chat's latest request.
- Engine: Stop ends a parked runtime that still holds background work.
- pi_rpc tests: new RunControls/SteerMessage fields (CI compile failure).

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

* Every harness adopts model switches in place; reaper waits out the wake

Live-tested all nine local harnesses (runtime_survival_live): Claude and
Codex already kept their process across a model switch; the other seven
restarted it. Now:

- OpenCode: the model and effort ride the next prompt (2.x: set on the
  session first). A switch sent mid-turn starts its own prompt.
- Pi: set_model / set_thinking_level on the live process before the
  message it was sent with.
- ACP (Grok, Devin, Hermes, Antigravity): the session's model, effort and
  options are selected again over the protocol between turns; a switch sent
  mid-turn waits for the session to go quiet, ahead of later messages. A
  set_config_option answer without configOptions now records the value set.
- Cursor: the shim names the new model on the switching message's send and
  every send after it; it never joins a batch or native steer with the
  messages sent before it.

Engine: when background work drains, the idle reaper allows a full window
before reaping. The agent reports the drained set a moment before the turn
its completion wakes, and reaping in that gap lost the wake (#831, caught
by the new live repro).

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

* Durability matrix across all harnesses, and what it caught

The chaos suite now runs every local harness (claude, codex, cursor,
opencode, grok, devin, pi, hermes, antigravity) and adds queued bursts,
Stop while idle, a long silent command, an agent crash mid-turn, two chats
at once and tool approvals. `restart_durability` quits the app mid-turn and
force-kills it mid-turn (a separate process group, SIGKILLed), then checks
nothing reads as still running, the killed turn resumes and finishes, and
the conversation keeps its context. Prompts are conversational: Grok
refuses exact-token demands as injection.

Fixed along the way:
- A force-killed turn whose reply never reached disk (the doc saves on a
  debounce) was never resumed: recovery only looked for a streaming entry.
- A force-killed Claude chat in a symlinked folder (/var, /tmp on macOS)
  resumed in a fresh session, its history gone: the stored cwd is the
  resolved path until a turn's Done; resume now compares directories.
- Sends held for a turn-boundary agent (Hermes, Antigravity) lost their
  images and model, and each handover pinged "done" while they waited.
  They now run as sent, and no turn ends with a completion while a message
  the user already sent is still on its way (held, or still in the command
  log after the agent outran a burst).
- A Stop did not cancel messages sent before it that were held for the
  turn's end, or whose dispatch was still in flight: the next send thawed
  them, or they started the stopped work again in a fresh runtime.
- ACP agents, Pi, OpenCode and Cursor only killed the agent's process
  group: a command the agent ran in its own session (Devin) outlived Stop
  and quitting the app. Teardown now takes the whole descendant tree, as
  Claude and Codex already did.

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

* Drop a needless borrow in the ACP config selection

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

* Stop is one boundary: no early Done, no replayed steer (review)

From the adversarial review (both reproduced against simulated providers
first, each test fails without its fix):

- Claude: "Send now" over a turn end held for a queued steer released
  that Done the moment the stop was asked, before the CLI answered. The
  host then sent the replacement, and the stopped turn's late result
  settled it early and cleared its pending delivery. The stopped turn's
  one Done now goes out when the stop settles (its own result, or the
  settle window), and a result arriving just after it from that turn is
  dropped.
- ACP: a stop left a steer's in-flight `_session/steering` call alive; its
  promptRequired answer, once the turn was cancelled, queued the cancelled
  message again and it ran after all. The stop now drops the call, and
  steering answers are ignored while a turn stops.

CI: `tree_teardown_reaches_shells_in_their_own_process_group` raced the
fixture's setpgid (two descendants existing did not mean the group did).
The fixture now reports its pid once it leads its group, and is killed
even when an assertion fails.

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

* Claude: never drop a replacement's own end as a stopped turn's late result

8c575d41 dropped any result arriving within the stop's settle window
unless the CLI had confirmed a new message started. A CLI that sends
neither command_lifecycle nor a replay never confirms one, so a quick
replacement's own result was dropped and the chat stayed Working
(reported in review, reproduced with a simulated CLI).

A result is now dropped as the stopped turn's only when nothing has
happened since the stop's Done: no message written, no output streamed.
Anything else takes the ordinary path — held while a message is
unconfirmed, settled by the existing fallback.

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

* Claude: judge a stopped turn's late result before it expands

e29fb828 counted every non-Done event as fresh activity, but a result
frame expands to Usage then Done: a stale result's own Usage marked it
fresh, and it was forwarded as a second Done (an Errored one fails the
parked session and its runtime). Reported in review, reproduced with a
simulated CLI.

The stale check now runs on the result frame before it expands, and drops
it whole (usage included). Activity since the stop is a message written
or genuine content — text, reasoning, tool calls and results, questions,
subagent events — never usage or a completed-message marker.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock                                    |    1 +
 crates/engine/Cargo.toml                      |    4 +-
 crates/engine/src/doc_host.rs                 |  281 +++-
 crates/engine/src/rpc.rs                      |    4 +-
 crates/engine/src/sessions.rs                 |  446 ++++-
 crates/engine/src/titles.rs                   |    1 +
 crates/engine/tests/adapter_chaos_live.rs     | 1442 +++++++++++++++++
 crates/engine/tests/restart_resume.rs         |  185 +++
 crates/engine/tests/rich_composer_delivery.rs |   18 +-
 crates/engine/tests/runtime_survival.rs       | 1040 ++++++++++++
 crates/engine/tests/runtime_survival_live.rs  |  795 +++++++++
 .../examples/cursor_stability_probe.rs        |   10 +-
 .../harness/examples/cursor_steering_probe.rs |    3 +
 crates/harness/examples/devin_models_probe.rs |    1 +
 .../harness/examples/grok_subagent_probe.rs   |    1 +
 .../examples/opencode_subagent_probe.rs       |    1 +
 .../harness/examples/opencode_turn_probe.rs   |    1 +
 crates/harness/examples/steering_probe.rs     |    3 +-
 crates/harness/src/acp/mod.rs                 |  565 +++++--
 crates/harness/src/claude/mod.rs              |  509 +++++-
 crates/harness/src/claude/normalize.rs        |   28 +-
 crates/harness/src/claude/wire.rs             |  154 +-
 crates/harness/src/codex/mod.rs               |  403 ++++-
 crates/harness/src/cursor/mod.rs              |   53 +-
 crates/harness/src/cursor/shim.mjs            |   72 +-
 crates/harness/src/lib.rs                     |  135 ++
 crates/harness/src/opencode/mod.rs            |  300 +++-
 crates/harness/src/opencode/tests.rs          |    5 +
 crates/harness/src/pi/mod.rs                  |   93 +-
 crates/harness/src/process.rs                 |  122 ++
 crates/harness/src/process/owned.rs           |   10 +
 crates/harness/tests/acp.rs                   |  230 +++
 crates/harness/tests/acp_quiet.rs             |    9 +
 crates/harness/tests/acp_stall.rs             |    1 +
 crates/harness/tests/claude.rs                |  524 ++++++
 crates/harness/tests/codex.rs                 |  286 +++-
 crates/harness/tests/cursor.rs                |    9 +
 crates/harness/tests/cursor_shim.rs           |   60 +
 crates/harness/tests/fixtures/fake-acp.sh     |   85 +
 crates/harness/tests/fixtures/fake-claude.sh  |  224 +++
 crates/harness/tests/fixtures/fake-codex.sh   |  122 ++
 .../tests/fixtures/fake-cursor-sdk.mjs        |    5 +-
 crates/harness/tests/fixtures/pi_rpc.rs       |    5 +-
 crates/harness/tests/managed_install.rs       |    1 +
 .../harness/tests/managed_install_failure.rs  |    1 +
 crates/harness/tests/opencode.rs              |  277 ++++
 crates/harness/tests/pi_live.rs               |   14 +-
 crates/harness/tests/pi_rpc.rs                |   57 +
 crates/harness/tests/real_acp_lifecycle.rs    |    3 +-
 crates/harness/tests/real_quiet_survey.rs     |    1 +
 crates/harness/tests/windows_native.rs        |    3 +
 51 files changed, 8071 insertions(+), 532 deletions(-)
 create mode 100644 crates/engine/tests/adapter_chaos_live.rs
 create mode 100644 crates/engine/tests/runtime_survival.rs
 create mode 100644 crates/engine/tests/runtime_survival_live.rs

diff --git a/Cargo.lock b/Cargo.lock
index 9221c1fe32..d9cc4f63ed 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13040,6 +13040,7 @@ dependencies = [
  "tokio-util",
  "toml 0.8.23",
  "tracing",
+ "tracing-subscriber",
  "uuid",
  "windows-sys 0.61.2",
  "zeron-doc",
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index d74bd6d0c0..7b883cd14b 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -43,9 +43,11 @@ tempfile.workspace = true
 windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_Pipes", "Win32_System_Threading"] }
 
 [dev-dependencies]
-tokio = { workspace = true, features = ["test-util"] }
+tracing-subscriber.workspace = true
 zeron-mcp.workspace = true
 zeron-harness = { workspace = true, features = ["installer-fixture"] }
+# Paused-clock tests (the 30-minute idle reaper).
+tokio = { workspace = true, features = ["test-util"] }
 zip.workspace = true
 tokio-tungstenite.workspace = true
 # In-process registry server for the two-engine workspace integration tests.
diff --git a/crates/engine/src/doc_host.rs b/crates/engine/src/doc_host.rs
index fcf4c7377b..b08e6e19a2 100644
--- a/crates/engine/src/doc_host.rs
+++ b/crates/engine/src/doc_host.rs
@@ -560,6 +560,14 @@ pub struct ChatDocHandle {
     /// Queue rows held as explicit steers for a turn-boundary agent. They
     /// lead ordinary queued rows, in the order they were steered.
     steered_rows: Mutex<Vec<String>>,
+    /// Sends held for a turn-boundary agent's turn end (rather than queued
+    /// by the user), with the run configuration each was sent with: the row
+    /// carries only its text and images.
+    held_sends: Mutex<HashMap<String, zeron_proto::RunRequest>>,
+    /// The latest Stop command that has acted. A prompt sent before it that
+    /// only executes now (a loaded host, a slow agent) was cancelled by it:
+    /// running it would start the stopped work again in a fresh runtime.
+    stopped_by: Mutex<Option<String>>,
     /// An explicit user interrupt freezes automatic queue delivery. The next
     /// explicit prompt or queue send resumes it; incidental doc/status changes
     /// must not turn Cancel into "send the next row".
@@ -650,6 +658,47 @@ impl Drop for ChatDocHandle {
 }
 
 impl ChatDocHandle {
+    /// The turn ending now is followed at once by a message the user has
+    /// already sent: one still on its way through the command log (a burst
+    /// the agent outran), or one held for a turn-boundary agent's turn end.
+    /// The work goes on, so the end is not a completion to notify.
+    pub(crate) fn continues_with_sent_message(&self) -> bool {
+        // Not yet in the transcript: delivery writes the user's message
+        // before dispatching it, so the command that started the turn now
+        // ending (still marked pending a moment longer) never counts.
+        let in_flight = self.doc.read_commands().is_ok_and(|commands| {
+            let pending: Vec<&str> = commands
+                .iter()
+                .filter(|c| c.status == SessionCommandStatus::Pending)
+                .filter_map(|c| match &c.payload {
+                    SessionCommandPayload::Run { message_id, .. } => Some(message_id.as_str()),
+                    SessionCommandPayload::Steer { message_id, .. } => {
+                        Some(message_id.as_deref().unwrap_or(c.id.as_str()))
+                    }
+                    _ => None,
+                })
+                .collect();
+            !pending.is_empty()
+                && self.doc.read_entries().is_ok_and(|entries| {
+                    pending
+                        .iter()
+                        .any(|id| !entries.iter().any(|e| e.id == *id))
+                })
+        });
+        if in_flight {
+            return true;
+        }
+        if self.queue_paused.load(Ordering::Acquire) {
+            return false;
+        }
+        let Ok(Some(head)) = self.doc.read_queue().map(|q| q.into_iter().next()) else {
+            return false;
+        };
+        head.delivery_gate.is_none()
+            && (lock(&self.held_sends).contains_key(&head.id)
+                || lock(&self.steered_rows).contains(&head.id))
+    }
+
     /// Live views and agents retain their documents and resist idle retirement.
     /// At capacity their transports can yield without dropping these leases.
     fn sync_protected(&self) -> bool {
@@ -1529,6 +1578,8 @@ impl DocHost {
             drain_lock: tokio::sync::Mutex::new(()),
             command_drain_lock: tokio::sync::Mutex::new(()),
             steered_rows: Mutex::new(Vec::new()),
+            held_sends: Mutex::new(HashMap::new()),
+            stopped_by: Mutex::new(None),
             queue_paused: AtomicBool::new(recovered_queue_pending),
             mirror_dirty: AtomicBool::new(true),
             last_access: AtomicI64::new(now_ms()),
@@ -4054,19 +4105,98 @@ impl DocHost {
         }
     }
 
+    /// A Stop acts on everything sent before it, in the order the user sent
+    /// it. Controls bypass the prompt drain (so a stalled provider stays
+    /// stoppable), which let a Stop execute before a send queued ahead of it
+    /// had dispatched: with no turn yet it did nothing and the turn then ran
+    /// in full; mid-turn, the earlier steer landed after the Stop and read as
+    /// the user's next message, re-running in the fresh runtime. Wait for
+    /// earlier prompts to dispatch (milliseconds) — bounded short while a
+    /// turn is in flight, so a provider wedged on backpressure still stops.
+    async fn await_earlier_prompts(
+        &self,
+        sessions: &SessionsEngine,
+        handle: &Arc<ChatDocHandle>,
+        stop_id: &str,
+    ) {
+        let started = tokio::time::Instant::now();
+        loop {
+            let bound = if sessions.turn_in_flight(&handle.chat_id) {
+                std::time::Duration::from_secs(2)
+            } else {
+                std::time::Duration::from_secs(15)
+            };
+            if started.elapsed() >= bound {
+                return;
+            }
+            let Ok(commands) = handle.doc.read_commands() else {
+                return;
+            };
+            let Some(at) = commands.iter().position(|c| c.id == stop_id) else {
+                return;
+            };
+            let earlier_prompt = commands[..at].iter().any(|c| {
+                c.status == SessionCommandStatus::Pending
+                    && matches!(
+                        c.payload,
+                        SessionCommandPayload::Run { .. } | SessionCommandPayload::Steer { .. }
+                    )
+            });
+            if !earlier_prompt {
+                return;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+        }
+    }
+
+    /// A prompt queued after a control that is still executing (a Stop
+    /// tearing the runtime down) waits for it: running ahead of it put the
+    /// user's next message into the runtime the Stop was killing.
+    async fn await_earlier_controls(&self, handle: &Arc<ChatDocHandle>, prompt_id: &str) {
+        let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(30);
+        while tokio::time::Instant::now() < deadline {
+            let Ok(commands) = handle.doc.read_commands() else {
+                return;
+            };
+            let Some(at) = commands.iter().position(|c| c.id == prompt_id) else {
+                return;
+            };
+            let earlier_control = {
+                let executing = lock(&self.inner.executing);
+                commands[..at].iter().any(|c| {
+                    c.status == SessionCommandStatus::Pending
+                        && !matches!(
+                            c.payload,
+                            SessionCommandPayload::Run { .. } | SessionCommandPayload::Steer { .. }
+                        )
+                        && executing.contains(&c.id)
+                })
+            };
+            if !earlier_control {
+                return;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+        }
+    }
+
     /// Stop the active turn without treating the resulting Idle transition as
     /// permission to release the next queued message. The same lock used by
     /// drains closes the race between clicking Cancel and the status watcher.
+    /// A parked runtime still running background work is stopped too: the
+    /// idle reaper spares it, so Stop is what ends that work.
     async fn interrupt_and_pause_queue(
         &self,
         sessions: &SessionsEngine,
         handle: &Arc<ChatDocHandle>,
     ) -> Result<bool, EngineError> {
         let _drain = handle.drain_lock.lock().await;
-        if !sessions.turn_in_flight(&handle.chat_id) {
+        if !sessions.turn_in_flight(&handle.chat_id)
+            && !sessions.holds_background_work(&handle.chat_id)
+        {
             return Ok(false);
         }
         handle.queue_paused.store(true, Ordering::Release);
+        self.cancel_held_sends(handle);
         match sessions.interrupt(&handle.chat_id).await {
             Ok(true) => Ok(true),
             Ok(false) => {
@@ -4080,6 +4210,33 @@ impl DocHost {
         }
     }
 
+    /// A Stop cancels the messages sent during the turn it stops: the sends
+    /// and steers held for that turn's end leave the queue (the user's own
+    /// queued rows stay, paused) and land in the transcript unrun — never
+    /// to start the stopped work again in the next runtime.
+    fn cancel_held_sends(&self, handle: &Arc<ChatDocHandle>) {
+        let held: Vec<String> = {
+            let mut sends = lock(&handle.held_sends);
+            let mut steered = lock(&handle.steered_rows);
+            let ids = sends.keys().cloned().chain(steered.drain(..)).collect();
+            sends.clear();
+            ids
+        };
+        let mut changed = false;
+        for id in held {
+            let Ok(Some(row)) = handle.doc.take_queued(&id) else {
+                continue;
+            };
+            changed = true;
+            if let Err(err) = handle.write_user_message(&row.id, &row.text, row.issued_at) {
+                tracing::warn!(chat = %handle.chat_id, error = %err, "cancelled held send write failed");
+            }
+        }
+        if changed {
+            handle.publish_queue();
+        }
+    }
+
     /// Send one taken queue row.
     async fn dispatch_queued(
         &self,
@@ -4102,7 +4259,14 @@ impl DocHost {
             ));
         }
         let mut attachments = item.attachments.clone();
-        let mut prompt = queued_message_prompt(&item.text, &attachments);
+        // A send held for the turn end goes out exactly as it was sent: its
+        // text never carried the queue's image note.
+        let held = lock(&handle.held_sends).remove(&item.id);
+        let mut prompt = if held.is_some() {
+            item.text.clone()
+        } else {
+            queued_message_prompt(&item.text, &attachments)
+        };
         self.resolve_attachment_refs(&mut prompt, &mut attachments);
         if send == QueueSend::Steer {
             match sessions
@@ -4122,20 +4286,24 @@ impl DocHost {
         }
         // Same reading of "busy" as the drain: a turn parked on a question is
         // still a turn, and it has to be stopped before this one starts.
+        // The message replaces the turn, not the agent: its background work
+        // keeps running (only the user's Stop tears that down).
         if send == QueueSend::Interrupt && sessions.turn_in_flight(chat_id) {
-            sessions.interrupt(chat_id).await?;
+            sessions.stop_turn(chat_id).await?;
         }
         let previous = sessions.last_request(chat_id);
-        let request = self
-            .request_from_chat_row(chat_id, &prompt)
-            .map(|mut current| {
-                if let Some(previous) = &previous {
-                    current.auto_approve = previous.auto_approve;
-                    current.worktree = previous.worktree.clone();
-                }
-                current
-            })
-            .or(previous);
+        // ... and on its model, effort and options, not the chat's saved ones.
+        let request = held.or_else(|| {
+            self.request_from_chat_row(chat_id, &prompt)
+                .map(|mut current| {
+                    if let Some(previous) = &previous {
+                        current.auto_approve = previous.auto_approve;
+                        current.worktree = previous.worktree.clone();
+                    }
+                    current
+                })
+                .or(previous)
+        });
         let Some(mut request) = request else {
             return Err(EngineError::Other(
                 "no live run and no prior run config".into(),
@@ -4605,8 +4773,12 @@ impl DocHost {
                 CommandDisposition::Skip => Ok("duplicate"),
                 CommandDisposition::Expired => Ok("expired"),
                 CommandDisposition::Superseded => Ok("superseded"),
-                CommandDisposition::Execute => match self.execute(&sessions, &handle, &entry).await
-                {
+                CommandDisposition::Execute => match {
+                    if _prompt_guard.is_some() {
+                        self.await_earlier_controls(&handle, &entry.id).await;
+                    }
+                    self.execute(&sessions, &handle, &entry).await
+                } {
                     Ok(_) => Ok("executed"),
                     Err(err) => Err(err),
                 },
@@ -4997,6 +5169,12 @@ impl DocHost {
                     self.resolve_command(handle, &entry.id, SessionCommandStatus::Superseded, None);
                 }
                 CommandDisposition::Execute => {
+                    if matches!(
+                        entry.payload,
+                        SessionCommandPayload::Run { .. } | SessionCommandPayload::Steer { .. }
+                    ) {
+                        self.await_earlier_controls(handle, &entry.id).await;
+                    }
                     let (status, resolution) = match self.execute(&sessions, handle, &entry).await {
                         Ok(outcome) => outcome,
                         Err(err) => (SessionCommandStatus::Rejected, Some(err.to_string())),
@@ -5160,6 +5338,27 @@ impl DocHost {
         }
     }
 
+    /// `entry` is a prompt sent before the Stop that has already acted on
+    /// this chat: the Stop cancelled it. Returns its message id.
+    fn cancelled_by_stop(
+        &self,
+        handle: &Arc<ChatDocHandle>,
+        entry: &SessionCommandEntry,
+    ) -> Option<String> {
+        let message_id = match &entry.payload {
+            SessionCommandPayload::Run { message_id, .. } => message_id.clone(),
+            SessionCommandPayload::Steer { message_id, .. } => {
+                message_id.clone().unwrap_or_else(|| entry.id.clone())
+            }
+            _ => return None,
+        };
+        let stop = lock(&handle.stopped_by).clone()?;
+        let commands = handle.doc.read_commands().ok()?;
+        let at = commands.iter().position(|c| c.id == entry.id)?;
+        let stop_at = commands.iter().position(|c| c.id == stop)?;
+        (at < stop_at).then_some(message_id)
+    }
+
     async fn execute(
         &self,
         sessions: &SessionsEngine,
@@ -5167,6 +5366,24 @@ impl DocHost {
         entry: &SessionCommandEntry,
     ) -> Result<(SessionCommandStatus, Option<String>), EngineError> {
         let chat_id = &handle.chat_id;
+        if let Some(message_id) = self.cancelled_by_stop(handle, entry) {
+            // Still the user's message: it stays in the transcript, unrun.
+            let prompt = match &entry.payload {
+                SessionCommandPayload::Run { request, .. } => request.prompt.clone(),
+                SessionCommandPayload::Steer { prompt, .. } => prompt.clone(),
+                _ => String::new(),
+            };
+            if let Err(err) =
+                handle.write_user_message(&message_id, &prompt, entry.issued_at.min(now_ms()))
+            {
+                tracing::warn!(chat = %chat_id, error = %err, "cancelled message write failed");
+            }
+            tracing::info!(chat = %chat_id, "prompt sent before a Stop that has acted: cancelled");
+            return Ok((
+                SessionCommandStatus::Applied,
+                Some("cancelled by the Stop sent after it".into()),
+            ));
+        }
         match &entry.payload {
             SessionCommandPayload::Run {
                 request,
@@ -5248,6 +5465,7 @@ impl DocHost {
                         &request.prompt,
                         entry.issued_at,
                         false,
+                        Some(&request),
                     )?;
                     return Ok((
                         SessionCommandStatus::Applied,
@@ -5292,6 +5510,29 @@ impl DocHost {
                 .await
             }
             SessionCommandPayload::Interrupt {} => {
+                self.await_earlier_prompts(sessions, handle, &entry.id)
+                    .await;
+                *lock(&handle.stopped_by) = Some(entry.id.clone());
+                // Sends before this Stop that are still on their way (a slow
+                // dispatch the wait above gave up on) are cancelled with it.
+                if let Ok(commands) = handle.doc.read_commands()
+                    && let Some(at) = commands.iter().position(|c| c.id == entry.id)
+                {
+                    let earlier = commands[..at]
+                        .iter()
+                        .filter(|c| c.status == SessionCommandStatus::Pending)
+                        .filter_map(|c| match &c.payload {
+                            SessionCommandPayload::Run { message_id, .. } => {
+                                Some(message_id.clone())
+                            }
+                            SessionCommandPayload::Steer { message_id, .. } => {
+                                Some(message_id.clone().unwrap_or_else(|| c.id.clone()))
+                            }
+                            _ => None,
+                        })
+                        .collect();
+                    sessions.cancel_sent_messages(&handle.chat_id, earlier);
+                }
                 self.interrupt_and_pause_queue(sessions, handle).await?;
                 Ok((SessionCommandStatus::Applied, None))
             }
@@ -5375,11 +5616,12 @@ impl DocHost {
         prompt: &str,
         issued_at: i64,
         steer: bool,
+        request: Option<&zeron_proto::RunRequest>,
     ) -> Result<(), EngineError> {
         let item = QueuedMessage {
             id: message_id.to_string(),
             text: prompt.to_string(),
-            attachments: Vec::new(),
+            attachments: request.map(|r| r.attachments.clone()).unwrap_or_default(),
             hold_for_turn_end: false,
             issued_by: self.inner.config.device_id.clone(),
             issued_at: issued_at.min(now_ms()),
@@ -5389,6 +5631,9 @@ impl DocHost {
         if handle.doc.read_queue()?.iter().any(|row| row.id == item.id) {
             return Ok(()); // a redelivered command: already held
         }
+        if let Some(request) = request {
+            lock(&handle.held_sends).insert(item.id.clone(), request.clone());
+        }
         if steer {
             handle
                 .doc
@@ -5433,7 +5678,7 @@ impl DocHost {
             && (unsteerable_turn || sessions.defers_to_turn_end(chat_id, None))
         {
             let id = message_id.unwrap_or_else(new_id);
-            self.hold_until_turn_end(handle, &id, &prompt, issued_at, true)?;
+            self.hold_until_turn_end(handle, &id, &prompt, issued_at, true, None)?;
             return Ok((
                 SessionCommandStatus::Applied,
                 Some("held until the turn ends".into()),
@@ -5486,7 +5731,7 @@ impl DocHost {
             }
             SteerOutcome::DeferredByUpdate => {
                 let id = message_id.unwrap_or_else(new_id);
-                self.hold_until_turn_end(handle, &id, &prompt, issued_at, true)?;
+                self.hold_until_turn_end(handle, &id, &prompt, issued_at, true, None)?;
                 // The completed turn's status publication normally re-drains
                 // this queue. Also cover completion racing the enqueue itself.
                 self.drain_queue(handle).await;
diff --git a/crates/engine/src/rpc.rs b/crates/engine/src/rpc.rs
index db850aa8f1..48c9150565 100644
--- a/crates/engine/src/rpc.rs
+++ b/crates/engine/src/rpc.rs
@@ -1188,8 +1188,8 @@ impl EngineRpc {
                 let chat_ids = deleted.chat_ids;
                 tokio::spawn(async move {
                     for chat_id in chat_ids {
-                        if let Err(err) = sessions.interrupt(&chat_id).await {
-                            tracing::debug!(chat = %chat_id, error = %err, "deleteSpace interrupt skipped");
+                        if let Err(err) = sessions.terminate(&chat_id).await {
+                            tracing::debug!(chat = %chat_id, error = %err, "deleteSpace teardown skipped");
                         }
                         doc_host.purge_chat(&chat_id);
                     }
diff --git a/crates/engine/src/sessions.rs b/crates/engine/src/sessions.rs
index 12c8d549fa..48efa8360a 100644
--- a/crates/engine/src/sessions.rs
+++ b/crates/engine/src/sessions.rs
@@ -28,7 +28,7 @@ use zeron_doc::{
     DocError, MessagePart, MessageRole, MessageStatus, STREAM_COMMIT_MS, SegmentWriter, SessionDoc,
     SessionMessageEntry, fold_event_into_parts, sanitize_tool_call,
 };
-use zeron_harness::{CancellationToken, Harness, RunControls, SteerMessage};
+use zeron_harness::{CancellationToken, Harness, RunControls, SteerMessage, TurnControl};
 use zeron_proto::{
     AgentEvent, DoneStatus, HarnessId, RunRequest, Session, SessionStatus, UserInputAnswer,
     UserInputQuestion,
@@ -69,38 +69,47 @@ struct HarnessSessionRef {
     cwd: String,
 }
 
-/// Configuration baked into a live harness runtime. The steering mailbox only
-/// carries prompt text, so routing a request whose model/effort/sandbox changed
-/// would silently run it with the old process configuration. Such requests
+/// The configuration a live harness runtime launched with. The steering
+/// mailbox carries only the prompt (and its images), so a request whose
+/// launch settings differ would silently run with the old process's — it
 /// must replace the runtime and resume its harness-native session instead.
-#[derive(Debug, Clone, PartialEq)]
+/// The driver decides what "differ" means ([`Harness::same_runtime`]): a
+/// replacement kills the runtime's background work, so a setting the
+/// launch never reads, or the same value spelled differently by another
+/// client, must never force one.
+#[derive(Clone)]
 struct RuntimeConfig {
     harness_id: HarnessId,
-    model: Option<String>,
-    reasoning: Option<zeron_proto::ReasoningLevel>,
-    model_options: serde_json::Map<String, serde_json::Value>,
-    cwd: String,
-    sandbox: zeron_proto::SandboxLevel,
-    auto_approve: bool,
-    worktree: Option<zeron_proto::WorktreeSpec>,
+    request: RunRequest,
+    harness: Arc<dyn Harness>,
 }
 
 impl RuntimeConfig {
-    fn from_request(harness_id: HarnessId, request: &RunRequest) -> Self {
+    fn new(harness_id: HarnessId, request: &RunRequest, harness: Arc<dyn Harness>) -> Self {
         Self {
             harness_id,
-            model: request.model.clone(),
-            reasoning: request.reasoning,
-            model_options: request.model_options.clone(),
-            cwd: request.cwd.clone(),
-            sandbox: request.sandbox,
-            auto_approve: request.auto_approve,
-            worktree: request.worktree.clone(),
+            request: request.clone(),
+            harness,
         }
     }
 
     fn can_route(&self, harness_id: HarnessId, request: &RunRequest) -> bool {
-        request.attachments.is_empty() && self == &Self::from_request(harness_id, request)
+        self.harness_id == harness_id && self.harness.same_runtime(&self.request, request)
+    }
+
+    /// How `request` reaches this runtime: `Some(false)` as is, `Some(true)`
+    /// with its configuration adopted in place first
+    /// ([`Harness::reconfigures_in_place`]), `None` only by replacing it.
+    fn route(&self, harness_id: HarnessId, request: &RunRequest) -> Option<bool> {
+        if self.can_route(harness_id, request) {
+            Some(false)
+        } else if self.harness_id == harness_id
+            && self.harness.reconfigures_in_place(&self.request, request)
+        {
+            Some(true)
+        } else {
+            None
+        }
     }
 }
 
@@ -141,6 +150,13 @@ struct RunHandle {
     steer_tx: mpsc::Sender<SteerMessage>,
     /// Harness-level cancellation (protocol interrupt + child teardown).
     interrupt_token: CancellationToken,
+    /// Turn-level stop + the runtime's background-work report. Used for
+    /// stopping a turn when the driver [`Harness::stops_turn_in_place`].
+    turn: TurnControl,
+    stops_turn_in_place: bool,
+    /// The harness stream is open. Before that there is no runtime to keep:
+    /// a stop tears the pending start down instead.
+    started: Arc<std::sync::atomic::AtomicBool>,
     /// Engine-level cancel: arms the run task's grace deadline so a harness that
     /// ignores its token can never strand the run.
     cancel: watch::Sender<bool>,
@@ -156,6 +172,11 @@ struct RunHandle {
     /// This runtime's provider session holds the fork's copied history (a
     /// side chat's bootstrap went out on its run or on one of its steers).
     fork_history_sent: Arc<std::sync::atomic::AtomicBool>,
+    /// The user stopped this runtime: it is being torn down and takes no
+    /// more prompts. Flipped under the ledger lock, so every accepted steer
+    /// is unambiguously before the stop (cancelled with it) or after it
+    /// (re-dispatched to a fresh runtime — never lost).
+    retiring: Arc<std::sync::atomic::AtomicBool>,
 }
 
 /// One accepted-but-unconfirmed steer: enough to re-dispatch it verbatim.
@@ -167,11 +188,23 @@ struct RoutedSteer {
     /// is recorded only when the runtime confirms consuming it (`Steered`).
     /// An orphan re-dispatches the bare prompt, still owing the history.
     fork_history: bool,
+    /// Accepted after the user's Stop began tearing the runtime down: the
+    /// Stop did not cancel it, so the message still runs.
+    after_stop: bool,
+    /// The run configuration it was sent with, images included: an orphan
+    /// re-dispatches exactly this, not whatever the chat's latest request
+    /// became. `None` when the chat had no recorded request.
+    request: Option<Box<RunRequest>>,
 }
 
 struct Inner {
     voice: crate::voice::VoiceManager,
     device_id: String,
+    /// The engine is shutting down: dying runs re-dispatch nothing.
+    shutting_down: std::sync::atomic::AtomicBool,
+    /// Per chat: messages a Stop cancelled while they were still on their
+    /// way (see [`SessionsEngine::cancel_sent_messages`]).
+    cancelled_sends: Mutex<HashMap<String, std::collections::HashSet<String>>>,
     /// Loopback IPC port this engine serves, once known (0 = not serving):
     /// what the injected `zeron mcp` server dials back into.
     ipc_port: std::sync::atomic::AtomicU16,
@@ -227,6 +260,8 @@ impl SessionsEngine {
             inner: Arc::new(Inner {
                 voice: crate::voice::VoiceManager::default(),
                 device_id,
+                shutting_down: std::sync::atomic::AtomicBool::new(false),
+                cancelled_sends: Mutex::new(HashMap::new()),
                 ipc_port: std::sync::atomic::AtomicU16::new(0),
                 journal,
                 registry,
@@ -340,6 +375,14 @@ impl SessionsEngine {
             .is_some_and(is_active)
     }
 
+    /// Whether the chat's live runtime reports background work (subagents,
+    /// background shells) still running — parked or not.
+    pub fn holds_background_work(&self, chat_id: &str) -> bool {
+        lock(&self.inner.runs)
+            .get(chat_id)
+            .is_some_and(|h| h.turn.background_live())
+    }
+
     /// Any run currently working or blocked on input — the auto-updater's
     /// "don't restart from under a session" gate.
     pub fn any_active(&self) -> bool {
@@ -354,7 +397,8 @@ impl SessionsEngine {
     /// but a mailbox delivery writes the user message now — above the reply
     /// still streaming for the message before it. Such prompts belong in the
     /// visible queue. `request` = a Run that may differ from the live config
-    /// (a different config restarts the runtime instead, which is no hold).
+    /// (one the runtime adopts in place still lands in its mailbox; any other
+    /// config restarts the runtime instead, which is no hold).
     pub fn defers_to_turn_end(
         &self,
         chat_id: &str,
@@ -366,7 +410,8 @@ impl SessionsEngine {
         let live = lock(&self.inner.runs).get(chat_id).map(|h| {
             (
                 h.runtime_config.harness_id,
-                h.steerable && request.is_none_or(|(id, r)| h.runtime_config.can_route(id, r)),
+                h.steerable
+                    && request.is_none_or(|(id, r)| h.runtime_config.route(id, r).is_some()),
             )
         });
         live.is_some_and(|(harness, routable)| routable && !self.steers_mid_turn(harness))
@@ -385,7 +430,7 @@ impl SessionsEngine {
     pub fn live_run_steerable(&self, chat_id: &str) -> bool {
         lock(&self.inner.runs)
             .get(chat_id)
-            .is_some_and(|h| h.steerable)
+            .is_some_and(|h| h.steerable && !h.retiring.load(std::sync::atomic::Ordering::Acquire))
     }
 
     /// The last request dispatched for a chat (steer→new-turn fallback).
@@ -533,16 +578,19 @@ impl SessionsEngine {
         let routed = lock(&self.inner.runs).get(chat_id).map(|h| {
             (
                 h.run_id.clone(),
-                h.steerable,
-                h.runtime_config.can_route(harness_id, &request),
+                h.steerable && !h.retiring.load(std::sync::atomic::Ordering::Acquire),
+                h.runtime_config.route(harness_id, &request),
                 h.steer_tx.clone(),
                 h.routed_steers.clone(),
                 h.fork_history_sent.clone(),
+                h.retiring.clone(),
             )
         });
-        if let Some((run_id, steerable, same_runtime, steer_tx, ledger, history_sent)) = routed {
+        if let Some((run_id, steerable, route, steer_tx, ledger, history_sent, retiring)) = routed {
             if idle {
-                return if same_runtime && harness_id == HarnessId::Codex {
+                // No prompt rides an idle start, so nothing could carry an
+                // in-place reconfiguration: only the runtime as is will do.
+                return if route == Some(false) && harness_id == HarnessId::Codex {
                     Ok(run_id)
                 } else {
                     Err(EngineError::Other("incompatible live runtime".into()))
@@ -550,6 +598,8 @@ impl SessionsEngine {
             }
             let user_id = message_id.clone().unwrap_or_else(new_id);
             let mut bootstrap = None;
+            let same_runtime = route.is_some();
+            let reconfigure = route == Some(true);
             let accepted = if steerable && same_runtime {
                 bootstrap =
                     self.warm_fork_history(chat_id, harness_id, &request.prompt, &history_sent);
@@ -566,6 +616,12 @@ impl SessionsEngine {
                         zeron_proto::invocation::harness_prompt(delivered, harness_id)
                     },
                     message_id: Some(user_id.clone()),
+                    // Images ride the mailbox too: replacing the runtime just
+                    // to inline them killed its background work.
+                    attachments: request.attachments.clone(),
+                    // A changed model/effort/option the live process adopts
+                    // in place: replacing it killed its background work.
+                    config: reconfigure.then(|| Box::new(request.clone())),
                 };
                 if let Ok(permit) = steer_tx.reserve().await {
                     // Commit the reserved slot atomically with the update
@@ -579,6 +635,8 @@ impl SessionsEngine {
                                 prompt: request.prompt.clone(),
                                 message_id: user_id.clone(),
                                 fork_history: bootstrap.is_some(),
+                                after_stop: retiring.load(std::sync::atomic::Ordering::Acquire),
+                                request: Some(Box::new(request.clone())),
                             });
                             permit.send(message);
                         })
@@ -590,6 +648,18 @@ impl SessionsEngine {
                 false
             };
             if accepted {
+                if reconfigure {
+                    // The runtime runs this configuration from now on: later
+                    // sends compare against it, and a re-dispatch of an
+                    // orphaned steer starts from it.
+                    if let Some(h) = lock(&self.inner.runs)
+                        .get_mut(chat_id)
+                        .filter(|h| h.run_id == run_id)
+                    {
+                        h.runtime_config.request = request.clone();
+                    }
+                    lock(&self.inner.last_requests).insert(chat_id.to_string(), request.clone());
+                }
                 let handle = self.doc_handle(chat_id)?;
                 handle.write_user_message(&user_id, &request.prompt, now_ms())?;
                 self.note_turn_start(chat_id, &request.cwd);
@@ -624,17 +694,27 @@ impl SessionsEngine {
                 message_id = Some(user_id);
             }
             if !same_runtime {
-                tracing::debug!(
+                tracing::info!(
                     chat = %chat_id,
                     "restarting live harness to apply changed run configuration"
                 );
             }
             // Mailbox closed (runtime mid-teardown / non-steering harness) or
-            // the routed run died with the message reclaimed, or configuration
-            // changed beyond what the text-only mailbox can carry: replace it.
-            self.interrupt(chat_id).await?;
+            // the routed run died with the message reclaimed, or the launch
+            // configuration changed: replace the runtime.
+            self.terminate(chat_id).await?;
         }
 
+        // A Stop sent after this message cancelled it while it was on its
+        // way: never start the stopped work again in a fresh runtime.
+        if let Some(id) = &message_id
+            && lock(&self.inner.cancelled_sends)
+                .get_mut(chat_id)
+                .is_some_and(|ids| ids.remove(id))
+        {
+            tracing::info!(chat = %chat_id, "message cancelled by a later Stop: not dispatched");
+            return Ok(String::new());
+        }
         let harness = self.inner.registry.resolve(harness_id)?;
         let handle = self.doc_handle(chat_id)?;
         let user_id = message_id.unwrap_or_else(new_id);
@@ -692,6 +772,8 @@ impl SessionsEngine {
             })
         };
         let interrupt_token = CancellationToken::new();
+        let turn = TurnControl::default();
+        let started = Arc::new(std::sync::atomic::AtomicBool::new(false));
         let fork_history_sent = Arc::new(std::sync::atomic::AtomicBool::new(false));
         let (voice_handle, realtime, _voice_events) = zeron_harness::codex::realtime::channel();
         let voice_active = Arc::new(VoiceActivity::default());
@@ -701,6 +783,7 @@ impl SessionsEngine {
             request_input,
             steering: steer_rx,
             interrupt: interrupt_token.clone(),
+            turn: turn.clone(),
         };
 
         lock(&self.inner.runs).insert(
@@ -710,14 +793,18 @@ impl SessionsEngine {
                 voice_active: voice_active.clone(),
                 run_id: run_id.clone(),
                 steerable: harness.supports_steering(),
-                runtime_config: RuntimeConfig::from_request(harness_id, &request),
+                runtime_config: RuntimeConfig::new(harness_id, &request, harness.clone()),
                 steer_tx,
                 interrupt_token,
+                stops_turn_in_place: harness.supports_steering() && harness.stops_turn_in_place(),
+                turn: turn.clone(),
+                started: started.clone(),
                 cancel: cancel_tx,
                 engine_tx,
                 pending_inputs,
                 routed_steers: Arc::new(Mutex::new(std::collections::VecDeque::new())),
                 fork_history_sent: fork_history_sent.clone(),
+                retiring: Arc::new(std::sync::atomic::AtomicBool::new(false)),
             },
         );
         self.set_status(
@@ -761,7 +848,9 @@ impl SessionsEngine {
                 resume_injected,
                 startup_retry,
                 fork_history_sent,
+                started,
             },
+            turn,
         ));
         Ok(run_id)
     }
@@ -815,7 +904,7 @@ impl SessionsEngine {
     ) -> Result<SteerOutcome, EngineError> {
         let target = lock(&self.inner.runs)
             .get(chat_id)
-            .filter(|h| h.steerable)
+            .filter(|h| h.steerable && !h.retiring.load(std::sync::atomic::Ordering::Acquire))
             .map(|h| {
                 (
                     h.run_id.clone(),
@@ -823,9 +912,10 @@ impl SessionsEngine {
                     h.steer_tx.clone(),
                     h.routed_steers.clone(),
                     h.fork_history_sent.clone(),
+                    h.retiring.clone(),
                 )
             });
-        let Some((run_id, harness_id, steer_tx, ledger, history_sent)) = target else {
+        let Some((run_id, harness_id, steer_tx, ledger, history_sent, retiring)) = target else {
             return Ok(SteerOutcome::NotSteerable);
         };
         zeron_proto::invocation::validate_harness_invocations(prompt, harness_id)
@@ -833,6 +923,13 @@ impl SessionsEngine {
         let user_id = message_id.unwrap_or_else(new_id);
         let bootstrap = self.warm_fork_history(chat_id, harness_id, prompt, &history_sent);
         let delivered = bootstrap.as_deref().unwrap_or(prompt);
+        // A steer runs on the configuration live now; record it with the
+        // message so a re-dispatch keeps it.
+        let sent_with = self.last_request(chat_id).map(|mut request| {
+            request.prompt = prompt.to_string();
+            request.attachments = Vec::new();
+            Box::new(request)
+        });
         let message = SteerMessage {
             prompt: if harness_id == HarnessId::Opencode {
                 delivered.to_owned()
@@ -840,6 +937,8 @@ impl SessionsEngine {
                 zeron_proto::invocation::harness_prompt(delivered, harness_id)
             },
             message_id: Some(user_id.clone()),
+            attachments: Vec::new(),
+            config: None,
         };
         // Saturation is backpressure, not a dead runtime. Waiting for room
         // preserves the live process and every accepted message in a burst.
@@ -856,6 +955,8 @@ impl SessionsEngine {
                 prompt: prompt.to_string(),
                 message_id: user_id.clone(),
                 fork_history: bootstrap.is_some(),
+                after_stop: retiring.load(std::sync::atomic::Ordering::Acquire),
+                request: sent_with,
             });
             permit.send(message);
         });
@@ -894,21 +995,94 @@ impl SessionsEngine {
         Ok(SteerOutcome::Accepted)
     }
 
-    /// Interrupt the live run, if any. The run settles with a synthetic
-    /// `Done{interrupted}` and its streaming entry stamped `aborted`; this waits
-    /// (bounded) for that settlement so callers observe a consistent doc.
+    /// A Stop acting now cancels these messages, sent before it but still
+    /// on their way: one that reaches dispatch after the runtime went down
+    /// is dropped rather than run in a fresh runtime.
+    pub fn cancel_sent_messages(&self, chat_id: &str, message_ids: Vec<String>) {
+        if message_ids.is_empty() {
+            return;
+        }
+        lock(&self.inner.cancelled_sends)
+            .entry(chat_id.to_string())
+            .or_default()
+            .extend(message_ids);
+    }
+
+    /// The user's Stop: a hard boundary. The in-flight turn ends `aborted`
+    /// and the runtime goes with it — background subagents, background
+    /// shells, everything the agent runs. The next message resumes the
+    /// conversation in a fresh process. (Sending, steering and switching
+    /// models never come here: they keep the runtime and its work.)
     pub async fn interrupt(&self, chat_id: &str) -> Result<bool, EngineError> {
+        self.terminate(chat_id).await
+    }
+
+    /// End the in-flight turn so another prompt can take its place ("send
+    /// now"), keeping the runtime and its background work. Its streaming
+    /// entry is stamped `aborted`; this waits (bounded) for that settlement
+    /// so callers observe a consistent doc. Returns whether there was a turn
+    /// (or runtime) to stop.
+    ///
+    /// A driver that [`Harness::stops_turn_in_place`] ends only the turn: the
+    /// runtime parks with its background work — subagents, background shells
+    /// — still running, and the next prompt routes into it. Drivers without
+    /// that, runs whose harness has not started yet, and stops that do not
+    /// settle fall back to [`Self::terminate`].
+    pub async fn stop_turn(&self, chat_id: &str) -> Result<bool, EngineError> {
+        const STOP_SETTLE: std::time::Duration = std::time::Duration::from_secs(15);
+        let target = lock(&self.inner.runs)
+            .get(chat_id)
+            .filter(|h| {
+                h.stops_turn_in_place && h.started.load(std::sync::atomic::Ordering::Acquire)
+            })
+            .map(|h| (h.run_id.clone(), h.turn.clone(), h.pending_inputs.clone()));
+        let Some((run_id, turn, pending)) = target else {
+            return self.terminate(chat_id).await;
+        };
+        if !self.turn_in_flight(chat_id) {
+            return Ok(false); // parked between turns: nothing to stop
+        }
+        // Unpark questions first: the stopped turn can never be answered.
+        let parked: Vec<_> = lock(&pending).drain().map(|(_, tx)| tx).collect();
+        for tx in parked {
+            let _ = tx.send(Vec::new());
+        }
+        turn.stop_turn();
+        let deadline = tokio::time::Instant::now() + STOP_SETTLE;
+        while tokio::time::Instant::now() < deadline {
+            if !self.is_live(chat_id, &run_id) || !self.turn_in_flight(chat_id) {
+                return Ok(true);
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+        }
+        tracing::warn!(chat = %chat_id, "turn stop did not settle; tearing the runtime down");
+        self.terminate(chat_id).await
+    }
+
+    /// Tear the chat's live runtime down (protocol interrupt, then the
+    /// child). The run settles with a synthetic `Done{interrupted}` and its
+    /// streaming entry stamped `aborted`; this waits (bounded) for that
+    /// settlement. Background work the runtime held dies with it.
+    pub async fn terminate(&self, chat_id: &str) -> Result<bool, EngineError> {
         let target = lock(&self.inner.runs).get(chat_id).map(|h| {
             (
                 h.run_id.clone(),
                 h.interrupt_token.clone(),
                 h.cancel.clone(),
                 h.pending_inputs.clone(),
+                h.routed_steers.clone(),
+                h.retiring.clone(),
             )
         });
-        let Some((run_id, token, cancel, pending)) = target else {
+        let Some((run_id, token, cancel, pending, ledger, retiring)) = target else {
             return Ok(false);
         };
+        // From here the runtime takes no prompt: a send now starts a fresh
+        // runtime, and one that raced into this mailbox is re-dispatched.
+        {
+            let _order = lock(&ledger);
+            retiring.store(true, std::sync::atomic::Ordering::Release);
+        }
         // Publish cancellation BEFORE waking the harness. Otherwise a fast
         // EOF after token.cancel() can beat this watch notification and be
         // classified as an error instead of an interrupted turn.
@@ -996,6 +1170,10 @@ impl SessionsEngine {
                     })
             });
             let attempts = self.inner.journal.resume_attempts(&chat_id);
+            // Fresh: the crashed reply's streaming entry is recent — or no
+            // reply entry reached disk at all (the doc saves on a debounce,
+            // and a kill moments into the turn leaves the user's message as
+            // the transcript's last word), and that message is recent.
             let fresh = handle
                 .doc()
                 .read_entries()
@@ -1005,6 +1183,7 @@ impl SessionsEngine {
                         .iter()
                         .rev()
                         .find(|e| e.status == Some(MessageStatus::Streaming))
+                        .or_else(|| entries.last().filter(|e| e.role == MessageRole::User))
                         .map(|e| now_ms() - e.created_at < RESUME_FRESH_MS)
                 })
                 .unwrap_or(false);
@@ -1091,10 +1270,13 @@ impl SessionsEngine {
 
     /// Graceful shutdown: interrupt every live run so streaming entries settle.
     pub async fn shutdown(&self) {
+        self.inner
+            .shutting_down
+            .store(true, std::sync::atomic::Ordering::Release);
         self.inner.voice.retire();
         let chats: Vec<String> = lock(&self.inner.runs).keys().cloned().collect();
         for chat_id in chats {
-            if let Err(err) = self.interrupt(&chat_id).await {
+            if let Err(err) = self.terminate(&chat_id).await {
                 tracing::warn!(chat = %chat_id, error = %err, "shutdown interrupt failed");
             }
         }
@@ -1320,6 +1502,14 @@ impl Inner {
         lock(&self.doc_host).clone()
     }
 
+    /// A message the user already sent follows the turn that is ending
+    /// (see [`crate::doc_host::ChatDocHandle::continues_with_sent_message`]).
+    fn continues_with_sent_message(&self, chat_id: &str) -> bool {
+        self.doc_host()
+            .and_then(|host| host.open(chat_id).ok())
+            .is_some_and(|handle| handle.continues_with_sent_message())
+    }
+
     /// Zeron's own MCP server for a run of `chat_id`: this binary's `zeron
     /// mcp` subcommand, dialing the engine's IPC port and stamped with the
     /// originating chat + device so the agent's side chats link back here.
@@ -1393,7 +1583,17 @@ impl Inner {
     /// never rides `--resume`. An empty stored id is the explicit tombstone —
     /// no resume, no falling through to staler sources.
     fn resume_for(&self, chat_id: &str, cwd: &str) -> Option<String> {
-        let cwd_ok = |session_cwd: &str| session_cwd.is_empty() || session_cwd == cwd;
+        // The same directory, however it is spelled: an agent reports where
+        // it runs with symlinks resolved (`/private/var/…` for `/var/…` on
+        // macOS), and until a turn's Done restores the request's spelling a
+        // mid-turn crash leaves that one stored — a string compare then
+        // started the resumed run in a fresh session, its history gone.
+        let cwd_ok = |session_cwd: &str| {
+            session_cwd.is_empty()
+                || session_cwd == cwd
+                || std::fs::canonicalize(session_cwd)
+                    .is_ok_and(|a| std::fs::canonicalize(cwd).is_ok_and(|b| a == b))
+        };
         if let Some(known) = lock(&self.harness_sessions).get(chat_id).cloned() {
             return (!known.session_id.is_empty() && cwd_ok(&known.cwd))
                 .then_some(known.session_id);
@@ -1869,6 +2069,8 @@ struct RunResumeState {
     resume_injected: bool,
     startup_retry: bool,
     fork_history_sent: Arc<std::sync::atomic::AtomicBool>,
+    /// Set once the harness stream is open (see [`RunHandle::started`]).
+    started: Arc<std::sync::atomic::AtomicBool>,
 }
 
 fn cursor_unstarted_history(
@@ -1945,6 +2147,7 @@ async fn drive_run(
     mut engine_rx: mpsc::UnboundedReceiver<AgentEvent>,
     mut cancel_rx: watch::Receiver<bool>,
     resume_state: RunResumeState,
+    turn: TurnControl,
 ) {
     let device_id = inner.device_id.clone();
     // Captured for post-run auto-titling (the request moves into the harness).
@@ -2046,7 +2249,12 @@ async fn drive_run(
         Err(error) => Err(error),
     };
     let mut stream = match started {
-        Ok(stream) => stream,
+        Ok(stream) => {
+            resume_state
+                .started
+                .store(true, std::sync::atomic::Ordering::Release);
+            stream
+        }
         Err(err) => {
             let message = err.to_string();
             tracing::warn!(chat = %chat_id, harness = ?harness_id, error = %message, "run failed to start");
@@ -2162,7 +2370,16 @@ async fn drive_run(
     let subagent_silence = session_idle * 8;
     let mut idle_since: Option<tokio::time::Instant> =
         resume_state.idle.then(tokio::time::Instant::now);
+    // A parked runtime whose agent reports background work (see
+    // `TurnControl::background_live`) is not idle: reaping it killed that
+    // work. The reaper re-checks a full idle window later instead.
+    let mut reap_deferred_until: Option<tokio::time::Instant> = None;
+    // The reaper last deferred for background work. Its end is not idleness
+    // either: the agent reports the drained set a moment before the turn the
+    // completion wakes, and reaping in that gap lost the wake (issue #831).
+    let mut held_for_background = false;
     let steerable = harness.supports_steering();
+    let stops_turn_in_place = steerable && harness.stops_turn_in_place();
     // TURN-QUIESCE WATCHDOG (2026-08-12 stuck-Working incident): a harness
     // that loses a turn's Done — the adapter never settles `session/prompt`
     // even though the agent finished — strands Working forever: the live
@@ -2269,7 +2486,12 @@ async fn drive_run(
                 // already durable, so retire the parked process cleanly and let
                 // the queued exclusive lease proceed.
                 _ = tokio::time::sleep_until(tokio::time::Instant::now()),
-                    if idle_since.is_some() && !resume_state.voice_active.live() && inner.registry.update_pending(harness_id) =>
+                    if idle_since.is_some()
+                        && !resume_state.voice_active.live()
+                        && inner.registry.update_pending(harness_id)
+                        && !turn.background_live()
+                        && (subagents.is_empty()
+                            || last_subagent_activity.is_none_or(|at| at.elapsed() >= subagent_silence)) =>
                 {
                     if let Some(token) = lock(&inner.runs)
                         .get(&chat_id)
@@ -2287,17 +2509,35 @@ async fn drive_run(
                 // the window counts from its last activity, and stretches to
                 // `subagent_silence` while its sink is open.
                 _ = tokio::time::sleep_until(
-                    idle_since
-                        .map(|at| {
-                            at.max(last_subagent_activity.unwrap_or(at))
-                                + if subagents.is_empty() { session_idle } else { subagent_silence }
-                        })
-                        .unwrap_or_else(tokio::time::Instant::now)
+                    {
+                        let window = if subagents.is_empty() { session_idle } else { subagent_silence };
+                        let base = idle_since
+                            .map(|at| at.max(last_subagent_activity.unwrap_or(at)) + window);
+                        match (base, reap_deferred_until) {
+                            (Some(base), Some(deferred)) => base.max(deferred),
+                            (base, deferred) => base.or(deferred).unwrap_or_else(tokio::time::Instant::now),
+                        }
+                    }
                 ), if idle_since.is_some() && !resume_state.voice_active.live() => {
                     // A call that began after this wait was armed holds it off.
                     if resume_state.voice_active.live() {
                         continue;
                     }
+                    // The driver's own report of background work (Claude's
+                    // background agents and shells) is authoritative — it
+                    // lists every task the process still runs — so it holds
+                    // the runtime for as long as that work lives.
+                    if turn.background_live() {
+                        tracing::info!(chat = %chat_id, "idle reaper deferred: the agent reports background work");
+                        reap_deferred_until = Some(tokio::time::Instant::now() + session_idle);
+                        held_for_background = true;
+                        continue;
+                    }
+                    if std::mem::take(&mut held_for_background) {
+                        // The work just ended: a full idle window from here.
+                        reap_deferred_until = Some(tokio::time::Instant::now() + session_idle);
+                        continue;
+                    }
                     tracing::info!(
                         chat = %chat_id,
                         live_subagents = subagents.len(),
@@ -2403,7 +2643,8 @@ async fn drive_run(
                     // completion notice, but never notify for an empty boundary
                     // or while an accepted steer still awaits delivery.
                     let completed_turn = ((!folded.is_empty() || writer.is_some())
-                        && !inner.has_pending_steers(&chat_id, &run_id))
+                        && !inner.has_pending_steers(&chat_id, &run_id)
+                        && !inner.continues_with_sent_message(&chat_id))
                         .then(|| entry_id.clone());
                     if !folded.is_empty() || writer.is_some() {
                         if let Err(err) = finish_segment(
@@ -2424,6 +2665,7 @@ async fn drive_run(
                     entry_id = new_id();
                     segment_started = now_ms();
                     idle_since = Some(tokio::time::Instant::now());
+                    reap_deferred_until = None;
                     self_continued_turn = false;
                     inner.set_status_with_completion(
                         &chat_id, SessionStatus::Idle, false, completed_turn,
@@ -2975,19 +3217,37 @@ async fn drive_run(
             {
                 titles.maybe_generate(&chat_id, harness_id, &user_prompt, &run_cwd);
             }
+            // A turn stopped in place: the runtime lives on, parked like a
+            // completed turn. Steers it had accepted but not yet delivered
+            // were cancelled with the turn (never delivered, never
+            // confirmed) — drop them, or they would hold the parked session
+            // Working forever.
+            let stopped_in_place =
+                *status == DoneStatus::Interrupted && stops_turn_in_place && !interrupted;
+            if stopped_in_place
+                && let Some(ledger) = lock(&inner.runs)
+                    .get(&chat_id)
+                    .filter(|h| h.run_id == run_id)
+                    .map(|h| h.routed_steers.clone())
+            {
+                lock(&ledger).clear();
+            }
             // An accepted steer awaiting its boundary owns the continuation:
             // the previous Done is an internal handoff, not a completion ping.
-            // Ordinary queued rows are not in this ledger and still notify.
+            // So does a message the user already sent that is still on its
+            // way (see `continues_with_sent_message`); rows the user queued
+            // themselves still notify.
             let pending_steer = inner.has_pending_steers(&chat_id, &run_id);
             let completed_turn = (*status == DoneStatus::Completed
                 && !interrupted
                 && turn_was_active
-                && !pending_steer)
-                .then(|| entry_id.clone());
+                && !pending_steer
+                && !inner.continues_with_sent_message(&chat_id))
+            .then(|| entry_id.clone());
             // PERSISTENT SESSION: a cleanly completed turn on a steerable
             // harness PARKS instead of ending — child + mailbox stay warm for
             // the next routed dispatch; per-turn state resets for it.
-            if *status == DoneStatus::Completed
+            if (*status == DoneStatus::Completed || stopped_in_place)
                 && steerable
                 && !interrupted
                 && !inner.registry.update_pending(harness_id)
@@ -2999,6 +3259,7 @@ async fn drive_run(
                 // Resume-retry is strictly a first-turn concern.
                 saw_session_started = true;
                 idle_since = Some(tokio::time::Instant::now());
+                reap_deferred_until = None;
                 self_continued_turn = false;
                 // Accepted steers still own this runtime. Publishing Idle
                 // here lets the ordinary queue overtake that continuation.
@@ -3057,7 +3318,19 @@ async fn drive_run(
         .unwrap_or_default();
     inner.remove_run(&chat_id, &run_id);
     inner.set_status_with_completion(&chat_id, final_status, false, final_completed_turn);
-    if !interrupted && !orphans.is_empty() {
+    // A Stop cancels the messages it found waiting; one accepted after it
+    // began is still the user's next message and must run.
+    let orphans: Vec<RoutedSteer> = if inner
+        .shutting_down
+        .load(std::sync::atomic::Ordering::Acquire)
+    {
+        Vec::new()
+    } else if interrupted {
+        orphans.into_iter().filter(|s| s.after_stop).collect()
+    } else {
+        orphans
+    };
+    if !orphans.is_empty() {
         // The dying run accepted these into its mailbox but never confirmed a
         // Steered boundary (idle-reaper race, a mid-turn error discarding
         // queued boundary steers, a parked child death). Their user entries
@@ -3070,13 +3343,16 @@ async fn drive_run(
         let chat = chat_id.clone();
         tokio::spawn(async move {
             for steer in orphans {
-                let Some(mut request) = engine.last_request(&chat) else {
+                let Some(mut request) = steer
+                    .request
+                    .map(|request| *request)
+                    .or_else(|| engine.last_request(&chat))
+                else {
                     tracing::warn!(chat = %chat, "orphaned steer lost: no run config to re-dispatch");
                     break;
                 };
                 request.prompt = steer.prompt.clone();
                 request.resume = None;
-                request.attachments = Vec::new();
                 tracing::info!(chat = %chat, "re-dispatching steer orphaned by a dying run");
                 let Some(host) = engine.inner.doc_host() else {
                     tracing::warn!(chat = %chat, "orphaned steer lost: doc host unavailable");
@@ -3582,12 +3858,36 @@ mod tests {
     #[test]
     fn live_routing_requires_the_same_runtime_configuration() {
         let initial = request();
-        let config = RuntimeConfig::from_request(HarnessId::Grok, &initial);
+        let config = RuntimeConfig::new(
+            HarnessId::Grok,
+            &initial,
+            Arc::new(zeron_harness::AcpHarness::grok()),
+        );
 
         let mut follow_up = initial.clone();
         follow_up.prompt = "second".into();
         follow_up.resume = Some("session-1".into());
         assert!(config.can_route(HarnessId::Grok, &follow_up));
+        assert!(!config.can_route(HarnessId::Devin, &follow_up));
+
+        // Images ride the mailbox: they never force a replacement runtime.
+        follow_up.attachments.push("/tmp/image.png".into());
+        assert!(config.can_route(HarnessId::Grok, &follow_up));
+
+        // Another client's spelling of the same option value is the same runtime.
+        let mut spelled = initial.clone();
+        spelled
+            .model_options
+            .insert("fastMode".into(), serde_json::json!(true));
+        let config = RuntimeConfig::new(
+            HarnessId::Grok,
+            &spelled,
+            Arc::new(zeron_harness::AcpHarness::grok()),
+        );
+        follow_up
+            .model_options
+            .insert("fastMode".into(), serde_json::json!("true"));
+        assert!(config.can_route(HarnessId::Grok, &follow_up));
 
         follow_up.model = Some("grok-4.5".into());
         assert!(!config.can_route(HarnessId::Grok, &follow_up));
@@ -3595,10 +3895,34 @@ mod tests {
 
         follow_up.reasoning = Some(zeron_proto::ReasoningLevel::Medium);
         assert!(!config.can_route(HarnessId::Grok, &follow_up));
-        follow_up.reasoning = initial.reasoning;
+    }
 
-        follow_up.attachments.push("/tmp/image.png".into());
-        assert!(!config.can_route(HarnessId::Grok, &follow_up));
+    #[test]
+    fn claude_routing_compares_what_the_cli_launches_with() {
+        let claude = || -> Arc<dyn Harness> { Arc::new(zeron_harness::ClaudeHarness::new()) };
+        let mut initial = request();
+        initial.model = Some("claude-opus-5-5".into());
+        initial
+            .model_options
+            .insert("fastMode".into(), serde_json::json!(false));
+        let config = RuntimeConfig::new(HarnessId::ClaudeCode, &initial, claude());
+
+        // The CLI never reads the sandbox level; an option that launches no
+        // flag in either spelling is the same runtime.
+        let mut follow_up = initial.clone();
+        follow_up.sandbox = SandboxLevel::DangerFullAccess;
+        follow_up.model_options.clear();
+        follow_up.worktree = None;
+        assert!(config.can_route(HarnessId::ClaudeCode, &follow_up));
+
+        follow_up
+            .model_options
+            .insert("fastMode".into(), serde_json::json!("true"));
+        assert!(!config.can_route(HarnessId::ClaudeCode, &follow_up));
+        follow_up.model_options.clear();
+
+        follow_up.cwd = "/elsewhere".into();
+        assert!(!config.can_route(HarnessId::ClaudeCode, &follow_up));
     }
 
     #[test]
diff --git a/crates/engine/src/titles.rs b/crates/engine/src/titles.rs
index 963c97f3be..82081a5451 100644
--- a/crates/engine/src/titles.rs
+++ b/crates/engine/src/titles.rs
@@ -286,6 +286,7 @@ async fn collect_text(
         }),
         steering: steer_rx,
         interrupt: interrupt.clone(),
+        turn: Default::default(),
     };
     let mut stream = harness.run_title(request, controls).await?;
     let mut text = String::new();
diff --git a/crates/engine/tests/adapter_chaos_live.rs b/crates/engine/tests/adapter_chaos_live.rs
new file mode 100644
index 0000000000..38bd28d6d0
--- /dev/null
+++ b/crates/engine/tests/adapter_chaos_live.rs
@@ -0,0 +1,1442 @@
+//! Opt-in adapter chaos suite against the REAL agent CLIs: the races and edge
+//! shapes where turn-end detection and runtime survival break, each checked
+//! against hard invariants rather than happy-path output.
+//!
+//! ZERON_TEST_HARNESS=claude ZERON_TEST_MODEL=claude-sonnet-5-5 \
+//! ZERON_TEST_OTHER_MODEL=claude-haiku-4-5 ZERON_CHAOS_ROUNDS=3 \
+//!   cargo test -p zeron-engine --test adapter_chaos_live -- --ignored --nocapture
+//!
+//! `ZERON_CHAOS_ONLY=<scenario>` runs one scenario. Invariants, per chat:
+//! - Never "done" early: no agent output after a Done unless a new user turn
+//!   began first (a steer boundary or a fresh process); no Idle→Working flip
+//!   the user did not cause; every requested sentinel present at the end.
+//! - Never stuck: every scenario settles Idle.
+//! - Every routed message is delivered (one steer boundary each).
+//! - One process for the chat's life, except after the user's Stop.
+//! - Nothing the agent started outlives a Stop.
+//!
+//! `ZERON_TEST_HARNESS`: claude | codex | cursor | opencode | grok | devin |
+//! pi | hermes | antigravity. `restart_durability` covers quitting and
+//! force-killing the app mid-turn (same environment variables).
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use zeron_doc::SessionCommandPayload;
+use zeron_engine::{EngineCore, HarnessRegistry};
+use zeron_harness::{
+    AcpHarness, ClaudeHarness, CodexHarness, CursorHarness, Harness, OpencodeHarness, PiHarness,
+};
+use zeron_proto::{
+    AgentEvent, ChatConfig, HarnessId, ReasoningLevel, RunRequest, SandboxLevel, SessionStatus,
+};
+
+struct Suite {
+    core: EngineCore,
+    id: HarnessId,
+    name: String,
+    model: Option<String>,
+    other_model: Option<String>,
+    cwd: String,
+    dir: tempfile::TempDir,
+    /// Unique per harness so parallel suites never count each other's work.
+    sleep_base: u32,
+}
+
+/// What one scenario did and saw.
+struct Chat<'a> {
+    suite: &'a Suite,
+    id: String,
+    sends: Arc<Mutex<Vec<Instant>>>,
+    /// (when, status, last_completed_turn) at every observed change.
+    timeline: Arc<Mutex<Vec<(Instant, SessionStatus, Option<String>)>>>,
+    sentinels: Vec<String>,
+    /// Every message sent: each must start a steer boundary or a process.
+    runs_sent: usize,
+    /// User Stops, and agent deaths this scenario caused: each may cost a
+    /// process.
+    stops: usize,
+    /// The scenario kills the agent: its turn may end errored.
+    allow_errored: bool,
+    monitor: tokio::task::JoinHandle<()>,
+    errors: Vec<String>,
+}
+
+/// The selected harness: its id, a fresh driver, and a probe-marker base
+/// unique to it (so parallel suites never count each other's work).
+fn harness(name: &str) -> (HarnessId, Arc<dyn Harness>, u32) {
+    match name {
+        "claude" => (HarnessId::ClaudeCode, Arc::new(ClaudeHarness::new()), 270),
+        "codex" => (HarnessId::Codex, Arc::new(CodexHarness::new()), 370),
+        "cursor" => (HarnessId::Cursor, Arc::new(CursorHarness::new()), 470),
+        "opencode" => (HarnessId::Opencode, Arc::new(OpencodeHarness::new()), 570),
+        "grok" => (HarnessId::Grok, Arc::new(AcpHarness::grok()), 670),
+        "devin" => (HarnessId::Devin, Arc::new(AcpHarness::devin()), 770),
+        "pi" => (HarnessId::Pi, Arc::new(PiHarness::new()), 870),
+        "hermes" => (HarnessId::Hermes, Arc::new(AcpHarness::hermes()), 970),
+        "antigravity" => (
+            HarnessId::Antigravity,
+            Arc::new(AcpHarness::antigravity()),
+            1070,
+        ),
+        other => panic!("unknown harness {other}"),
+    }
+}
+
+fn engine(dir: &std::path::Path, name: &str) -> EngineCore {
+    let (id, harness, _) = harness(name);
+    let registry = HarnessRegistry::new();
+    registry.register(harness);
+    EngineCore::assemble(&dir.join("engine"), Arc::new(registry), id, None).unwrap()
+}
+
+impl Suite {
+    fn new() -> Self {
+        let name = std::env::var("ZERON_TEST_HARNESS").unwrap_or_else(|_| "claude".into());
+        let (id, _, sleep_base) = harness(&name);
+        let dir = tempfile::tempdir().unwrap();
+        let cwd = dir.path().to_str().unwrap().to_owned();
+        let core = engine(dir.path(), &name);
+        core.workspace
+            .create_space("space", &core.device_id, &cwd, None, false)
+            .unwrap();
+        Self {
+            core,
+            id,
+            name,
+            model: std::env::var("ZERON_TEST_MODEL").ok(),
+            other_model: std::env::var("ZERON_TEST_OTHER_MODEL").ok(),
+            cwd,
+            dir,
+            sleep_base,
+        }
+    }
+
+    fn request(&self, prompt: &str) -> RunRequest {
+        RunRequest {
+            mcp: None,
+            prompt: prompt.into(),
+            harness: Some(self.id),
+            model: self.model.clone(),
+            reasoning: None,
+            model_options: Default::default(),
+            cwd: self.cwd.clone(),
+            sandbox: SandboxLevel::DangerFullAccess,
+            auto_approve: true,
+            attachments: vec![],
+            worktree: None,
+            resume: None,
+        }
+    }
+
+    /// A probe command: sleeps `secs`, tagged with a marker unique to this
+    /// suite and slot so it can be found in the process table.
+    fn probe(&self, slot: u32, secs: u32) -> String {
+        format!(
+            "python3 -c 'import time; zq{}=1; time.sleep({secs})'",
+            self.sleep_base + slot
+        )
+    }
+
+    fn probe_marker(&self, slot: u32) -> String {
+        format!("zq{}=1", self.sleep_base + slot)
+    }
+
+    /// Processes still running one of this suite's probe commands.
+    fn probes_alive(&self) -> usize {
+        let pattern = format!("zq{}[0-9]=1", self.sleep_base / 10);
+        std::process::Command::new("pgrep")
+            .args(["-f", &pattern])
+            .output()
+            .map(|o| {
+                String::from_utf8_lossy(&o.stdout)
+                    .split_whitespace()
+                    .count()
+            })
+            .unwrap_or(0)
+    }
+
+    fn kill_probes(&self) {
+        let pattern = format!("zq{}[0-9]=1", self.sleep_base / 10);
+        let _ = std::process::Command::new("pkill")
+            .args(["-f", &pattern])
+            .status();
+    }
+
+    /// SIGKILL every agent process this test runs, whole trees (an agent
+    /// crash: OOM, `killall`). Only the current scenario's chat holds one:
+    /// each scenario retires its chat's runtime when it ends.
+    fn crash_agents(&self) -> usize {
+        let mut tree = descendants(std::process::id());
+        tree.reverse();
+        for pid in &tree {
+            let _ = std::process::Command::new("kill")
+                .args(["-9", &pid.to_string()])
+                .status();
+        }
+        tree.len()
+    }
+
+    fn chat(&self, scenario: &str, round: usize) -> Chat<'_> {
+        let id = format!("{scenario}-{round}");
+        self.core
+            .workspace
+            .create_chat(&id, Some("space"), None, None, None)
+            .unwrap();
+        self.core
+            .workspace
+            .set_chat_config(
+                &id,
+                &ChatConfig {
+                    harness: self.id,
+                    model: self.model.clone(),
+                    reasoning: None,
+                    model_options: Default::default(),
+                    sandbox: SandboxLevel::DangerFullAccess,
+                },
+            )
+            .unwrap();
+        let timeline = Arc::new(Mutex::new(Vec::new()));
+        let monitor = {
+            let sessions = self.core.sessions.clone();
+            let timeline = timeline.clone();
+            let chat = id.clone();
+            tokio::spawn(async move {
+                let mut last = None;
+                loop {
+                    let now = sessions
+                        .session_status(&chat)
+                        .map(|s| (s.status, s.last_completed_turn));
+                    if now.is_some() && now != last {
+                        let (status, ping) = now.clone().unwrap();
+                        timeline
+                            .lock()
+                            .unwrap()
+                            .push((Instant::now(), status, ping));
+                        last = now;
+                    }
+                    tokio::time::sleep(Duration::from_millis(5)).await;
+                }
+            })
+        };
+        Chat {
+            suite: self,
+            id,
+            sends: Default::default(),
+            timeline,
+            sentinels: Vec::new(),
+            runs_sent: 0,
+            stops: 0,
+            allow_errored: false,
+            monitor,
+            errors: Vec::new(),
+        }
+    }
+}
+
+impl Chat<'_> {
+    fn sentinel(&mut self, tag: &str) -> String {
+        let token = sentinel_token(tag);
+        self.sentinels.push(token.clone());
+        token
+    }
+
+    fn status(&self) -> Option<SessionStatus> {
+        self.suite
+            .core
+            .sessions
+            .session_status(&self.id)
+            .map(|s| s.status)
+    }
+
+    fn events(&self) -> Vec<AgentEvent> {
+        self.suite
+            .core
+            .sessions
+            .subscribe(&self.id, 0)
+            .map(|(events, _)| events.into_iter().map(|e| e.event).collect())
+            .unwrap_or_default()
+    }
+
+    fn text(&self) -> String {
+        self.events()
+            .iter()
+            .filter_map(|e| match e {
+                AgentEvent::TextDelta { text } => Some(text.as_str()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    fn tool_started(&self, needle: &str) -> bool {
+        self.events().iter().any(|e| {
+            matches!(e, AgentEvent::ToolCall { call, .. }
+                if serde_json::to_string(call).is_ok_and(|c| c.contains(needle)))
+        })
+    }
+
+    /// The user's send, through the durable command plane like every client.
+    fn send(&mut self, request: RunRequest) {
+        self.runs_sent += 1;
+        self.sends.lock().unwrap().push(Instant::now());
+        self.suite
+            .core
+            .doc_host
+            .queue_command(
+                &self.id,
+                SessionCommandPayload::Run {
+                    request,
+                    message_id: uuid::Uuid::new_v4().to_string(),
+                },
+            )
+            .unwrap();
+    }
+
+    fn say(&mut self, prompt: &str) {
+        let request = self.suite.request(prompt);
+        self.send(request);
+    }
+
+    fn stop(&mut self) {
+        self.stops += 1;
+        self.sends.lock().unwrap().push(Instant::now());
+        self.suite
+            .core
+            .doc_host
+            .queue_command(&self.id, SessionCommandPayload::Interrupt {})
+            .unwrap();
+    }
+
+    async fn until(
+        &mut self,
+        secs: u64,
+        what: &str,
+        mut predicate: impl FnMut(&Self) -> bool,
+    ) -> bool {
+        let deadline = Instant::now() + Duration::from_secs(secs);
+        while !predicate(self) {
+            if Instant::now() > deadline {
+                self.errors.push(format!("timed out: {what}"));
+                return false;
+            }
+            tokio::time::sleep(Duration::from_millis(20)).await;
+        }
+        true
+    }
+
+    async fn streaming(&mut self, what: &str) -> bool {
+        let base = self.text().len();
+        self.until(180, what, move |c| {
+            c.status() == Some(SessionStatus::Working) && c.text().len() > base + 40
+        })
+        .await
+    }
+
+    /// Settled: Idle, and every sentinel asked for so far has arrived.
+    async fn settled(&mut self, secs: u64) -> bool {
+        let sentinels = self.sentinels.clone();
+        self.until(
+            secs,
+            "the chat to settle Idle with every sentinel",
+            move |c| {
+                c.status() == Some(SessionStatus::Idle) && {
+                    let text = c.text();
+                    sentinels.iter().all(|s| text.contains(s.as_str()))
+                }
+            },
+        )
+        .await
+    }
+
+    /// Check every invariant; returns the violations.
+    async fn verdict(mut self) -> Vec<String> {
+        // Let trailing frames land before judging.
+        tokio::time::sleep(Duration::from_millis(1500)).await;
+        self.monitor.abort();
+        let events = self.events();
+
+        // Done followed by agent output with no new user turn in between.
+        let mut after_done = None;
+        for (i, e) in events.iter().enumerate() {
+            match e {
+                AgentEvent::Done { status, .. } => after_done = Some((i, *status)),
+                AgentEvent::Steered { .. } | AgentEvent::SessionStarted { .. } => after_done = None,
+                AgentEvent::TextDelta { text } if !text.trim().is_empty() => {
+                    if let Some((at, status)) = after_done.take() {
+                        self.errors.push(format!(
+                            "output after Done({status:?}) at event {at} with no new turn: {text:?}"
+                        ));
+                    }
+                }
+                AgentEvent::ToolCall { id, .. } => {
+                    if let Some((at, status)) = after_done.take() {
+                        self.errors.push(format!(
+                            "tool {id} after Done({status:?}) at event {at} with no new turn"
+                        ));
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // A completion ping followed by more work with no user action in
+        // between. (An Idle without a ping is a handoff — a turn-boundary
+        // agent taking the message held for its turn end — not "done".)
+        let sends = self.sends.lock().unwrap().clone();
+        let timeline = self.timeline.lock().unwrap().clone();
+        let mut idle_since: Option<Instant> = None;
+        let mut last_ping: Option<String> = None;
+        for (at, status, ping) in &timeline {
+            let pinged = ping.is_some() && *ping != last_ping;
+            if ping.is_some() {
+                last_ping = ping.clone();
+            }
+            match status {
+                SessionStatus::Idle if pinged => idle_since = Some(*at),
+                SessionStatus::Idle => {}
+                SessionStatus::Working | SessionStatus::AwaitingInput => {
+                    // A send queued just before the turn ended reaches the
+                    // agent just after: allow the command plane's latency.
+                    if let Some(idle) = idle_since.take()
+                        && !sends
+                            .iter()
+                            .any(|s| *s <= *at && *s + Duration::from_secs(2) >= idle)
+                    {
+                        self.errors.push(format!(
+                            "went Idle then Working again {:?} later with no user action (premature done)",
+                            at.duration_since(idle)
+                        ));
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Every sentinel arrived; nothing stuck.
+        let text = self.text();
+        for s in &self.sentinels {
+            if !text.contains(s.as_str()) {
+                self.errors.push(format!("sentinel {s} never arrived"));
+            }
+        }
+        if self.status() != Some(SessionStatus::Idle) {
+            self.errors
+                .push(format!("ended {:?}, not Idle", self.status()));
+        }
+
+        // Every message delivered (a steer boundary, or the process it
+        // started); one process except after Stops.
+        let steered = events
+            .iter()
+            .filter(|e| matches!(e, AgentEvent::Steered { .. }))
+            .count();
+        let processes = events
+            .iter()
+            .filter(|e| matches!(e, AgentEvent::SessionStarted { .. }))
+            .count();
+        if steered + processes < self.runs_sent {
+            self.errors.push(format!(
+                "{} messages sent but only {steered} steer boundaries + {processes} processes",
+                self.runs_sent
+            ));
+        }
+        if processes > 1 + self.stops {
+            self.errors
+                .push(format!("{processes} processes for {} stops", self.stops));
+        }
+        if !self.allow_errored
+            && self.events().iter().any(|e| {
+                matches!(
+                    e,
+                    AgentEvent::Done {
+                        status: zeron_proto::DoneStatus::Errored,
+                        ..
+                    }
+                )
+            })
+        {
+            self.errors.push("a turn errored".into());
+        }
+        if !self.errors.is_empty() {
+            let journal: Vec<String> = events
+                .iter()
+                .filter(|e| {
+                    !matches!(
+                        e,
+                        AgentEvent::TextDelta { .. }
+                            | AgentEvent::ReasoningDelta { .. }
+                            | AgentEvent::Usage { .. }
+                            | AgentEvent::ContextUsage { .. }
+                    )
+                })
+                .map(|e| format!("{e:?}").chars().take(160).collect())
+                .collect();
+            self.errors.push(format!("journal: {journal:#?}"));
+        }
+        self.errors
+    }
+}
+
+/// A unique, word-like token to ask the agent to echo. Random hex reads as a
+/// secret or an injection to some models (Grok declines to repeat it).
+fn sentinel_token(tag: &str) -> String {
+    const WORDS: &[&str] = &[
+        "CEDAR", "MANGO", "RIVER", "TULIP", "OTTER", "MAPLE", "COMET", "BISON", "LEMON", "WALNUT",
+        "HARBOR", "PEPPER",
+    ];
+    let id = uuid::Uuid::new_v4().as_u128();
+    let word = WORDS[(id % WORDS.len() as u128) as usize];
+    format!("{word}{}{}", 100 + (id >> 8) % 900, tag.to_uppercase())
+}
+
+/// Every process below `root`, parents before children.
+fn descendants(root: u32) -> Vec<u32> {
+    let mut out = Vec::new();
+    let mut frontier = vec![root];
+    while let Some(pid) = frontier.pop() {
+        let children = std::process::Command::new("pgrep")
+            .args(["-P", &pid.to_string()])
+            .output()
+            .map(|o| {
+                String::from_utf8_lossy(&o.stdout)
+                    .split_whitespace()
+                    .filter_map(|p| p.parse::<u32>().ok())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+        for child in children {
+            out.push(child);
+            frontier.push(child);
+        }
+    }
+    out
+}
+
+/// The answer to every question an approval or ask raises: an allowing
+/// option where one is offered, else the first.
+fn answer_all(questions: &[zeron_proto::UserInputQuestion]) -> Vec<zeron_proto::UserInputAnswer> {
+    questions
+        .iter()
+        .map(|q| {
+            let allow = q.options.iter().find(|o| {
+                let o = o.to_lowercase();
+                (o.contains("allow")
+                    || o.contains("yes")
+                    || o.contains("approve")
+                    || o.contains("accept"))
+                    && !o.contains("don't")
+                    && !o.contains("deny")
+                    && !o.contains("reject")
+            });
+            zeron_proto::UserInputAnswer {
+                question_id: q.id.clone(),
+                labels: allow.or(q.options.first()).cloned().into_iter().collect(),
+            }
+        })
+        .collect()
+}
+
+fn pixel(dir: &std::path::Path) -> String {
+    let path = dir.join(format!("pixel-{}.png", uuid::Uuid::new_v4().simple()));
+    std::fs::write(
+        &path,
+        [
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48,
+            0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x00, 0x00,
+            0x00, 0x90, 0x77, 0x53, 0xDE, 0x00, 0x00, 0x00, 0x0C, 0x49, 0x44, 0x41, 0x54, 0x08,
+            0xD7, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x18, 0xDD, 0x8D,
+            0xB0, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
+        ],
+    )
+    .unwrap();
+    path.display().to_string()
+}
+
+const ESSAY: &str = "Write a 500-word essay about rivers. Do not use any tools.";
+
+async fn scenario(suite: &Suite, name: &str, round: usize) -> Vec<String> {
+    let mut chat = suite.chat(name, round);
+    match name {
+        // Three messages within a second while the reply streams.
+        "rapid_steers" => {
+            chat.say(ESSAY);
+            if chat.streaming("the essay to stream").await {
+                let token = chat.sentinel("RS");
+                chat.say("Remember the word ALPHA.");
+                tokio::time::sleep(Duration::from_millis(300)).await;
+                chat.say("Remember the word BRAVO.");
+                tokio::time::sleep(Duration::from_millis(300)).await;
+                chat.say(&format!(
+                    "Stop the essay. Say hi to my cat {token}, then list every word I asked you to remember. No tools."
+                ));
+                if chat.settled(240).await {
+                    let text = chat.text();
+                    let tail = &text[text.find(&token).unwrap_or(0)..];
+                    for word in ["ALPHA", "BRAVO"] {
+                        if !tail.contains(word) {
+                            chat.errors
+                                .push(format!("steer {word} never reached the agent"));
+                        }
+                    }
+                }
+            }
+        }
+        // A steer while a foreground command runs.
+        "steer_during_tool" => {
+            let first = chat.sentinel("TA");
+            chat.say(&format!(
+                "Run this exact shell command in the FOREGROUND and wait for it: {} . Then say hi to my cat {first}.",
+                suite.probe(1, 15)
+            ));
+            let marker = suite.probe_marker(1);
+            if chat
+                .until(180, "the command to start", |c| c.tool_started(&marker))
+                .await
+            {
+                let second = chat.sentinel("TB");
+                chat.say(&format!(
+                    "When that is done, also say hi to my cat {second}."
+                ));
+                chat.settled(240).await;
+            }
+        }
+        // A send landing right as the reply finishes.
+        "boundary_race" => {
+            let first = chat.sentinel("BA");
+            chat.say(&format!(
+                "Just say hi to my cat {first} in one short sentence."
+            ));
+            if chat
+                .until(120, "the first reply", |c| {
+                    c.text().contains(first.as_str())
+                })
+                .await
+            {
+                let second = chat.sentinel("BB");
+                chat.say(&format!(
+                    "Just say hi to my cat {second} in one short sentence."
+                ));
+                chat.settled(180).await;
+            }
+            // And a send right after Idle.
+            let third = chat.sentinel("BC");
+            chat.say(&format!(
+                "Just say hi to my cat {third} in one short sentence."
+            ));
+            chat.settled(180).await;
+        }
+        // Stop the instant after sending, then send again at once.
+        "stop_races" => {
+            chat.say(ESSAY);
+            chat.stop();
+            // The Stop may cancel this message before its agent even starts.
+            chat.runs_sent -= 1;
+            chat.until(60, "the instant stop to settle", |c| {
+                c.status() == Some(SessionStatus::Idle)
+            })
+            .await;
+            let token = chat.sentinel("SR");
+            chat.say(&format!(
+                "Just say hi to my cat {token} in one short sentence."
+            ));
+            chat.settled(180).await;
+            // Stop mid-command, and send immediately after the Stop.
+            chat.say(&format!(
+                "Run this exact shell command in the FOREGROUND and wait for it: {} . Then reply FINISHED.",
+                suite.probe(2, 300)
+            ));
+            let marker = suite.probe_marker(2);
+            if chat
+                .until(180, "the command to start", |c| c.tool_started(&marker))
+                .await
+            {
+                chat.stop();
+                let token = chat.sentinel("SS");
+                chat.say(&format!(
+                    "Just say hi to my cat {token} in one short sentence."
+                ));
+                chat.settled(180).await;
+                if !chat
+                    .until(20, "the stopped command's process to be gone", |c| {
+                        c.suite.probes_alive() == 0
+                    })
+                    .await
+                {
+                    chat.errors
+                        .push("a Stop left the agent's command running".into());
+                }
+            }
+        }
+        // An image sent while the agent works.
+        "image_mid_turn" => {
+            chat.say(ESSAY);
+            if chat.streaming("the essay to stream").await {
+                let token = chat.sentinel("IM");
+                let mut request = suite.request(&format!(
+                    "Stop the essay. I attached a 1x1 test image. Just say hi to my cat {token} in one short sentence. No tools."
+                ));
+                request.attachments = vec![pixel(suite.dir.path())];
+                chat.send(request);
+                chat.settled(240).await;
+            }
+        }
+        // Another model chosen for a message sent mid-turn.
+        "model_switch_mid_turn" => {
+            let Some(other) = suite.other_model.clone() else {
+                return Vec::new();
+            };
+            chat.say(ESSAY);
+            if chat.streaming("the essay to stream").await {
+                let token = chat.sentinel("MS");
+                let mut request = suite.request(&format!(
+                    "Stop the essay. Just say hi to my cat {token} in one short sentence. No tools."
+                ));
+                request.model = Some(other.clone());
+                chat.send(request);
+                if chat.settled(240).await {
+                    let token = chat.sentinel("MT");
+                    let mut request = suite.request(&format!(
+                        "Just say hi to my cat {token} in one short sentence."
+                    ));
+                    request.model = Some(other);
+                    chat.send(request);
+                    chat.settled(180).await;
+                }
+            }
+        }
+        // Long silent reasoning must not read as a dead turn.
+        "long_reasoning" => {
+            let token = chat.sentinel("LR");
+            let mut request = suite.request(&format!(
+                "Think carefully step by step (privately) about this: how many distinct ways can you make change for 100 cents using pennies, nickels, dimes and quarters? Do not use tools. Then say hi to my cat {token} and tell me the number."
+            ));
+            request.reasoning = Some(ReasoningLevel::Max);
+            chat.send(request);
+            chat.settled(600).await;
+        }
+        // A steer while a subagent works.
+        "subagent_steer" => {
+            let delegate = match suite.id {
+                HarnessId::Codex => "Spawn one subagent (spawn_agent) and wait for it",
+                HarnessId::ClaudeCode => {
+                    "Use the Agent tool (foreground, general-purpose subagent) and wait for it"
+                }
+                _ => {
+                    "Delegate to one subagent (your task/subagent tool, if you have one; otherwise do it yourself) and wait for it"
+                }
+            };
+            let first = chat.sentinel("SA");
+            chat.say(&format!(
+                "{delegate}: its task is to run this exact shell command in the foreground: {} and then reply ok. After it returns, say hi to my cat {first}.",
+                suite.probe(3, 20)
+            ));
+            if chat
+                .until(240, "the subagent's command to start", |c| {
+                    c.suite.probes_alive() > 0
+                })
+                .await
+            {
+                let second = chat.sentinel("SB");
+                chat.say(&format!(
+                    "Also, at the very end, say hi to my cat {second}."
+                ));
+                chat.settled(300).await;
+            }
+        }
+        // The agent asks; the answer resumes the same turn, which ends once.
+        "question" => {
+            if suite.id != HarnessId::ClaudeCode {
+                return Vec::new();
+            }
+            let token = chat.sentinel("QA");
+            chat.say(&format!(
+                "Use the AskUserQuestion tool to ask me to pick exactly one of two colors, red or blue. After I answer, say hi to my cat {token} and tell me my choice. No other tools."
+            ));
+            if chat
+                .until(180, "the question", |c| {
+                    c.status() == Some(SessionStatus::AwaitingInput)
+                })
+                .await
+            {
+                let asked = chat.events().into_iter().rev().find_map(|e| match e {
+                    AgentEvent::InputRequested {
+                        request_id,
+                        questions,
+                    } => Some((request_id, questions)),
+                    _ => None,
+                });
+                if let Some((request_id, questions)) = asked {
+                    let answers = answer_all(&questions);
+                    chat.sends.lock().unwrap().push(Instant::now());
+                    if !suite
+                        .core
+                        .sessions
+                        .respond_input(&chat.id, &request_id, answers)
+                        .unwrap()
+                    {
+                        chat.errors
+                            .push("the answer found no pending question".into());
+                    }
+                    chat.settled(180).await;
+                } else {
+                    chat.errors
+                        .push("AwaitingInput without an InputRequested event".into());
+                }
+            }
+        }
+        // A steer, then Stop at once: both cancelled, the work killed, and
+        // the next message runs.
+        "steer_then_stop" => {
+            chat.say(&format!(
+                "Run this exact shell command in the FOREGROUND and wait for it: {} . Then reply FINISHED.",
+                suite.probe(4, 300)
+            ));
+            let marker = suite.probe_marker(4);
+            if chat
+                .until(180, "the command to start", |c| c.tool_started(&marker))
+                .await
+            {
+                chat.say("Also list the files in this directory afterwards.");
+                chat.stop();
+                chat.until(60, "the stop to settle", |c| {
+                    c.status() == Some(SessionStatus::Idle)
+                })
+                .await;
+                if !chat
+                    .until(20, "the stopped command to be gone", |c| {
+                        c.suite.probes_alive() == 0
+                    })
+                    .await
+                {
+                    chat.errors
+                        .push("a Stop left the agent's command running".into());
+                }
+                let token = chat.sentinel("ST");
+                chat.say(&format!(
+                    "Just say hi to my cat {token} in one short sentence."
+                ));
+                chat.settled(180).await;
+                // The cancelled steer must not have run in the new process.
+                chat.runs_sent -= 1;
+            }
+        }
+        // Several messages queued at once on an idle chat: every one runs,
+        // in the order sent.
+        "burst_idle" => {
+            let first = chat.sentinel("BU");
+            chat.say(&format!(
+                "Just say hi to my cat {first} in one short sentence."
+            ));
+            if chat.settled(180).await {
+                // However the agent takes them — one turn each, or together —
+                // every message must reach it.
+                let words = ["ALPHA", "BRAVO", "CHARLIE"];
+                for word in words {
+                    chat.say(&format!("Remember the word {word}. Reply only OK."));
+                }
+                let last = chat.sentinel("BZ");
+                chat.say(&format!(
+                    "Say hi to my cat {last}, then list every word I asked you to remember. No tools."
+                ));
+                if chat.settled(300).await {
+                    let text = chat.text();
+                    let tail = &text[text.rfind(last.as_str()).unwrap_or(0)..];
+                    for word in words {
+                        if !tail.contains(word) {
+                            chat.errors
+                                .push(format!("queued message {word} never reached the agent"));
+                        }
+                    }
+                }
+            }
+        }
+        // Stop on an idle chat holding no work: nothing to stop, and the
+        // agent must not be torn down for it.
+        "idle_stop" => {
+            let first = chat.sentinel("IA");
+            chat.say(&format!(
+                "Just say hi to my cat {first} in one short sentence."
+            ));
+            if chat.settled(180).await {
+                chat.stop();
+                chat.stops -= 1;
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                let second = chat.sentinel("IB");
+                chat.say(&format!(
+                    "Just say hi to my cat {second} in one short sentence."
+                ));
+                chat.settled(180).await;
+            }
+        }
+        // A long foreground command with no output: silence is not the end.
+        "silent_command" => {
+            let token = chat.sentinel("SC");
+            chat.say(&format!(
+                "Run this exact shell command in the FOREGROUND and wait for it to finish (it takes about 75 seconds and prints nothing): {} . Then say hi to my cat {token}.",
+                suite.probe(5, 75)
+            ));
+            chat.settled(420).await;
+        }
+        // The agent dies mid-command (OOM, `killall`): the turn must end,
+        // visibly, and the next message resumes the same conversation.
+        "crash_recovery" => {
+            let word = format!("PELICAN{}", &uuid::Uuid::new_v4().simple().to_string()[..4])
+                .to_uppercase();
+            let first = chat.sentinel("CA");
+            chat.say(&format!(
+                "Hi! I named my new boat {word}. Just say hi to my cat {first} in one short sentence."
+            ));
+            if chat.settled(180).await {
+                chat.say(&format!(
+                    "Run this exact shell command in the FOREGROUND and wait for it: {} . Then reply FINISHED.",
+                    suite.probe(6, 300)
+                ));
+                let marker = suite.probe_marker(6);
+                if chat
+                    .until(180, "the command to start", |c| c.tool_started(&marker))
+                    .await
+                {
+                    chat.allow_errored = true;
+                    chat.stops += 1;
+                    let killed = suite.crash_agents();
+                    if killed == 0 {
+                        chat.errors.push("found no agent process to kill".into());
+                    }
+                    chat.until(120, "the crashed turn to end", |c| {
+                        c.status() != Some(SessionStatus::Working)
+                    })
+                    .await;
+                    let ended = chat
+                        .events()
+                        .iter()
+                        .rev()
+                        .any(|e| matches!(e, AgentEvent::Done { .. }));
+                    if !ended {
+                        chat.errors
+                            .push("the crash ended the turn without a Done".into());
+                    }
+                    let second = chat.sentinel("CB");
+                    let said = chat.text().len();
+                    chat.say(&format!(
+                        "What did I name my boat? Also say hi to my cat {second}. No tools."
+                    ));
+                    if chat.settled(240).await {
+                        let reply = chat.text()[said..].to_uppercase();
+                        if !reply.contains(&word) {
+                            chat.errors.push(format!(
+                                "the conversation did not survive the crash: {word} missing from {reply:?}"
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+        // Two chats on the same harness at once: each gets its own replies
+        // and its own steer.
+        "concurrent_chats" => {
+            let mut other = suite.chat(&format!("{name}-b"), round);
+            chat.say(ESSAY);
+            other.say(ESSAY);
+            if chat.streaming("chat A to stream").await && other.streaming("chat B to stream").await
+            {
+                let a = chat.sentinel("CA");
+                let b = other.sentinel("CB");
+                chat.say(&format!(
+                    "Stop the essay. Just say hi to my cat {a} in one short sentence. No tools."
+                ));
+                other.say(&format!(
+                    "Stop the essay. Just say hi to my cat {b} in one short sentence. No tools."
+                ));
+                chat.settled(240).await;
+                other.settled(240).await;
+                if chat.text().contains(b.as_str()) || other.text().contains(a.as_str()) {
+                    chat.errors.push("a reply reached the other chat".into());
+                }
+            }
+            let other_id = other.id.clone();
+            let mut errors = other.verdict().await;
+            let _ = suite.core.sessions.terminate(&other_id).await;
+            for e in errors.drain(..) {
+                chat.errors.push(format!("chat B: {e}"));
+            }
+        }
+        // Approvals on: every permission the agent asks for is answered,
+        // and the turn carries on to its end.
+        "approval" => {
+            let token = chat.sentinel("AP");
+            let mut request = suite.request(&format!(
+                "Run this exact shell command: echo approved > approval.txt . Then say hi to my cat {token}."
+            ));
+            request.auto_approve = false;
+            chat.send(request);
+            let deadline = Instant::now() + Duration::from_secs(300);
+            let mut answered = std::collections::HashSet::new();
+            loop {
+                let pending = chat
+                    .events()
+                    .into_iter()
+                    .filter_map(|e| match e {
+                        AgentEvent::InputRequested {
+                            request_id,
+                            questions,
+                        } => Some((request_id, questions)),
+                        _ => None,
+                    })
+                    .filter(|(id, _)| !answered.contains(id))
+                    .collect::<Vec<_>>();
+                for (request_id, questions) in pending {
+                    chat.sends.lock().unwrap().push(Instant::now());
+                    let _ = suite.core.sessions.respond_input(
+                        &chat.id,
+                        &request_id,
+                        answer_all(&questions),
+                    );
+                    answered.insert(request_id);
+                }
+                let done = chat.status() == Some(SessionStatus::Idle)
+                    && chat.text().contains(token.as_str());
+                if done || Instant::now() > deadline {
+                    break;
+                }
+                tokio::time::sleep(Duration::from_millis(100)).await;
+            }
+            chat.settled(30).await;
+        }
+        other => panic!("unknown scenario {other}"),
+    }
+    let id = chat.id.clone();
+    let errors = chat.verdict().await;
+    // Retire the chat's runtime: a later crash scenario kills every agent
+    // this test runs.
+    let _ = suite.core.sessions.terminate(&id).await;
+    suite.kill_probes();
+    errors
+}
+
+const SCENARIOS: &[&str] = &[
+    "rapid_steers",
+    "steer_during_tool",
+    "boundary_race",
+    "stop_races",
+    "image_mid_turn",
+    "model_switch_mid_turn",
+    "long_reasoning",
+    "subagent_steer",
+    "question",
+    "steer_then_stop",
+    "burst_idle",
+    "idle_stop",
+    "silent_command",
+    "crash_recovery",
+    "concurrent_chats",
+    "approval",
+];
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+#[ignore = "uses real model quota; select harness and inexpensive model explicitly"]
+async fn adapter_chaos() {
+    if std::env::var_os("RUST_LOG").is_some() {
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+            .with_test_writer()
+            .try_init();
+    }
+    let suite = Suite::new();
+    suite.kill_probes();
+    let rounds: usize = std::env::var("ZERON_CHAOS_ROUNDS")
+        .ok()
+        .and_then(|r| r.parse().ok())
+        .unwrap_or(1);
+    let only = std::env::var("ZERON_CHAOS_ONLY").ok();
+    let mut failures = Vec::new();
+    let mut runs = 0;
+    for round in 0..rounds {
+        for name in SCENARIOS {
+            if only.as_deref().is_some_and(|o| o != *name) {
+                continue;
+            }
+            let started = Instant::now();
+            let errors = scenario(&suite, name, round).await;
+            runs += 1;
+            let verdict = if errors.is_empty() { "ok" } else { "FAILED" };
+            println!(
+                "{}: round {round} {name}: {verdict} ({:.0}s)",
+                suite.name,
+                started.elapsed().as_secs_f32()
+            );
+            for e in &errors {
+                println!("    {e}");
+            }
+            if !errors.is_empty() {
+                failures.push(format!("round {round} {name}"));
+            }
+        }
+    }
+    suite.core.shutdown().await;
+    suite.kill_probes();
+    println!(
+        "{}: {}/{runs} scenario runs passed",
+        suite.name,
+        runs - failures.len()
+    );
+    assert!(failures.is_empty(), "failed: {failures:?}");
+}
+
+const RESTART_CHAT: &str = "restart";
+
+fn status_of(core: &EngineCore) -> Option<SessionStatus> {
+    core.sessions.session_status(RESTART_CHAT).map(|s| s.status)
+}
+
+fn text_of(core: &EngineCore) -> String {
+    core.sessions
+        .subscribe(RESTART_CHAT, 0)
+        .map(|(events, _)| {
+            events
+                .into_iter()
+                .filter_map(|e| match e.event {
+                    AgentEvent::TextDelta { text } => Some(text),
+                    _ => None,
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn completed_of(core: &EngineCore) -> usize {
+    core.sessions
+        .subscribe(RESTART_CHAT, 0)
+        .map(|(events, _)| {
+            events
+                .iter()
+                .filter(|e| {
+                    matches!(
+                        e.event,
+                        AgentEvent::Done {
+                            status: zeron_proto::DoneStatus::Completed,
+                            ..
+                        }
+                    )
+                })
+                .count()
+        })
+        .unwrap_or(0)
+}
+
+/// Send `prompt` and wait for its turn to complete; returns the reply text.
+/// No reply token is demanded: some agents (Grok) refuse to echo one.
+async fn ask(core: &EngineCore, name: &str, cwd: &str, prompt: &str, what: &str) -> String {
+    let (done, said) = (completed_of(core), text_of(core).len());
+    send_to(core, restart_request(name, cwd, prompt));
+    let finished = tokio::time::timeout(Duration::from_secs(240), async {
+        while !(completed_of(core) > done && status_of(core) == Some(SessionStatus::Idle)) {
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
+    })
+    .await;
+    assert!(finished.is_ok(), "timed out: {what}:\n{}", dump(core));
+    text_of(core)[said..].to_owned()
+}
+
+/// A completed turn after recovery's "— resuming" marker: the force-killed
+/// turn was picked back up and ran to its end.
+fn resumed_to_end(core: &EngineCore) -> bool {
+    core.sessions
+        .subscribe(RESTART_CHAT, 0)
+        .is_ok_and(|(events, _)| {
+            events
+                .iter()
+                .position(|e| {
+                    matches!(&e.event, AgentEvent::Done { error: Some(note), .. }
+                        if note.contains("resuming"))
+                })
+                .is_some_and(|at| {
+                    events[at..].iter().any(|e| {
+                        matches!(
+                            e.event,
+                            AgentEvent::Done {
+                                status: zeron_proto::DoneStatus::Completed,
+                                ..
+                            }
+                        )
+                    })
+                })
+        })
+}
+
+fn send_to(core: &EngineCore, request: RunRequest) {
+    core.doc_host
+        .queue_command(
+            RESTART_CHAT,
+            SessionCommandPayload::Run {
+                request,
+                message_id: uuid::Uuid::new_v4().to_string(),
+            },
+        )
+        .unwrap();
+}
+
+fn restart_request(name: &str, cwd: &str, prompt: &str) -> RunRequest {
+    RunRequest {
+        mcp: None,
+        prompt: prompt.into(),
+        harness: Some(harness(name).0),
+        model: std::env::var("ZERON_TEST_MODEL").ok(),
+        reasoning: None,
+        model_options: Default::default(),
+        cwd: cwd.into(),
+        sandbox: SandboxLevel::DangerFullAccess,
+        auto_approve: true,
+        attachments: vec![],
+        worktree: None,
+        resume: None,
+    }
+}
+
+async fn wait_for(secs: u64, what: &str, mut predicate: impl FnMut() -> bool) {
+    let deadline = Instant::now() + Duration::from_secs(secs);
+    while !predicate() {
+        assert!(Instant::now() < deadline, "timed out: {what}");
+        tokio::time::sleep(Duration::from_millis(50)).await;
+    }
+}
+
+/// What the engine holds for the restart chat: journal events (text
+/// folded away) and the transcript's entries.
+fn dump(core: &EngineCore) -> String {
+    let events: Vec<String> = core
+        .sessions
+        .subscribe(RESTART_CHAT, 0)
+        .map(|(events, _)| {
+            events
+                .into_iter()
+                .filter(|e| {
+                    !matches!(
+                        e.event,
+                        AgentEvent::TextDelta { .. } | AgentEvent::ReasoningDelta { .. }
+                    )
+                })
+                .map(|e| format!("{:?}", e.event).chars().take(200).collect())
+                .collect()
+        })
+        .unwrap_or_default();
+    let entries: Vec<String> = core
+        .doc_host
+        .open(RESTART_CHAT)
+        .ok()
+        .and_then(|h| h.doc().read_entries().ok())
+        .unwrap_or_default()
+        .iter()
+        .map(|e| format!("{:?} {:?} {}", e.role, e.status, e.id))
+        .collect();
+    format!(
+        "status {:?}\nevents {events:#?}\nentries {entries:#?}\ntext {:?}",
+        status_of(core),
+        text_of(core)
+    )
+}
+
+fn probe_alive(marker: &str) -> bool {
+    std::process::Command::new("pgrep")
+        .args(["-f", marker])
+        .output()
+        .is_ok_and(|o| !o.stdout.is_empty())
+}
+
+/// Quitting the app mid-turn, and the app being force-killed mid-turn: after
+/// the restart nothing reads as still running, the force-killed turn is
+/// picked back up and finishes, and the conversation carries on with its
+/// context.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+#[ignore = "uses real model quota; select harness and inexpensive model explicitly"]
+async fn restart_durability() {
+    if std::env::var_os("RUST_LOG").is_some() {
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+            .with_test_writer()
+            .try_init();
+    }
+    let name = std::env::var("ZERON_TEST_HARNESS").unwrap_or_else(|_| "claude".into());
+    let (id, _, base) = harness(&name);
+    let dir = tempfile::tempdir().unwrap();
+    let cwd = dir.path().to_str().unwrap().to_owned();
+    let word = format!("HERON{}", &uuid::Uuid::new_v4().simple().to_string()[..4]).to_uppercase();
+
+    // 1. A conversation with something to remember.
+    let core = engine(dir.path(), &name);
+    core.workspace
+        .create_space("space", &core.device_id, &cwd, None, false)
+        .unwrap();
+    core.workspace
+        .create_chat(RESTART_CHAT, Some("space"), None, None, None)
+        .unwrap();
+    core.workspace
+        .set_chat_config(
+            RESTART_CHAT,
+            &ChatConfig {
+                harness: id,
+                model: std::env::var("ZERON_TEST_MODEL").ok(),
+                reasoning: None,
+                model_options: Default::default(),
+                sandbox: SandboxLevel::DangerFullAccess,
+            },
+        )
+        .unwrap();
+    ask(
+        &core,
+        &name,
+        &cwd,
+        &format!("Hi! I named my new boat {word}. A one-line hello back is all I need."),
+        "the opening reply",
+    )
+    .await;
+    println!("{name}: opening turn done");
+
+    if std::env::var_os("ZERON_RESTART_ONLY_FORCE_KILL").is_none() {
+        // 2. Quit the app mid-command.
+        let marker = format!("zr{}=1", base + 7);
+        send_to(
+            &core,
+            restart_request(
+                &name,
+                &cwd,
+                &format!(
+                    "Please run this shell command in the foreground and wait for it to finish: python3 -c 'import time; {marker}; time.sleep(300)'"
+                ),
+            ),
+        );
+        wait_for(240, "the command to start", || probe_alive(&marker)).await;
+        core.shutdown().await;
+        drop(core);
+        wait_for(30, "quitting to end the agent's command", || {
+            !probe_alive(&marker)
+        })
+        .await;
+        println!("{name}: quit mid-command; its work ended");
+
+        // 3. Restart: nothing stuck, context intact.
+        let core = engine(dir.path(), &name);
+        wait_for(60, "the quit turn to read as ended", || {
+            status_of(&core) != Some(SessionStatus::Working)
+        })
+        .await;
+        let reply = ask(
+            &core,
+            &name,
+            &cwd,
+            "Quick question: what did I name my boat? No tools needed.",
+            "the reply after a restart",
+        )
+        .await;
+        assert!(
+            reply.to_uppercase().contains(&word),
+            "the conversation did not survive quitting the app ({word}): {reply:?}\n{}",
+            dump(&core)
+        );
+        println!("{name}: restarted with the conversation intact");
+        core.shutdown().await;
+    } else {
+        core.shutdown().await;
+        drop(core);
+    }
+
+    // 4. Force-kill the app mid-command (a separate process: this one is the
+    // app here), then restart: the interrupted turn is resumed and finishes.
+    let crash_marker = format!("zr{}=1", base + 8);
+    let mut child = tokio::process::Command::new(std::env::current_exe().unwrap())
+        .args(["crash_phase", "--exact", "--ignored", "--nocapture"])
+        .env("ZERON_CRASH_DIR", dir.path())
+        .env("ZERON_CRASH_PROMPT", format!(
+            "Please run this shell command in the foreground and wait for it to finish: python3 -c 'import time; {crash_marker}; time.sleep(30)'"
+        ))
+        .env("ZERON_CRASH_MARKER", &crash_marker)
+        .process_group(0)
+        .stdout(std::process::Stdio::piped())
+        .kill_on_drop(true)
+        .spawn()
+        .unwrap();
+    let pgid = child.id().unwrap();
+    {
+        use tokio::io::AsyncBufReadExt;
+        let mut lines = tokio::io::BufReader::new(child.stdout.take().unwrap()).lines();
+        tokio::time::timeout(Duration::from_secs(300), async {
+            while let Ok(Some(line)) = lines.next_line().await {
+                if line.contains("CRASH-READY") {
+                    return;
+                }
+            }
+            panic!("the app process ended before its command started");
+        })
+        .await
+        .expect("the app process to start the command");
+    }
+    let _ = std::process::Command::new("kill")
+        .args(["-9", &format!("-{pgid}")])
+        .status();
+    let _ = child.wait().await;
+    // Whatever the agent left behind outlives a force-kill; clear it so the
+    // resumed run's own command is what we see.
+    let _ = std::process::Command::new("pkill")
+        .args(["-9", "-f", &crash_marker])
+        .status();
+    println!("{name}: app force-killed mid-command");
+
+    let core = engine(dir.path(), &name);
+    let resumed = tokio::time::timeout(Duration::from_secs(420), async {
+        while !(resumed_to_end(&core) && status_of(&core) == Some(SessionStatus::Idle)) {
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
+    })
+    .await;
+    assert!(
+        resumed.is_ok(),
+        "the force-killed turn was not resumed to its end:\n{}",
+        dump(&core)
+    );
+    println!("{name}: the force-killed turn resumed and finished");
+    let reply = ask(
+        &core,
+        &name,
+        &cwd,
+        "Remind me, what did I name my boat? No tools needed.",
+        "the reply after a force-kill",
+    )
+    .await;
+    assert!(
+        reply.to_uppercase().contains(&word),
+        "the conversation did not survive a force-kill ({word}): {reply:?}\n{}",
+        dump(&core)
+    );
+    println!("{name}: force-kill survived with the conversation intact");
+    core.shutdown().await;
+    let _ = std::process::Command::new("pkill")
+        .args(["-9", "-f", &format!("zr{}[0-9]=1", base / 10)])
+        .status();
+}
+
+/// `restart_durability`'s app process: starts the command, reports, and
+/// waits to be killed. Does nothing unless launched by that test.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+#[ignore = "launched by restart_durability"]
+async fn crash_phase() {
+    if std::env::var_os("RUST_LOG").is_some() {
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+            .with_test_writer()
+            .try_init();
+    }
+    let Some(dir) = std::env::var_os("ZERON_CRASH_DIR") else {
+        return;
+    };
+    let name = std::env::var("ZERON_TEST_HARNESS").unwrap_or_else(|_| "claude".into());
+    let dir = std::path::PathBuf::from(dir);
+    let core = engine(&dir, &name);
+    let cwd = dir.to_str().unwrap().to_owned();
+    send_to(
+        &core,
+        restart_request(&name, &cwd, &std::env::var("ZERON_CRASH_PROMPT").unwrap()),
+    );
+    let marker = std::env::var("ZERON_CRASH_MARKER").unwrap();
+    wait_for(240, "the command to start", || probe_alive(&marker)).await;
+    println!("CRASH-READY");
+    tokio::time::sleep(Duration::from_secs(600)).await;
+}
diff --git a/crates/engine/tests/restart_resume.rs b/crates/engine/tests/restart_resume.rs
index fb07750ae6..02b5a8d068 100644
--- a/crates/engine/tests/restart_resume.rs
+++ b/crates/engine/tests/restart_resume.rs
@@ -693,6 +693,191 @@ async fn fresh_crash_auto_resumes_and_notes_the_interruption() {
     core.shutdown().await;
 }
 
+/// A kill moments into a turn: the journal shows the run, but the doc's
+/// debounced save never stored a reply entry, so the user's message is the
+/// transcript's last word. That is a crashed turn too — it is picked back
+/// up, not left unanswered.
+#[tokio::test]
+async fn a_crash_before_the_reply_reached_disk_still_auto_resumes() {
+    let tmp = tempfile::tempdir().unwrap();
+    let dir = tmp.path().join("data");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("device-id"), "dev-crash").unwrap();
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_millis() as i64;
+    {
+        let store = DocsStore::open(dir.join("orgs/dev-org/dev-user")).unwrap();
+        let doc = SessionDoc::init(CHAT).unwrap();
+        doc.push_message(&SessionMessageEntry {
+            id: "msg-user-1".into(),
+            role: MessageRole::User,
+            parts: vec![MessagePart::Text {
+                id: "t0".into(),
+                text: "long task".into(),
+            }],
+            created_at: now - 5_000,
+            device_id: "dev-crash".into(),
+            status: Some(MessageStatus::Complete),
+            continuation_of: None,
+            duration_ms: None,
+        })
+        .unwrap();
+        store
+            .save_snapshot(CHAT, &doc.export_snapshot().unwrap())
+            .unwrap();
+        let journal = RunJournal::open(dir.join("orgs/dev-org/dev-user/journals")).unwrap();
+        journal
+            .append(
+                CHAT,
+                &AgentEvent::SessionStarted {
+                    harness: HarnessId::Mock,
+                    model: "mock-1".into(),
+                    tools: vec![],
+                    cwd: "/tmp".into(),
+                    session_id: "hs-crash".into(),
+                    assistant_message_id: "msg-assistant-1".into(),
+                },
+            )
+            .unwrap();
+    }
+
+    let requests: RequestLog = Arc::new(Mutex::new(Vec::new()));
+    let core = assemble(
+        &dir,
+        RecordingHarness {
+            requests: requests.clone(),
+            session_id: "hs-after-crash".into(),
+            fail_starts: Default::default(),
+        },
+    );
+    wait_for(
+        || complete_assistant_count(&core) == 1,
+        "the crashed turn to be picked back up",
+    )
+    .await;
+    let recorded = requests.lock().unwrap().clone();
+    let revived = recorded
+        .iter()
+        .find(|r| r.prompt == "long task")
+        .expect("auto-resumed dispatch reached the harness");
+    assert_eq!(revived.resume.as_deref(), Some("hs-crash"));
+    core.shutdown().await;
+}
+
+/// The agent reports where it runs with symlinks resolved; the chat names
+/// its folder through the symlink. A crash mid-turn leaves the resolved
+/// spelling stored (only a turn's Done restores the request's), and the
+/// recovered run must still resume that same conversation — not start fresh
+/// with its history gone (live, Claude Code on macOS's `/var` → `/private/var`).
+#[cfg(unix)]
+#[tokio::test]
+async fn a_crash_recovers_the_conversation_through_a_symlinked_folder() {
+    let tmp = tempfile::tempdir().unwrap();
+    let dir = tmp.path().join("data");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("device-id"), "dev-crash").unwrap();
+    let real = tmp.path().join("real-project");
+    std::fs::create_dir_all(&real).unwrap();
+    let link = tmp.path().join("linked-project");
+    std::os::unix::fs::symlink(&real, &link).unwrap();
+    let real = std::fs::canonicalize(&real).unwrap();
+    let (real, link) = (real.to_str().unwrap(), link.to_str().unwrap());
+
+    let requests: RequestLog = Arc::new(Mutex::new(Vec::new()));
+    {
+        let core = assemble(
+            &dir,
+            RecordingHarness {
+                requests: requests.clone(),
+                session_id: "unused".into(),
+                fail_starts: Default::default(),
+            },
+        );
+        core.workspace
+            .create_space("space-link", &core.device_id, link, None, false)
+            .unwrap();
+        core.workspace
+            .create_chat(CHAT, Some("space-link"), None, None, None)
+            .unwrap();
+        core.shutdown().await;
+    }
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_millis() as i64;
+    {
+        let store = DocsStore::open(dir.join("orgs/dev-org/dev-user")).unwrap();
+        let doc = SessionDoc::init(CHAT).unwrap();
+        doc.push_message(&SessionMessageEntry {
+            id: "msg-user-1".into(),
+            role: MessageRole::User,
+            parts: vec![MessagePart::Text {
+                id: "t0".into(),
+                text: "long task".into(),
+            }],
+            created_at: now - 5_000,
+            device_id: "dev-crash".into(),
+            status: Some(MessageStatus::Complete),
+            continuation_of: None,
+            duration_ms: None,
+        })
+        .unwrap();
+        store
+            .save_snapshot(CHAT, &doc.export_snapshot().unwrap())
+            .unwrap();
+        let journal = RunJournal::open(dir.join("orgs/dev-org/dev-user/journals")).unwrap();
+        journal
+            .append(
+                CHAT,
+                &AgentEvent::SessionStarted {
+                    harness: HarnessId::Mock,
+                    model: "mock-1".into(),
+                    tools: vec![],
+                    cwd: real.into(),
+                    session_id: "hs-crash".into(),
+                    assistant_message_id: "msg-assistant-1".into(),
+                },
+            )
+            .unwrap();
+    }
+
+    let core = assemble(
+        &dir,
+        RecordingHarness {
+            requests: requests.clone(),
+            session_id: "hs-crash".into(),
+            fail_starts: Default::default(),
+        },
+    );
+    wait_for(
+        || {
+            requests
+                .lock()
+                .unwrap()
+                .iter()
+                .any(|r| r.prompt == "long task")
+        },
+        "the crashed turn to be picked back up",
+    )
+    .await;
+    let revived = requests
+        .lock()
+        .unwrap()
+        .iter()
+        .find(|r| r.prompt == "long task")
+        .cloned()
+        .unwrap();
+    assert_eq!(revived.cwd, link, "the chat's own folder");
+    assert_eq!(
+        revived.resume.as_deref(),
+        Some("hs-crash"),
+        "the same conversation, through the symlink"
+    );
+    core.shutdown().await;
+}
+
 #[tokio::test]
 async fn resume_is_cwd_scoped() {
     let tmp = tempfile::tempdir().unwrap();
diff --git a/crates/engine/tests/rich_composer_delivery.rs b/crates/engine/tests/rich_composer_delivery.rs
index 7c06d48bd9..bc116d3ec6 100644
--- a/crates/engine/tests/rich_composer_delivery.rs
+++ b/crates/engine/tests/rich_composer_delivery.rs
@@ -37,7 +37,7 @@ const HARNESSES: [HarnessId; 9] = [
 
 enum Delivery {
     Run(RunRequest),
-    Steer(String),
+    Steer(String, Vec<String>),
 }
 struct DiscoveryGate {
     started: mpsc::UnboundedSender<std::path::PathBuf>,
@@ -135,7 +135,7 @@ impl Harness for RecordingHarness {
                     _ = controls.interrupt.cancelled() => None,
                     message = controls.steering.recv() => {
                         let message = message?;
-                        delivery.send(Delivery::Steer(message.prompt)).unwrap();
+                        delivery.send(Delivery::Steer(message.prompt, message.attachments)).unwrap();
                         Some((Ok(AgentEvent::Steered { assistant_message_id: None, next_assistant_message_id: None }), (controls, delivery)))
                     }
                 }
@@ -290,7 +290,7 @@ async fn rich_selections_survive_fresh_warm_steer_and_attachment_delivery_for_ev
             .dispatch(CHAT, id, request(&warm), None)
             .await
             .unwrap();
-        let Delivery::Steer(text) = receive(&mut rx).await else {
+        let Delivery::Steer(text, _) = receive(&mut rx).await else {
             panic!("warm run must use mailbox")
         };
         assert_eq!(text, expected(&warm, &readable, id), "{id:?}");
@@ -301,7 +301,7 @@ async fn rich_selections_survive_fresh_warm_steer_and_attachment_delivery_for_ev
             core.sessions.steer(CHAT, &steer, None).await.unwrap(),
             SteerOutcome::Accepted
         ));
-        let Delivery::Steer(text) = receive(&mut rx).await else {
+        let Delivery::Steer(text, _) = receive(&mut rx).await else {
             panic!("steer expected")
         };
         assert_eq!(text, expected(&steer, &readable, id), "{id:?}");
@@ -316,11 +316,13 @@ async fn rich_selections_survive_fresh_warm_steer_and_attachment_delivery_for_ev
             .dispatch(CHAT, id, req.clone(), None)
             .await
             .unwrap();
-        let Delivery::Run(run) = receive(&mut rx).await else {
-            panic!("attachments require a new run")
+        // Images ride the live runtime's mailbox: replacing the runtime to
+        // inline them killed its background work.
+        let Delivery::Steer(text, attachments) = receive(&mut rx).await else {
+            panic!("an attachment must not replace the live runtime")
         };
-        assert_delivered(&run.prompt, &attached, &readable, id);
-        assert_eq!(run.attachments, req.attachments);
+        assert_eq!(text, expected(&attached, &readable, id), "{id:?}");
+        assert_eq!(attachments, req.attachments);
         assert_persisted(&core, &attached, 4);
         core.shutdown().await;
     }
diff --git a/crates/engine/tests/runtime_survival.rs b/crates/engine/tests/runtime_survival.rs
new file mode 100644
index 0000000000..4688d049f8
--- /dev/null
+++ b/crates/engine/tests/runtime_survival.rs
@@ -0,0 +1,1040 @@
+//! A live runtime is the agent's whole process — its background subagents and
+//! background shells included. Sending the next message, steering, "send
+//! now", switching models, or leaving a session parked must never tear it
+//! down behind the user's back (2026-09-29: "sometimes sending a message
+//! closes the existing claude session and re-opens it … it kills subagents
+//! and sub processes"). The user's Stop is the one deliberate teardown.
+//!
+//! The harness here models one persistent agent process per `run()`: every
+//! `run()` is a spawn, the `interrupt` token is its death, a turn stop ends
+//! only the turn, and the test decides when the "background task" finishes.
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use async_trait::async_trait;
+use futures::StreamExt;
+use futures::stream::BoxStream;
+use tokio::sync::mpsc;
+
+use zeron_doc::{MessageStatus, SessionCommandPayload};
+use zeron_engine::{EngineCore, HarnessRegistry};
+use zeron_harness::{Harness, HarnessError, RunControls, TurnControl};
+use zeron_proto::{
+    AgentEvent, DoneStatus, HarnessId, Model, ReasoningLevel, RunRequest, SandboxLevel,
+    SessionStatus, SteeringMode,
+};
+
+const CHAT: &str = "chat-runtime-survival";
+
+#[derive(Default)]
+struct Ledger {
+    spawns: AtomicUsize,
+    kills: AtomicUsize,
+    /// Every prompt the live process received, with its image count.
+    prompts: Mutex<Vec<(String, usize)>>,
+    /// The latest runtime's turn control (the test flips its background work).
+    turn: Mutex<Option<TurnControl>>,
+    /// The model each in-place reconfiguration switched the process to.
+    reconfigured: Mutex<Vec<Option<String>>>,
+    /// The model each process was spawned with.
+    spawned_models: Mutex<Vec<Option<String>>>,
+    /// Ends a turn whose prompt contains `wait`.
+    release: tokio::sync::Notify,
+}
+
+/// One persistent agent process per `run()`. A prompt containing `hold`
+/// stays in flight until stopped; any other prompt completes at once. A
+/// steer containing `vanish` kills the process before it confirms the steer.
+/// A prompt containing `wait` runs until the test releases it.
+struct ProcessHarness {
+    ledger: Arc<Ledger>,
+    /// Model changes apply to the live process (`set_model`-style).
+    adopts_config: bool,
+    /// Takes input only between turns (Hermes, Antigravity): the engine
+    /// holds sends made mid-turn for the turn's end.
+    turn_boundary: bool,
+}
+
+fn done(status: DoneStatus) -> AgentEvent {
+    AgentEvent::Done {
+        status,
+        result: None,
+        error: None,
+        session_id: Some("provider-session".into()),
+    }
+}
+
+#[async_trait]
+impl Harness for ProcessHarness {
+    fn id(&self) -> HarnessId {
+        HarnessId::Mock
+    }
+    fn display_name(&self) -> &str {
+        "Process"
+    }
+    fn supports_steering(&self) -> bool {
+        true
+    }
+    fn steering_mode(&self) -> SteeringMode {
+        if self.turn_boundary {
+            SteeringMode::TurnBoundary
+        } else {
+            SteeringMode::StepBoundary
+        }
+    }
+    fn reasoning_levels(&self) -> &[ReasoningLevel] {
+        &[ReasoningLevel::Medium, ReasoningLevel::High]
+    }
+    fn deterministic_turn_end(&self) -> bool {
+        true
+    }
+    fn stops_turn_in_place(&self) -> bool {
+        true
+    }
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        self.adopts_config && live.cwd == next.cwd
+    }
+    async fn models(&self) -> Result<Vec<Model>, HarnessError> {
+        Ok(vec![])
+    }
+    async fn run(
+        &self,
+        request: RunRequest,
+        mut controls: RunControls,
+    ) -> Result<BoxStream<'static, Result<AgentEvent, HarnessError>>, HarnessError> {
+        let ledger = self.ledger.clone();
+        ledger.spawns.fetch_add(1, Ordering::SeqCst);
+        ledger
+            .spawned_models
+            .lock()
+            .unwrap()
+            .push(request.model.clone());
+        *ledger.turn.lock().unwrap() = Some(controls.turn.clone());
+        let (tx, rx) = mpsc::channel::<Result<AgentEvent, HarnessError>>(64);
+        tokio::spawn(async move {
+            let turn = controls.turn.clone();
+            let send = |event: AgentEvent| {
+                let tx = tx.clone();
+                async move { tx.send(Ok(event)).await.is_ok() }
+            };
+            let prompt = |text: &str, images: usize| {
+                ledger
+                    .prompts
+                    .lock()
+                    .unwrap()
+                    .push((text.to_owned(), images));
+                text.contains("hold")
+            };
+            let _ = send(AgentEvent::SessionStarted {
+                harness: HarnessId::Mock,
+                model: "process".into(),
+                tools: vec![],
+                cwd: request.cwd.clone(),
+                session_id: "provider-session".into(),
+                assistant_message_id: "a0".into(),
+            })
+            .await;
+            let holding = prompt(&request.prompt, request.attachments.len());
+            let _ = send(AgentEvent::TextDelta {
+                text: format!("on it: {}", request.prompt),
+            })
+            .await;
+            let mut waiting = request.prompt.contains("wait");
+            if !holding && !waiting && !send(done(DoneStatus::Completed)).await {
+                return;
+            }
+            loop {
+                tokio::select! {
+                    biased;
+                    _ = ledger.release.notified(), if waiting => {
+                        waiting = false;
+                        if !send(done(DoneStatus::Completed)).await {
+                            return;
+                        }
+                    }
+                    _ = controls.interrupt.cancelled() => {
+                        // The process dies, and its background work with it.
+                        ledger.kills.fetch_add(1, Ordering::SeqCst);
+                        let _ = send(done(DoneStatus::Interrupted)).await;
+                        return;
+                    }
+                    _ = turn.stop_requested() => {
+                        if !send(done(DoneStatus::Interrupted)).await {
+                            return;
+                        }
+                    }
+                    steer = controls.steering.recv() => {
+                        let Some(steer) = steer else { return };
+                        if steer.prompt.contains("vanish") {
+                            return;
+                        }
+                        if let Some(config) = &steer.config {
+                            ledger.reconfigured.lock().unwrap().push(config.model.clone());
+                        }
+                        let holding = prompt(&steer.prompt, steer.attachments.len());
+                        let boundary = AgentEvent::Steered {
+                            assistant_message_id: None,
+                            next_assistant_message_id: None,
+                        };
+                        if !send(boundary).await
+                            || !send(AgentEvent::TextDelta { text: format!("on it: {}", steer.prompt) }).await
+                        {
+                            return;
+                        }
+                        waiting = steer.prompt.contains("wait");
+                        if !holding && !waiting && !send(done(DoneStatus::Completed)).await {
+                            return;
+                        }
+                    }
+                }
+            }
+        });
+        Ok(
+            futures::stream::unfold(rx, |mut rx| async move { rx.recv().await.map(|e| (e, rx)) })
+                .boxed(),
+        )
+    }
+}
+
+struct Rig {
+    core: EngineCore,
+    ledger: Arc<Ledger>,
+    _dir: tempfile::TempDir,
+}
+
+fn rig() -> Rig {
+    rig_with(false)
+}
+
+fn rig_with(adopts_config: bool) -> Rig {
+    rig_full(adopts_config, false)
+}
+
+fn rig_full(adopts_config: bool, turn_boundary: bool) -> Rig {
+    let ledger = Arc::new(Ledger::default());
+    let registry = HarnessRegistry::new();
+    registry.register(Arc::new(ProcessHarness {
+        ledger: ledger.clone(),
+        adopts_config,
+        turn_boundary,
+    }));
+    let dir = tempfile::tempdir().unwrap();
+    let core = EngineCore::assemble(dir.path(), Arc::new(registry), HarnessId::Mock, None)
+        .expect("engine core assembles");
+    Rig {
+        core,
+        ledger,
+        _dir: dir,
+    }
+}
+
+fn request(prompt: &str) -> RunRequest {
+    RunRequest {
+        mcp: None,
+        prompt: prompt.into(),
+        harness: Some(HarnessId::Mock),
+        model: Some("process-1".into()),
+        reasoning: Some(ReasoningLevel::High),
+        model_options: serde_json::Map::from_iter([("fastMode".into(), serde_json::json!(true))]),
+        cwd: "/tmp".into(),
+        sandbox: SandboxLevel::WorkspaceWrite,
+        auto_approve: false,
+        attachments: Vec::new(),
+        worktree: None,
+        resume: None,
+    }
+}
+
+fn status(core: &EngineCore) -> Option<SessionStatus> {
+    core.sessions.session_status(CHAT).map(|s| s.status)
+}
+
+async fn wait_for(mut predicate: impl FnMut() -> bool, what: &str) {
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
+    while !predicate() {
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "timed out waiting for {what}"
+        );
+        tokio::time::sleep(Duration::from_millis(10)).await;
+    }
+}
+
+async fn settle(rig: &Rig, prompts: usize) {
+    wait_for(
+        || {
+            status(&rig.core) == Some(SessionStatus::Idle)
+                && rig.ledger.prompts.lock().unwrap().len() >= prompts
+        },
+        "the turn to park",
+    )
+    .await;
+}
+
+#[tokio::test]
+async fn sends_with_images_or_respelled_options_join_the_live_runtime() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("launch the scouts"), None)
+        .await
+        .unwrap();
+    settle(&rig, 1).await;
+
+    // The phone spells the same option as a string, and the message carries
+    // an image: neither is a different runtime.
+    let mut follow_up = request("what is in this screenshot?");
+    follow_up.model_options =
+        serde_json::Map::from_iter([("fastMode".into(), serde_json::json!("true"))]);
+    follow_up.sandbox = SandboxLevel::WorkspaceWrite;
+    follow_up.attachments = vec!["/tmp/shot.png".into()];
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, follow_up, None)
+        .await
+        .unwrap();
+    settle(&rig, 2).await;
+
+    // Through the durable command plane too (the desktop/mobile send path).
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: request("and one more"),
+                message_id: "m-3".into(),
+            },
+        )
+        .unwrap();
+    settle(&rig, 3).await;
+
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 1, "one process");
+    assert_eq!(rig.ledger.kills.load(Ordering::SeqCst), 0);
+    assert_eq!(
+        rig.ledger.prompts.lock().unwrap()[1],
+        ("what is in this screenshot?".to_string(), 1),
+        "the image rode the mailbox"
+    );
+
+    // A real configuration change still gets a fresh runtime.
+    let mut other_model = request("switch models");
+    other_model.model = Some("process-2".into());
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, other_model, None)
+        .await
+        .unwrap();
+    settle(&rig, 4).await;
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 2);
+    rig.core.sessions.shutdown().await;
+}
+
+/// Switching models mid-chat on a driver that adopts configuration in place
+/// (Claude's `set_model`/`apply_flag_settings`, Codex's per-turn params)
+/// keeps the process — and every background subagent and shell it holds.
+#[tokio::test]
+async fn a_model_switch_is_adopted_by_the_live_runtime() {
+    let rig = rig_with(true);
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("launch the scouts"), None)
+        .await
+        .unwrap();
+    settle(&rig, 1).await;
+
+    let mut other_model = request("switch models");
+    other_model.model = Some("process-2".into());
+    other_model.reasoning = Some(ReasoningLevel::Medium);
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, other_model, None)
+        .await
+        .unwrap();
+    settle(&rig, 2).await;
+
+    // The same model again is the (now reconfigured) same runtime: no
+    // second reconfiguration rides along.
+    let mut again = request("still on the new model");
+    again.model = Some("process-2".into());
+    again.reasoning = Some(ReasoningLevel::Medium);
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, again, None)
+        .await
+        .unwrap();
+    settle(&rig, 3).await;
+
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 1, "one process");
+    assert_eq!(rig.ledger.kills.load(Ordering::SeqCst), 0);
+    assert_eq!(
+        *rig.ledger.reconfigured.lock().unwrap(),
+        vec![Some("process-2".to_string())]
+    );
+
+    // A different directory still needs a different process.
+    let mut elsewhere = request("over there");
+    elsewhere.cwd = "/var".into();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, elsewhere, None)
+        .await
+        .unwrap();
+    settle(&rig, 4).await;
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 2);
+    rig.core.sessions.shutdown().await;
+}
+
+/// A message the runtime accepted but died before confirming is replayed as
+/// it was sent — its images and configuration included, under its own id —
+/// not as the chat's latest request with the images stripped.
+#[tokio::test]
+async fn a_message_orphaned_by_a_dying_runtime_replays_as_sent() {
+    let rig = rig_with(true);
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: working"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the agent to be running the turn",
+    )
+    .await;
+
+    let mut sent = request("vanish: what is in this screenshot?");
+    sent.model = Some("process-2".into());
+    sent.attachments = vec!["/tmp/shot.png".into()];
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, sent, Some("m-orphan".into()))
+        .await
+        .unwrap();
+    settle(&rig, 2).await;
+
+    assert_eq!(
+        rig.ledger.spawns.load(Ordering::SeqCst),
+        2,
+        "a fresh runtime"
+    );
+    assert_eq!(
+        rig.ledger.prompts.lock().unwrap()[1],
+        ("vanish: what is in this screenshot?".to_string(), 1),
+        "the image survived the replay"
+    );
+    assert_eq!(
+        rig.ledger.spawned_models.lock().unwrap()[1].as_deref(),
+        Some("process-2"),
+        "the configuration it was sent with"
+    );
+    let entries = rig
+        .core
+        .doc_host
+        .open(CHAT)
+        .unwrap()
+        .doc()
+        .read_entries()
+        .unwrap();
+    let orphan: Vec<_> = entries
+        .iter()
+        .filter(|e| e.role == zeron_doc::MessageRole::User && e.id != entries[0].id)
+        .map(|e| e.id.as_str())
+        .collect();
+    assert_eq!(orphan, ["m-orphan"], "one entry, under its own id");
+    rig.core.sessions.shutdown().await;
+}
+
+/// Every distinct completion ping the chat publishes, recorded until the
+/// returned handle is aborted.
+fn record_pings(rig: &Rig) -> (Arc<Mutex<Vec<String>>>, tokio::task::JoinHandle<()>) {
+    let pings = Arc::new(Mutex::new(Vec::<String>::new()));
+    let sessions = rig.core.sessions.clone();
+    let seen = pings.clone();
+    let task = tokio::spawn(async move {
+        loop {
+            if let Some(ping) = sessions
+                .session_status(CHAT)
+                .and_then(|s| s.last_completed_turn)
+            {
+                let mut seen = seen.lock().unwrap();
+                if seen.last() != Some(&ping) {
+                    seen.push(ping);
+                }
+            }
+            tokio::time::sleep(Duration::from_millis(2)).await;
+        }
+    });
+    (pings, task)
+}
+
+fn queued(rig: &Rig) -> Vec<String> {
+    rig.core
+        .doc_host
+        .open(CHAT)
+        .unwrap()
+        .watch_queue()
+        .borrow()
+        .iter()
+        .map(|row| row.text.clone())
+        .collect()
+}
+
+/// A send to a turn-boundary agent mid-turn waits for the turn's end — and
+/// then runs as it was sent (its image, its model), with no "done" ping for
+/// the turn that hands over to it.
+#[tokio::test]
+async fn a_send_held_for_the_turn_end_runs_as_sent_without_a_ping() {
+    let rig = rig_full(true, true);
+    let (pings, recorder) = record_pings(&rig);
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("wait: first"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the first turn to run",
+    )
+    .await;
+    let mut sent = request("second");
+    sent.model = Some("process-2".into());
+    sent.attachments = vec!["/tmp/shot.png".into()];
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: sent,
+                message_id: "m-held".into(),
+            },
+        )
+        .unwrap();
+    wait_for(|| queued(&rig) == ["second"], "the send to be held").await;
+
+    rig.ledger.release.notify_one();
+    settle(&rig, 2).await;
+    wait_for(
+        || {
+            rig.core
+                .sessions
+                .session_status(CHAT)
+                .and_then(|s| s.last_completed_turn)
+                .is_some()
+        },
+        "the held send's reply to complete",
+    )
+    .await;
+    tokio::time::sleep(Duration::from_millis(200)).await;
+    recorder.abort();
+    assert_eq!(
+        rig.ledger.prompts.lock().unwrap()[1],
+        ("second".to_string(), 1),
+        "the held send kept its image"
+    );
+    assert_eq!(
+        *rig.ledger.reconfigured.lock().unwrap(),
+        vec![Some("process-2".to_string())],
+        "the held send ran on the model it was sent with"
+    );
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 1);
+    let last_reply = rig
+        .core
+        .doc_host
+        .open(CHAT)
+        .unwrap()
+        .doc()
+        .read_entries()
+        .unwrap()
+        .last()
+        .map(|e| e.id.clone())
+        .unwrap();
+    assert_eq!(
+        *pings.lock().unwrap(),
+        vec![last_reply],
+        "only the held send's reply pings: the handover to it is not a completion"
+    );
+    rig.core.sessions.shutdown().await;
+}
+
+/// A Stop cancels what was sent during the turn it stops: a send held for
+/// that turn's end never runs — not even after the user's next message
+/// thaws the queue.
+#[tokio::test]
+async fn stop_cancels_sends_held_for_the_stopped_turn() {
+    let rig = rig_full(false, true);
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("wait: first"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the first turn to run",
+    )
+    .await;
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: request("held before the stop"),
+                message_id: "m-held".into(),
+            },
+        )
+        .unwrap();
+    wait_for(
+        || queued(&rig) == ["held before the stop"],
+        "the send to be held",
+    )
+    .await;
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    wait_for(
+        || {
+            rig.ledger.kills.load(Ordering::SeqCst) == 1
+                && status(&rig.core) == Some(SessionStatus::Idle)
+                && queued(&rig).is_empty()
+        },
+        "the stop to cancel the held send",
+    )
+    .await;
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: request("after the stop"),
+                message_id: "m-after".into(),
+            },
+        )
+        .unwrap();
+    wait_for(
+        || {
+            rig.ledger
+                .prompts
+                .lock()
+                .unwrap()
+                .iter()
+                .any(|(p, _)| p == "after the stop")
+        },
+        "the next message to run",
+    )
+    .await;
+    settle(&rig, 2).await;
+    tokio::time::sleep(Duration::from_millis(300)).await;
+    assert!(
+        !rig.ledger
+            .prompts
+            .lock()
+            .unwrap()
+            .iter()
+            .any(|(p, _)| p.contains("held before the stop")),
+        "a send held for the stopped turn ran after the Stop"
+    );
+    rig.core.sessions.shutdown().await;
+}
+
+/// A message sent before a Stop whose dispatch only lands once the Stop
+/// has torn the runtime down (a loaded host, a slow agent) was cancelled by
+/// it: it must not start the stopped work again in a fresh runtime.
+#[tokio::test]
+async fn a_message_the_stop_cancelled_never_reaches_a_fresh_runtime() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: working"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the agent to be running the turn",
+    )
+    .await;
+    // The Stop acts with the message still on its way …
+    rig.core
+        .sessions
+        .cancel_sent_messages(CHAT, vec!["m-late".into()]);
+    rig.core.sessions.interrupt(CHAT).await.unwrap();
+    // … and the message reaches dispatch only now.
+    rig.core
+        .sessions
+        .dispatch(
+            CHAT,
+            HarnessId::Mock,
+            request("hold: sent before the stop"),
+            Some("m-late".into()),
+        )
+        .await
+        .unwrap();
+    tokio::time::sleep(Duration::from_millis(300)).await;
+    assert_eq!(
+        rig.ledger.spawns.load(Ordering::SeqCst),
+        1,
+        "no fresh runtime"
+    );
+    assert_eq!(status(&rig.core), Some(SessionStatus::Idle));
+    // The user's next message still runs.
+    rig.core
+        .sessions
+        .dispatch(
+            CHAT,
+            HarnessId::Mock,
+            request("after the stop"),
+            Some("m-next".into()),
+        )
+        .await
+        .unwrap();
+    settle(&rig, 2).await;
+    assert_eq!(rig.ledger.prompts.lock().unwrap()[1].0, "after the stop");
+    rig.core.sessions.shutdown().await;
+}
+
+/// "Send now" replaces the in-flight turn but keeps the runtime and its
+/// background work; the user's Stop is a hard boundary that tears all of it
+/// down, and the next message starts a fresh process.
+#[tokio::test]
+async fn send_now_keeps_the_runtime_and_stop_tears_it_down() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: build it"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.turn.lock().unwrap().is_some(),
+        "the runtime to start",
+    )
+    .await;
+    let turn = rig.ledger.turn.lock().unwrap().clone().unwrap();
+    turn.set_background(1);
+    wait_for(
+        || status(&rig.core) == Some(SessionStatus::Working),
+        "the turn to run",
+    )
+    .await;
+
+    // Send now: the turn ends in place.
+    assert!(rig.core.sessions.stop_turn(CHAT).await.unwrap());
+    assert_eq!(status(&rig.core), Some(SessionStatus::Idle));
+    let doc = rig.core.doc_host.open(CHAT).unwrap();
+    assert!(
+        doc.doc()
+            .read_entries()
+            .unwrap()
+            .iter()
+            .any(|entry| entry.status == Some(MessageStatus::Aborted)),
+        "the replaced turn reads as stopped"
+    );
+    assert_eq!(rig.ledger.kills.load(Ordering::SeqCst), 0, "no teardown");
+    assert!(
+        !rig.core.sessions.stop_turn(CHAT).await.unwrap(),
+        "a parked runtime has no turn to stop"
+    );
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: again"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || {
+            status(&rig.core) == Some(SessionStatus::Working)
+                && rig.ledger.prompts.lock().unwrap().len() == 2
+        },
+        "the second turn to run",
+    )
+    .await;
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 1, "one process");
+    assert!(turn.background_live());
+
+    // Stop (the Cancel command): the runtime and its work are gone.
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    wait_for(
+        || status(&rig.core) == Some(SessionStatus::Idle),
+        "stop to settle",
+    )
+    .await;
+    wait_for(
+        || rig.ledger.kills.load(Ordering::SeqCst) == 1,
+        "the runtime to be torn down",
+    )
+    .await;
+    assert!(!rig.core.sessions.live_run_steerable(CHAT));
+
+    // The next message starts a fresh process.
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("status?"), None)
+        .await
+        .unwrap();
+    settle(&rig, 3).await;
+    assert_eq!(rig.ledger.spawns.load(Ordering::SeqCst), 2);
+    rig.core.sessions.shutdown().await;
+}
+
+/// Stop pressed right after Send: controls bypass the prompt drain, and the
+/// Stop used to run before the send had dispatched — it found no turn, did
+/// nothing, and the turn then ran in full.
+#[tokio::test]
+async fn a_stop_right_after_send_stops_that_turn() {
+    let rig = rig();
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: request("hold: the essay"),
+                message_id: "m-1".into(),
+            },
+        )
+        .unwrap();
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    wait_for(
+        || rig.ledger.kills.load(Ordering::SeqCst) == 1,
+        "the Stop to tear the turn down",
+    )
+    .await;
+    wait_for(
+        || status(&rig.core) == Some(SessionStatus::Idle),
+        "the stopped chat to settle",
+    )
+    .await;
+    assert_eq!(rig.ledger.prompts.lock().unwrap().len(), 1);
+    rig.core.sessions.shutdown().await;
+}
+
+/// Send pressed right after Stop: it used to land in the mailbox of the
+/// runtime the Stop was tearing down, and an interrupted run re-dispatches
+/// nothing — the message showed as sent and never ran.
+#[tokio::test]
+async fn a_send_right_after_stop_runs_in_a_fresh_runtime() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: working"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the agent to be running the turn",
+    )
+    .await;
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: request("after the stop"),
+                message_id: "m-2".into(),
+            },
+        )
+        .unwrap();
+    wait_for(
+        || {
+            rig.ledger
+                .prompts
+                .lock()
+                .unwrap()
+                .iter()
+                .any(|(p, _)| p == "after the stop")
+        },
+        "the message sent after Stop to run",
+    )
+    .await;
+    settle(&rig, 2).await;
+    assert_eq!(rig.ledger.kills.load(Ordering::SeqCst), 1);
+    assert_eq!(
+        rig.ledger.spawns.load(Ordering::SeqCst),
+        2,
+        "a fresh runtime"
+    );
+    rig.core.sessions.shutdown().await;
+}
+
+/// The raw race under the command plane: a routed send accepted into a
+/// runtime after its Stop began is re-dispatched, never dropped.
+#[tokio::test]
+async fn a_send_accepted_by_a_stopping_runtime_is_redispatched() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: working"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the agent to be running the turn",
+    )
+    .await;
+    let (stop, send) = tokio::join!(
+        rig.core.sessions.interrupt(CHAT),
+        rig.core
+            .sessions
+            .dispatch(CHAT, HarnessId::Mock, request("racing the stop"), None)
+    );
+    stop.unwrap();
+    send.unwrap();
+    wait_for(
+        || {
+            rig.ledger
+                .prompts
+                .lock()
+                .unwrap()
+                .iter()
+                .filter(|(p, _)| p == "racing the stop")
+                .count()
+                >= 1
+                && status(&rig.core) == Some(SessionStatus::Idle)
+        },
+        "the racing message to run",
+    )
+    .await;
+    assert_eq!(
+        rig.ledger.kills.load(Ordering::SeqCst),
+        1,
+        "the Stop tore it down"
+    );
+    rig.core.sessions.shutdown().await;
+}
+
+/// A steer sent before Stop is cancelled with the turn: it must never run
+/// later in the fresh runtime as if it were the user's next message.
+#[tokio::test]
+async fn a_steer_sent_before_stop_is_cancelled_with_it() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(CHAT, HarnessId::Mock, request("hold: working"), None)
+        .await
+        .unwrap();
+    wait_for(
+        || rig.ledger.prompts.lock().unwrap().len() == 1,
+        "the agent to be running the turn",
+    )
+    .await;
+    rig.core
+        .doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: request("hold: steer before stop"),
+                message_id: "m-steer".into(),
+            },
+        )
+        .unwrap();
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    wait_for(
+        || {
+            rig.ledger.kills.load(Ordering::SeqCst) == 1
+                && status(&rig.core) == Some(SessionStatus::Idle)
+        },
+        "the stop to settle",
+    )
+    .await;
+    tokio::time::sleep(Duration::from_millis(500)).await;
+    assert_eq!(
+        rig.ledger.spawns.load(Ordering::SeqCst),
+        1,
+        "nothing re-ran"
+    );
+    assert_eq!(status(&rig.core), Some(SessionStatus::Idle));
+    rig.core.sessions.shutdown().await;
+}
+
+/// The idle reaper spares a parked runtime holding background work, so the
+/// user's Stop must reach it and end that work.
+#[tokio::test]
+async fn stop_ends_a_parked_runtime_holding_background_work() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(
+            CHAT,
+            HarnessId::Mock,
+            request("launch a background scout"),
+            None,
+        )
+        .await
+        .unwrap();
+    settle(&rig, 1).await;
+    // A runtime parked with nothing running is left alone.
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    tokio::time::sleep(Duration::from_millis(300)).await;
+    assert_eq!(rig.ledger.kills.load(Ordering::SeqCst), 0);
+
+    let turn = rig.ledger.turn.lock().unwrap().clone().unwrap();
+    turn.set_background(1);
+    rig.core
+        .doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    wait_for(
+        || rig.ledger.kills.load(Ordering::SeqCst) == 1,
+        "the Stop to end the background work",
+    )
+    .await;
+    assert!(!rig.core.sessions.live_run_steerable(CHAT));
+    rig.core.sessions.shutdown().await;
+}
+
+#[tokio::test(start_paused = true)]
+async fn the_idle_reaper_spares_a_runtime_holding_background_work() {
+    let rig = rig();
+    rig.core
+        .sessions
+        .dispatch(
+            CHAT,
+            HarnessId::Mock,
+            request("launch a background scout"),
+            None,
+        )
+        .await
+        .unwrap();
+    settle(&rig, 1).await;
+    let turn = rig.ledger.turn.lock().unwrap().clone().unwrap();
+    turn.set_background(1);
+
+    // Far past the 30-minute idle window: the scout is still running. (The
+    // odd 20 minutes put its end mid-way through a deferred window.)
+    tokio::time::sleep(Duration::from_secs(3 * 60 * 60 + 20 * 60)).await;
+    assert!(
+        rig.core.sessions.live_run_steerable(CHAT),
+        "the reaper killed a runtime holding live background work"
+    );
+    assert_eq!(rig.ledger.kills.load(Ordering::SeqCst), 0);
+
+    // Once the background work is done, an idle runtime is released again —
+    // but not before a full idle window has passed since: the completion's
+    // wake turn starts a moment after the agent reports the work drained.
+    turn.set_background(0);
+    tokio::time::sleep(Duration::from_secs(29 * 60)).await;
+    assert!(
+        rig.core.sessions.live_run_steerable(CHAT),
+        "the reaper killed the runtime as its background work ended"
+    );
+    tokio::time::sleep(Duration::from_secs(2 * 60 * 60)).await;
+    wait_for(
+        || rig.ledger.kills.load(Ordering::SeqCst) == 1,
+        "the idle runtime to be reaped",
+    )
+    .await;
+    rig.core.sessions.shutdown().await;
+}
diff --git a/crates/engine/tests/runtime_survival_live.rs b/crates/engine/tests/runtime_survival_live.rs
new file mode 100644
index 0000000000..45c08fcf06
--- /dev/null
+++ b/crates/engine/tests/runtime_survival_live.rs
@@ -0,0 +1,795 @@
+//! Opt-in real-model checks. A chat's agent process — and the background
+//! work it holds — survives everything but the user's Stop: a follow-up with
+//! an image, another client's spelling of the same options, a steer into a
+//! long command, a model switch. Stop tears all of it down
+//! (`stop_tears_down_all_agent_work`), and a resumed process never reads
+//! as done before its reply.
+//!
+//! ZERON_TEST_HARNESS=claude ZERON_TEST_MODEL=claude-haiku-4-5 \
+//!   cargo test -p zeron-engine --test runtime_survival_live -- --ignored --nocapture
+//!
+//! `ZERON_TEST_HARNESS`: claude | codex | cursor | opencode | devin | hermes |
+//! pi | antigravity | grok. Harnesses whose agents can hold background work
+//! across turns (claude, codex) must also finish that work after the cancel.
+use std::{sync::Arc, time::Duration};
+
+use zeron_doc::SessionCommandPayload;
+use zeron_engine::{EngineCore, HarnessRegistry};
+use zeron_harness::{
+    AcpHarness, ClaudeHarness, CodexHarness, CursorHarness, Harness, OpencodeHarness,
+};
+use zeron_proto::{AgentEvent, ChatConfig, RunRequest, SandboxLevel, SessionStatus};
+
+const CHAT: &str = "survival";
+
+fn processes(core: &EngineCore) -> usize {
+    core.sessions
+        .subscribe(CHAT, 0)
+        .map(|(events, _)| {
+            events
+                .iter()
+                .filter(|e| matches!(e.event, AgentEvent::SessionStarted { .. }))
+                .count()
+        })
+        .unwrap_or(0)
+}
+
+fn completed_turns(core: &EngineCore) -> usize {
+    core.sessions
+        .subscribe(CHAT, 0)
+        .map(|(events, _)| {
+            events
+                .iter()
+                .filter(|e| {
+                    matches!(
+                        e.event,
+                        AgentEvent::Done {
+                            status: zeron_proto::DoneStatus::Completed,
+                            ..
+                        }
+                    )
+                })
+                .count()
+        })
+        .unwrap_or(0)
+}
+
+fn status(core: &EngineCore) -> Option<SessionStatus> {
+    core.sessions.session_status(CHAT).map(|s| s.status)
+}
+
+fn journal(core: &EngineCore) -> Vec<AgentEvent> {
+    core.sessions
+        .subscribe(CHAT, 0)
+        .map(|(events, _)| {
+            events
+                .into_iter()
+                .filter(|e| {
+                    !matches!(
+                        e.event,
+                        AgentEvent::TextDelta { .. } | AgentEvent::ReasoningDelta { .. }
+                    )
+                })
+                .map(|e| e.event)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Waits for `predicate`, giving up early on an errored session.
+async fn wait(core: &EngineCore, secs: u64, mut predicate: impl FnMut() -> bool, what: &str) {
+    let errored = || status(core) == Some(SessionStatus::Errored);
+    let settled = tokio::time::timeout(Duration::from_secs(secs), async {
+        while !predicate() && !errored() {
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
+    })
+    .await;
+    if settled.is_err() || errored() {
+        eprintln!("status: {:?}; events: {:#?}", status(core), journal(core));
+        core.shutdown().await;
+        panic!("gave up waiting for {what}");
+    }
+}
+
+fn run(
+    prompt: &str,
+    model: &Option<String>,
+    harness: zeron_proto::HarnessId,
+    cwd: &str,
+) -> RunRequest {
+    RunRequest {
+        mcp: None,
+        prompt: prompt.into(),
+        harness: Some(harness),
+        model: model.clone(),
+        reasoning: None,
+        model_options: Default::default(),
+        cwd: cwd.into(),
+        sandbox: SandboxLevel::DangerFullAccess,
+        auto_approve: true,
+        attachments: vec![],
+        worktree: None,
+        resume: None,
+    }
+}
+
+#[tokio::test]
+#[ignore = "uses real model quota; select harness and inexpensive model explicitly"]
+async fn agent_process_survives_sends_and_cancel() {
+    let name = std::env::var("ZERON_TEST_HARNESS").expect("select harness");
+    let model = std::env::var("ZERON_TEST_MODEL").ok();
+    let harness: Arc<dyn Harness> = match name.as_str() {
+        "claude" => Arc::new(ClaudeHarness::new()),
+        "codex" => Arc::new(CodexHarness::new()),
+        "cursor" => Arc::new(CursorHarness::new()),
+        "opencode" => Arc::new(OpencodeHarness::new()),
+        "grok" => Arc::new(AcpHarness::grok()),
+        "devin" => Arc::new(AcpHarness::devin()),
+        "hermes" => Arc::new(AcpHarness::hermes()),
+        "pi" => Arc::new(zeron_harness::PiHarness::new()),
+        "antigravity" => Arc::new(AcpHarness::antigravity()),
+        _ => panic!("unknown harness"),
+    };
+    let dir = tempfile::tempdir().unwrap();
+    let cwd = dir.path().to_str().unwrap().to_owned();
+    let id = harness.id();
+    let registry = HarnessRegistry::new();
+    registry.register(harness);
+    let core =
+        EngineCore::assemble(&dir.path().join("engine"), Arc::new(registry), id, None).unwrap();
+    core.workspace
+        .create_space("space", &core.device_id, &cwd, None, false)
+        .unwrap();
+    core.workspace
+        .create_chat(CHAT, Some("space"), None, None, None)
+        .unwrap();
+    core.workspace
+        .set_chat_config(
+            CHAT,
+            &ChatConfig {
+                harness: id,
+                model: model.clone(),
+                reasoning: None,
+                model_options: Default::default(),
+                sandbox: SandboxLevel::DangerFullAccess,
+            },
+        )
+        .unwrap();
+    println!("{name}: workspace {cwd}");
+
+    // 1. Background work that outlives the turn.
+    let background = match name.as_str() {
+        "claude" => Some(
+            "This is an automated test in a disposable directory. Do exactly two things, then end your turn at once without waiting for either: \
+             (1) use the Agent tool with run_in_background=true (subagent_type general-purpose, description 'sleeper') and the prompt \
+             'Run this exact bash command and nothing else: sleep 75 && printf done > sub-done . Then reply DONE.'; \
+             (2) use the Bash tool with run_in_background=true to run exactly: sleep 70 && printf done > bg-done . \
+             Reply only LAUNCHED.",
+        ),
+        "codex" => Some(
+            "This is an automated test in a disposable directory. Spawn one subagent (spawn_agent) whose task is: \
+             'Run this exact shell command and nothing else: sleep 75 && printf done > sub-done . Then reply DONE.' \
+             Do not wait for it and do not run the command yourself. Reply only LAUNCHED once it is spawned.",
+        ),
+        _ => None,
+    };
+    let opening = background.unwrap_or("This is an automated test. Reply only READY.");
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run(opening, &model, id, &cwd),
+                message_id: "m-1".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) >= 1 && status(&core) == Some(SessionStatus::Idle),
+        "the opening turn",
+    )
+    .await;
+    assert_eq!(processes(&core), 1);
+    if background.is_some() {
+        wait(
+            &core,
+            120,
+            || {
+                core.sessions.subscribe(CHAT, 0).is_ok_and(|(events, _)| {
+                    events
+                        .iter()
+                        .any(|e| matches!(e.event, AgentEvent::Subagent { .. }))
+                })
+            },
+            "the background subagent to start",
+        )
+        .await;
+    }
+    println!("{name}: opening turn parked");
+
+    // 2. A follow-up from "another client": an image, and option values
+    // spelled as strings (the phone's encoding).
+    let image = dir.path().join("pixel.png");
+    std::fs::write(
+        &image,
+        [
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48,
+            0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x00, 0x00,
+            0x00, 0x90, 0x77, 0x53, 0xDE, 0x00, 0x00, 0x00, 0x0C, 0x49, 0x44, 0x41, 0x54, 0x08,
+            0xD7, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x18, 0xDD, 0x8D,
+            0xB0, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
+        ],
+    )
+    .unwrap();
+    let mut follow_up = run(
+        &format!(
+            "Attached image: {} (a 1x1 test pixel). Do not use tools. Reply only SEEN.",
+            image.display()
+        ),
+        &model,
+        id,
+        &cwd,
+    );
+    follow_up.attachments = vec![image.display().to_string()];
+    follow_up.model_options = serde_json::Map::from_iter([(
+        "unusedByAnyDriver".to_owned(),
+        serde_json::Value::String(String::new()),
+    )]);
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: follow_up,
+                message_id: "m-2".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) >= 2 && status(&core) == Some(SessionStatus::Idle),
+        "the image follow-up",
+    )
+    .await;
+    assert_eq!(processes(&core), 1, "the follow-up restarted the agent");
+    println!("{name}: image follow-up joined the live process");
+
+    // 2b. Steer a streaming turn into a long foreground command. The steer
+    // ends the streaming reply (Claude's `now`), and until the command and
+    // the reply after it finish the chat must stay Working with no
+    // completion ping (2026-10-01: "marked done immediately", sound and
+    // notification while the agent was still running the steered work).
+    let pings = |core: &EngineCore| {
+        core.sessions
+            .session_status(CHAT)
+            .and_then(|s| s.last_completed_turn)
+    };
+    let before_pings = pings(&core);
+    let before_done = completed_turns(&core);
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run(
+                    "Write a 600-word essay about rivers. Do not use tools.",
+                    &model,
+                    id,
+                    &cwd,
+                ),
+                message_id: "m-2b".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || {
+            status(&core) == Some(SessionStatus::Working)
+                && core.sessions.subscribe(CHAT, 0).is_ok_and(|(events, _)| {
+                    events
+                        .iter()
+                        .rev()
+                        .take_while(|e| !matches!(e.event, AgentEvent::Done { .. }))
+                        .filter(|e| matches!(&e.event, AgentEvent::TextDelta { .. }))
+                        .count()
+                        > 5
+                })
+        },
+        "the essay to stream",
+    )
+    .await;
+    core.sessions
+        .dispatch(
+            CHAT,
+            id,
+            run(
+                "Stop the essay now. Run this exact shell command in the FOREGROUND and wait for it: sleep 12 && printf ok > steer-done . Then reply only STEERED.",
+                &model,
+                id,
+                &cwd,
+            ),
+            Some("m-2b-steer".into()),
+        )
+        .await
+        .unwrap();
+    let steered_at = std::time::Instant::now();
+    let mut premature = Vec::new();
+    while !dir.path().join("steer-done").exists() {
+        assert!(
+            steered_at.elapsed() < Duration::from_secs(240),
+            "the steered command never ran: {:#?}",
+            journal(&core)
+        );
+        if status(&core) != Some(SessionStatus::Working) || pings(&core) != before_pings {
+            premature.push((steered_at.elapsed(), status(&core), pings(&core)));
+        }
+        tokio::time::sleep(Duration::from_millis(50)).await;
+    }
+    wait(
+        &core,
+        240,
+        || status(&core) == Some(SessionStatus::Idle) && completed_turns(&core) > before_done,
+        "the steered turn to end",
+    )
+    .await;
+    assert!(
+        premature.is_empty(),
+        "the steered turn read as done while its command ran: {premature:?}\n{:#?}",
+        journal(&core)
+    );
+    assert_ne!(
+        pings(&core),
+        before_pings,
+        "the steered turn's end pings once"
+    );
+    assert_eq!(processes(&core), 1, "the steer restarted the agent");
+    println!("{name}: steer into a long command stayed Working until its real end");
+
+    // 2c. Switch models on a follow-up: the live process adopts it.
+    if let Ok(other) = std::env::var("ZERON_TEST_OTHER_MODEL") {
+        let before = completed_turns(&core);
+        core.doc_host
+            .queue_command(
+                CHAT,
+                SessionCommandPayload::Run {
+                    request: run(
+                        "Do not use tools. Reply only SWITCHED.",
+                        &Some(other.clone()),
+                        id,
+                        &cwd,
+                    ),
+                    message_id: "m-2c".into(),
+                },
+            )
+            .unwrap();
+        wait(
+            &core,
+            240,
+            || completed_turns(&core) > before && status(&core) == Some(SessionStatus::Idle),
+            "the model-switch follow-up",
+        )
+        .await;
+        assert_eq!(processes(&core), 1, "the model switch restarted the agent");
+        println!("{name}: switched to {other} in the live process");
+    }
+
+    // 3. The background work the opening turn launched ran to completion.
+    if background.is_some() {
+        let expect: &[&str] = if name == "claude" {
+            &["sub-done", "bg-done"]
+        } else {
+            &["sub-done"]
+        };
+        wait(
+            &core,
+            240,
+            || expect.iter().all(|f| dir.path().join(f).exists()),
+            "the background work to finish",
+        )
+        .await;
+        println!("{name}: background work finished: {expect:?}");
+        assert_eq!(processes(&core), 1);
+    }
+    core.shutdown().await;
+}
+
+/// "Marked done the moment I sent it": a chat whose agent process died with
+/// background work still running (app restart, idle reap, a config-change
+/// restart) resumes in a new process, and the CLI settles the dead tasks
+/// with empty results while the new message is still queued. None of them
+/// may complete the message — no Idle, no completion ping — before its
+/// reply.
+///
+/// ZERON_TEST_HARNESS=claude ZERON_TEST_MODEL=claude-sonnet-5-5 \
+///   cargo test -p zeron-engine --test runtime_survival_live resume_after -- --ignored --nocapture
+#[tokio::test]
+#[ignore = "uses real model quota; select harness and inexpensive model explicitly"]
+async fn resume_after_killed_background_work_is_not_done_early() {
+    let name = std::env::var("ZERON_TEST_HARNESS").unwrap_or_else(|_| "claude".into());
+    let model = std::env::var("ZERON_TEST_MODEL").ok();
+    let id = match name.as_str() {
+        "claude" => zeron_proto::HarnessId::ClaudeCode,
+        "codex" => zeron_proto::HarnessId::Codex,
+        _ => panic!("claude or codex"),
+    };
+    let dir = tempfile::tempdir().unwrap();
+    let cwd = dir.path().to_str().unwrap().to_owned();
+    let engine_dir = dir.path().join("engine");
+    let assemble = || {
+        let registry = HarnessRegistry::new();
+        let harness: Arc<dyn Harness> = if id == zeron_proto::HarnessId::Codex {
+            Arc::new(CodexHarness::new())
+        } else {
+            Arc::new(ClaudeHarness::new())
+        };
+        registry.register(harness);
+        EngineCore::assemble(&engine_dir, Arc::new(registry), id, None).unwrap()
+    };
+    let core = assemble();
+    core.workspace
+        .create_space("space", &core.device_id, &cwd, None, false)
+        .unwrap();
+    core.workspace
+        .create_chat(CHAT, Some("space"), None, None, None)
+        .unwrap();
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run(
+                    if id == zeron_proto::HarnessId::Codex {
+                        "This is an automated test in a disposable directory. Spawn one subagent (spawn_agent) whose task is: \
+                         'Run this exact shell command and nothing else: python3 -c \"import time; time.sleep(170)\" . Then reply DONE.' \
+                         Do not wait for it and do not run the command yourself. Reply only LAUNCHED once it is spawned."
+                    } else {
+                        "This is an automated test in a disposable directory. Do exactly two things, then end your turn at once without waiting for either: \
+                         (1) use the Bash tool with run_in_background=true to run exactly: python3 -c 'import time; time.sleep(180)' ; \
+                         (2) use the Agent tool with run_in_background=true (subagent_type general-purpose) and the prompt \
+                         'Run this exact bash command in the foreground and nothing else: python3 -c \"import time; time.sleep(170)\" . Then reply DONE.'. \
+                         Reply only LAUNCHED."
+                    },
+                    &model,
+                    id,
+                    &cwd,
+                ),
+                message_id: "m-1".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) >= 1 && status(&core) == Some(SessionStatus::Idle),
+        "the opening turn",
+    )
+    .await;
+    wait(
+        &core,
+        120,
+        || {
+            core.sessions.subscribe(CHAT, 0).is_ok_and(|(events, _)| {
+                events
+                    .iter()
+                    .any(|e| matches!(e.event, AgentEvent::Subagent { .. }))
+            })
+        },
+        "the background subagent to start",
+    )
+    .await;
+    // The process dies with its background work (an app restart).
+    core.shutdown().await;
+    drop(core);
+    println!("{name}: engine restarted under live background work");
+
+    let core = assemble();
+    let pings = |core: &EngineCore| {
+        core.sessions
+            .session_status(CHAT)
+            .and_then(|s| s.last_completed_turn)
+    };
+    let before_pings = pings(&core);
+    let before_events = core
+        .sessions
+        .subscribe(CHAT, 0)
+        .map(|(events, _)| events.len())
+        .unwrap_or(0);
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run("Do not use tools. Reply only PONG.", &model, id, &cwd),
+                message_id: "m-2".into(),
+            },
+        )
+        .unwrap();
+    // Deltas are tokens: "PONG" may arrive split.
+    let replied = |core: &EngineCore| {
+        core.sessions.subscribe(CHAT, 0).is_ok_and(|(events, _)| {
+            events
+                .iter()
+                .skip(before_events)
+                .filter_map(|e| match &e.event {
+                    AgentEvent::TextDelta { text } => Some(text.as_str()),
+                    _ => None,
+                })
+                .collect::<String>()
+                .contains("PONG")
+        })
+    };
+    wait(
+        &core,
+        60,
+        || status(&core) == Some(SessionStatus::Working),
+        "the resumed message to start",
+    )
+    .await;
+    let sent = std::time::Instant::now();
+    let mut premature = Vec::new();
+    while !replied(&core) {
+        assert!(
+            sent.elapsed() < Duration::from_secs(180),
+            "no reply: {:#?}",
+            journal(&core)
+        );
+        if status(&core) != Some(SessionStatus::Working) || pings(&core) != before_pings {
+            premature.push((sent.elapsed(), status(&core), pings(&core)));
+        }
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    wait(
+        &core,
+        120,
+        || status(&core) == Some(SessionStatus::Idle) && pings(&core) != before_pings,
+        "the resumed message to end",
+    )
+    .await;
+    assert!(
+        premature.is_empty(),
+        "the resumed message read as done before its reply: {premature:?}\n{:#?}",
+        journal(&core)
+    );
+    println!("{name}: resumed message stayed Working until its reply");
+    core.shutdown().await;
+    let _ = std::process::Command::new("pkill")
+        .args(["-f", "time.sleep.1[78]0"])
+        .status();
+}
+
+/// Stop is a hard boundary: the Stop button ends the turn AND everything the
+/// agent runs — background subagents, background shells, the foreground
+/// command — while sends, steers and model switches never touch them (see
+/// `agent_process_survives_sends_and_cancel`). The next message resumes the
+/// conversation in a fresh process without reading as done early.
+///
+/// ZERON_TEST_HARNESS=claude ZERON_TEST_MODEL=claude-sonnet-5-5 \
+///   cargo test -p zeron-engine --test runtime_survival_live stop_ -- --ignored --nocapture
+#[tokio::test]
+#[ignore = "uses real model quota; select harness and inexpensive model explicitly"]
+async fn stop_tears_down_all_agent_work() {
+    let name = std::env::var("ZERON_TEST_HARNESS").unwrap_or_else(|_| "claude".into());
+    let model = std::env::var("ZERON_TEST_MODEL").ok();
+    let (id, harness): (zeron_proto::HarnessId, Arc<dyn Harness>) = match name.as_str() {
+        "claude" => (
+            zeron_proto::HarnessId::ClaudeCode,
+            Arc::new(ClaudeHarness::new()),
+        ),
+        "codex" => (zeron_proto::HarnessId::Codex, Arc::new(CodexHarness::new())),
+        _ => panic!("claude or codex"),
+    };
+    let alive = || {
+        std::process::Command::new("pgrep")
+            .args(["-f", "time.sleep.(19[1-5])"])
+            .output()
+            .map(|o| {
+                String::from_utf8_lossy(&o.stdout)
+                    .split_whitespace()
+                    .count()
+            })
+            .unwrap_or(0)
+    };
+    assert_eq!(alive(), 0, "stale probe processes from an earlier run");
+    let dir = tempfile::tempdir().unwrap();
+    let cwd = dir.path().to_str().unwrap().to_owned();
+    let registry = HarnessRegistry::new();
+    registry.register(harness);
+    let core =
+        EngineCore::assemble(&dir.path().join("engine"), Arc::new(registry), id, None).unwrap();
+    core.workspace
+        .create_space("space", &core.device_id, &cwd, None, false)
+        .unwrap();
+    core.workspace
+        .create_chat(CHAT, Some("space"), None, None, None)
+        .unwrap();
+    let opening = if id == zeron_proto::HarnessId::Codex {
+        "This is an automated test in a disposable directory. Do exactly two things, then end your turn without waiting: \
+         (1) spawn one subagent (spawn_agent) whose task is: 'Run this exact shell command in the foreground and nothing else: python3 -c \"import time; time.sleep(191)\" . Then reply DONE.' \
+         (2) start this exact command as a long-running background terminal session (do not wait for it): python3 -c 'import time; time.sleep(192)' . \
+         Reply only LAUNCHED."
+    } else {
+        "This is an automated test in a disposable directory. Do exactly two things, then end your turn at once without waiting for either: \
+         (1) use the Bash tool with run_in_background=true to run exactly: python3 -c 'import time; time.sleep(192)' ; \
+         (2) use the Agent tool with run_in_background=true (subagent_type general-purpose) and the prompt \
+         'Run this exact bash command in the foreground and nothing else: python3 -c \"import time; time.sleep(191)\" . Then reply DONE.'. \
+         Reply only LAUNCHED."
+    };
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run(opening, &model, id, &cwd),
+                message_id: "m-1".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) >= 1 && status(&core) == Some(SessionStatus::Idle),
+        "the opening turn",
+    )
+    .await;
+    // Claude wraps each command in a shell (two processes a job); Codex
+    // runs the command itself.
+    let per_job = if id == zeron_proto::HarnessId::Codex {
+        1
+    } else {
+        2
+    };
+    wait(
+        &core,
+        180,
+        || alive() >= 2 * per_job,
+        "both background jobs to start",
+    )
+    .await;
+    println!("{name}: background work running ({} processes)", alive());
+
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run(
+                    "Run this exact shell command in the FOREGROUND (not in the background) and wait for it to finish: python3 -c 'import time; time.sleep(193)' . Then reply FINISHED.",
+                    &model,
+                    id,
+                    &cwd,
+                ),
+                message_id: "m-2".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || status(&core) == Some(SessionStatus::Working) && alive() >= 3 * per_job,
+        "the foreground command to start",
+    )
+    .await;
+    core.doc_host
+        .queue_command(CHAT, SessionCommandPayload::Interrupt {})
+        .unwrap();
+    wait(
+        &core,
+        60,
+        || status(&core) == Some(SessionStatus::Idle),
+        "stop to settle",
+    )
+    .await;
+    wait(
+        &core,
+        20,
+        || alive() == 0,
+        "every agent process to be gone after Stop",
+    )
+    .await;
+    println!("{name}: Stop ended the turn and all background work");
+
+    // The next message resumes the conversation in a fresh process.
+    let before = completed_turns(&core);
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run("Do not use tools. Reply only PONG.", &model, id, &cwd),
+                message_id: "m-3".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) > before && status(&core) == Some(SessionStatus::Idle),
+        "the message after Stop",
+    )
+    .await;
+    println!("{name}: the next message resumed after Stop");
+    core.shutdown().await;
+    let _ = std::process::Command::new("pkill")
+        .args(["-f", "time.sleep.(19[1-5])"])
+        .status();
+}
+
+/// Issue #831: the idle reaper ended a parked Claude session whose agent
+/// still ran a background shell, killing it before its completion woke the
+/// agent. With a short idle window, the shell outlives the window, finishes
+/// in the same process, and its completion wakes the agent.
+///
+/// ZERON_TEST_MODEL=claude-haiku-5-5 \
+///   cargo test -p zeron-engine --test runtime_survival_live idle_reaper_ -- --ignored --nocapture
+#[tokio::test]
+#[ignore = "uses real model quota; select an inexpensive model explicitly"]
+async fn idle_reaper_spares_a_background_shell_until_it_wakes_the_agent() {
+    // SAFETY: set before the engine starts; this test binary runs it alone
+    // under the documented filter.
+    unsafe {
+        std::env::set_var("ZERON_SESSION_IDLE_MS", "15000");
+    }
+    let model = std::env::var("ZERON_TEST_MODEL").ok();
+    let id = zeron_proto::HarnessId::ClaudeCode;
+    let dir = tempfile::tempdir().unwrap();
+    let cwd = dir.path().to_str().unwrap().to_owned();
+    let registry = HarnessRegistry::new();
+    registry.register(Arc::new(ClaudeHarness::new()));
+    let core =
+        EngineCore::assemble(&dir.path().join("engine"), Arc::new(registry), id, None).unwrap();
+    core.workspace
+        .create_space("space", &core.device_id, &cwd, None, false)
+        .unwrap();
+    core.workspace
+        .create_chat(CHAT, Some("space"), None, None, None)
+        .unwrap();
+    core.doc_host
+        .queue_command(
+            CHAT,
+            SessionCommandPayload::Run {
+                request: run(
+                    "This is an automated test in a disposable directory. Do exactly one thing, then end your turn at once without waiting for it: \
+                     use the Bash tool with run_in_background=true to run exactly: sleep 45 && printf done > bg-done . \
+                     Reply only STARTED. Later, when you are notified that the command finished, reply only FINISHED.",
+                    &model,
+                    id,
+                    &cwd,
+                ),
+                message_id: "m-1".into(),
+            },
+        )
+        .unwrap();
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) >= 1 && status(&core) == Some(SessionStatus::Idle),
+        "the opening turn",
+    )
+    .await;
+    assert!(
+        core.sessions.holds_background_work(CHAT),
+        "the agent never launched the background shell: {:#?}",
+        journal(&core)
+    );
+    println!("claude: parked with the background shell running");
+    // Three idle windows pass before the shell ends: the reaper must spare it.
+    wait(
+        &core,
+        240,
+        || dir.path().join("bg-done").exists(),
+        "the background shell to finish",
+    )
+    .await;
+    println!("claude: background shell finished");
+    wait(
+        &core,
+        240,
+        || completed_turns(&core) >= 2 && status(&core) == Some(SessionStatus::Idle),
+        "the completion to wake the agent",
+    )
+    .await;
+    assert_eq!(processes(&core), 1, "the reaper restarted the agent");
+    assert!(
+        core.sessions.live_run_steerable(CHAT),
+        "the woken session is still live"
+    );
+    println!("claude: the completion woke the same process");
+    core.shutdown().await;
+}
diff --git a/crates/harness/examples/cursor_stability_probe.rs b/crates/harness/examples/cursor_stability_probe.rs
index 8770e5dad5..48dfa9712b 100644
--- a/crates/harness/examples/cursor_stability_probe.rs
+++ b/crates/harness/examples/cursor_stability_probe.rs
@@ -29,6 +29,7 @@ async fn turn(
             let _ = tx.send(vec![]);
             rx
         }),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
@@ -149,6 +150,7 @@ async fn parked(harness: &CursorHarness, count: usize) {
             let _ = tx.send(vec![]);
             rx
         }),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
@@ -204,7 +206,7 @@ async fn parked(harness: &CursorHarness, count: usize) {
                             println!("auth_clock_advanced_ms={offset} exchanges_before={}",exchanges.lines().count());
                         }
                     }
-                    tx.send(zeron_harness::SteerMessage{prompt:"Repeat the exact PARKED-STABILITY token from earlier. Reply only the token. Do not use tools or files.".into(),message_id:None}).await.unwrap();
+                    tx.send(zeron_harness::SteerMessage{prompt:"Repeat the exact PARKED-STABILITY token from earlier. Reply only the token. Do not use tools or files.".into(),message_id:None, attachments: Vec::new(), config: None}).await.unwrap();
                 }
                 _=>{}
             }
@@ -261,6 +263,7 @@ async fn burst(harness: &CursorHarness, count: usize, cancel: bool) {
             let _ = tx.send(vec![]);
             rx
         }),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
@@ -298,6 +301,8 @@ async fn burst(harness: &CursorHarness, count: usize, cancel: bool) {
                 .send(zeron_harness::SteerMessage {
                     prompt,
                     message_id: None,
+                    attachments: Vec::new(),
+                    config: None,
                 })
                 .await
                 .is_err()
@@ -399,6 +404,7 @@ async fn history(harness: &CursorHarness, count: usize) {
             let _ = tx.send(vec![]);
             rx
         }),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
@@ -426,7 +432,7 @@ async fn history(harness: &CursorHarness, count: usize) {
     let producer = tokio::spawn(async move {
         start_rx.await.unwrap();
         for token in sent.iter().skip(1) {
-            tx.send(zeron_harness::SteerMessage{prompt:format!("Add token {token} to your remembered conversation history. Reply with the token from the immediately previous user message, followed by this new token. Do not use tools."),message_id:Some(uuid::Uuid::new_v4().to_string())}).await.unwrap();
+            tx.send(zeron_harness::SteerMessage{prompt:format!("Add token {token} to your remembered conversation history. Reply with the token from the immediately previous user message, followed by this new token. Do not use tools."),message_id:Some(uuid::Uuid::new_v4().to_string()),attachments:Vec::new(),config:None}).await.unwrap();
         }
     });
     let mut id = String::new();
diff --git a/crates/harness/examples/cursor_steering_probe.rs b/crates/harness/examples/cursor_steering_probe.rs
index cc047ee5d0..606a8a2d16 100644
--- a/crates/harness/examples/cursor_steering_probe.rs
+++ b/crates/harness/examples/cursor_steering_probe.rs
@@ -35,6 +35,7 @@ async fn main() -> anyhow::Result<()> {
                     let _ = tx.send(vec![]);
                     rx
                 }),
+                turn: Default::default(),
             },
         )
         .await?;
@@ -57,6 +58,8 @@ async fn main() -> anyhow::Result<()> {
                                     .send(SteerMessage {
                                         prompt: i.to_string(),
                                         message_id: Some(format!("digit-{i}")),
+                                        attachments: Vec::new(),
+                                        config: None,
                                     })
                                     .await
                                     .is_err()
diff --git a/crates/harness/examples/devin_models_probe.rs b/crates/harness/examples/devin_models_probe.rs
index a6b6b6af37..0d9370cd8c 100644
--- a/crates/harness/examples/devin_models_probe.rs
+++ b/crates/harness/examples/devin_models_probe.rs
@@ -36,6 +36,7 @@ async fn main() -> anyhow::Result<()> {
         }),
         steering,
         interrupt: CancellationToken::new(),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
diff --git a/crates/harness/examples/grok_subagent_probe.rs b/crates/harness/examples/grok_subagent_probe.rs
index 9c5b498562..9b1e6f016a 100644
--- a/crates/harness/examples/grok_subagent_probe.rs
+++ b/crates/harness/examples/grok_subagent_probe.rs
@@ -33,6 +33,7 @@ async fn main() {
         }),
         steering,
         interrupt: CancellationToken::new(),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
diff --git a/crates/harness/examples/opencode_subagent_probe.rs b/crates/harness/examples/opencode_subagent_probe.rs
index 5b1b5f55d6..21a2e968cd 100644
--- a/crates/harness/examples/opencode_subagent_probe.rs
+++ b/crates/harness/examples/opencode_subagent_probe.rs
@@ -41,6 +41,7 @@ async fn main() {
         }),
         steering,
         interrupt: CancellationToken::new(),
+        turn: Default::default(),
     };
     // Optional second arg overrides the prompt (e.g. the mock rig's
     // "TWO subagents" variant exercising concurrent binding).
diff --git a/crates/harness/examples/opencode_turn_probe.rs b/crates/harness/examples/opencode_turn_probe.rs
index be55a72266..6b8f262e1f 100644
--- a/crates/harness/examples/opencode_turn_probe.rs
+++ b/crates/harness/examples/opencode_turn_probe.rs
@@ -86,6 +86,7 @@ async fn main() {
                 }),
                 steering,
                 interrupt: interrupt.clone(),
+                turn: Default::default(),
             },
         )
         .await
diff --git a/crates/harness/examples/steering_probe.rs b/crates/harness/examples/steering_probe.rs
index 19c8bd1b15..b5e7485acc 100644
--- a/crates/harness/examples/steering_probe.rs
+++ b/crates/harness/examples/steering_probe.rs
@@ -65,6 +65,7 @@ async fn main() -> anyhow::Result<()> {
             let _ = tx.send(vec![]);
             rx
         }),
+        turn: Default::default(),
     };
     let mut stream =
         tokio::time::timeout(Duration::from_secs(90), harness.run(request, controls)).await??;
@@ -78,7 +79,7 @@ async fn main() -> anyhow::Result<()> {
                 _ = ticker.tick(), if !injected => {
                     if workspace.path().join("started").exists() {
                         for index in 0..3 {
-                            steer.send(SteerMessage { prompt: format!("Additive follow-up {index}: keep all earlier work running. Write ONLY the secret from the first user message into file followup-{index}. Do not read it from another file. Use a shell command to append {index} as one line to receipts. Reply FOLLOWUP-{index}-DONE."), message_id: Some(format!("probe-{index}")) }).await?;
+                            steer.send(SteerMessage { prompt: format!("Additive follow-up {index}: keep all earlier work running. Write ONLY the secret from the first user message into file followup-{index}. Do not read it from another file. Use a shell command to append {index} as one line to receipts. Reply FOLLOWUP-{index}-DONE."), message_id: Some(format!("probe-{index}")), attachments: Vec::new(), config: None }).await?;
                         }
                         injected = true;
                         println!("{name}: injected 3 steers while shell was running");
diff --git a/crates/harness/src/acp/mod.rs b/crates/harness/src/acp/mod.rs
index 20b3ab00f8..c3ba5dae50 100644
--- a/crates/harness/src/acp/mod.rs
+++ b/crates/harness/src/acp/mod.rs
@@ -24,6 +24,8 @@
 //!   others queue steers and deliver them as the next `session/prompt` at the
 //!   turn boundary. The session stays parked between turns while the
 //!   steering mailbox lives.
+//! - Turn stop ([`crate::TurnControl::stop_turn`]): `session/cancel` settles
+//!   the prompt `cancelled`; the agent and its session take the next prompt.
 //! - Interrupt: `session/cancel`, escalating SIGTERM → SIGKILL; the stream
 //!   always ends with `Done { status: Interrupted }`.
 
@@ -1246,7 +1248,7 @@ pub struct AcpHarness {
     /// Retain successful catalogs per credential/binary context through outages.
     models_cache: crate::catalog::Catalog,
     workspace_commands: crate::skills::CommandDiscovery,
-    devin_models: devin_models::Catalog,
+    devin_models: std::sync::Arc<devin_models::Catalog>,
 }
 
 impl AcpHarness {
@@ -1265,7 +1267,7 @@ impl AcpHarness {
             commands: tokio::sync::OnceCell::new(),
             models_cache: crate::catalog::Catalog::default(),
             workspace_commands: crate::skills::CommandDiscovery::default(),
-            devin_models: devin_models::Catalog::default(),
+            devin_models: Default::default(),
         }
     }
 
@@ -2144,6 +2146,24 @@ impl Harness for AcpHarness {
         // quiet watchdog must not park a still-pending model request either.
         true
     }
+    /// `session/cancel` settles the prompt `cancelled`; the agent process
+    /// and its session take the next `session/prompt`.
+    fn stops_turn_in_place(&self) -> bool {
+        true
+    }
+    /// The session's model, effort and model options are selected over the
+    /// protocol (`session/set_model`, `session/set_config_option`), so a
+    /// change applies between turns without a new agent. Clearing one back
+    /// to the agent's default cannot be expressed that way.
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd
+            && (next.model.is_some() || live.model.is_none())
+            && (next.reasoning.is_some() || live.reasoning.is_none())
+            && live
+                .model_options
+                .keys()
+                .all(|key| next.model_options.contains_key(key))
+    }
 
     fn supports_steering(&self) -> bool {
         true
@@ -2340,18 +2360,19 @@ impl Harness for AcpHarness {
         let (client, incoming) =
             client_with_sign_in_prompt(stdin, stdout, self.spec.id, &sign_in_prompted);
         let (event_tx, event_rx) = mpsc::channel::<Result<AgentEvent, HarnessError>>(256);
-        let devin_selection = match request.model.as_deref() {
-            Some(model) if self.spec.id == HarnessId::Devin => {
-                let (exe, _) = self.resolve_program(false).await?;
-                let selection = self
-                    .devin_models
-                    .selection(
-                        &exe,
-                        self.model_discovery_timeout,
-                        model,
-                        &request.model_options,
-                    )
-                    .await;
+        let devin_catalog = if self.spec.id == HarnessId::Devin {
+            let (exe, _) = self.resolve_program(false).await?;
+            Some(DevinCatalog {
+                catalog: self.devin_models.clone(),
+                exe,
+                timeout: self.model_discovery_timeout,
+            })
+        } else {
+            None
+        };
+        let devin_selection = match (request.model.as_deref(), &devin_catalog) {
+            (Some(model), Some(devin)) => {
+                let selection = devin.selection(model, &request.model_options).await;
                 if selection.is_none() && model == devin_models::FUSION {
                     let chosen = |key: &str| {
                         request
@@ -2386,6 +2407,7 @@ impl Harness for AcpHarness {
             prompt_complete_extension: self.spec.prompt_complete_extension,
             preempt_steers: self.spec.steering_mode == SteeringMode::StepBoundary,
             devin_selection,
+            devin_catalog,
             resend_unstarted: self.spec.drops_unstarted_cancelled_prompt,
             prompt_stall: self.spec.prompt_stall,
             stall_hint: self.spec.stall_hint,
@@ -2430,6 +2452,8 @@ struct Session {
     preempt_steers: bool,
     /// Devin: the requested model's catalog group (see `devin_models`).
     devin_selection: Option<devin_models::Selection>,
+    /// Devin: the catalog a later model switch selects its group from.
+    devin_catalog: Option<DevinCatalog>,
     /// See `AcpAgentSpec::drops_unstarted_cancelled_prompt`.
     resend_unstarted: bool,
     prompt_stall: Option<Duration>,
@@ -2447,6 +2471,33 @@ struct Session {
     sign_in_prompted: CancellationToken,
 }
 
+/// Devin's model catalog, for selecting a model's group on the live session.
+struct DevinCatalog {
+    catalog: std::sync::Arc<devin_models::Catalog>,
+    exe: PathBuf,
+    timeout: Duration,
+}
+
+impl DevinCatalog {
+    async fn selection(
+        &self,
+        model: &str,
+        options: &serde_json::Map<String, Value>,
+    ) -> Option<devin_models::Selection> {
+        self.catalog
+            .selection(&self.exe, self.timeout, model, options)
+            .await
+    }
+}
+
+/// How a session selects a run's model, effort and model options.
+#[derive(Clone, Copy)]
+struct ConfigRules {
+    harness: HarnessId,
+    effort_in_model_id: bool,
+    effort_values: fn(Option<ReasoningLevel>, Option<&str>) -> Vec<&'static str>,
+}
+
 fn initialize_params(harness: HarnessId) -> Value {
     let mut capabilities = json!({
         "fs": { "readTextFile": false, "writeTextFile": false },
@@ -3475,6 +3526,172 @@ fn steering_call_future(
 
 /// The per-run event loop: one task multiplexing agent messages, the pending
 /// turn, the steering mailbox, the interrupt token, and consumer liveness.
+/// Select `request`'s model, effort and model options on the session —
+/// at its start, and again when a later message changes them. Returns the
+/// session's options as they stand afterwards, which the next switch
+/// compares against.
+async fn select_session_config(
+    client: &RpcClient,
+    incoming: &mut mpsc::Receiver<Incoming>,
+    rules: ConfigRules,
+    session_id: &str,
+    mut session_response: Value,
+    request: &RunRequest,
+    devin_selection: Option<devin_models::Selection>,
+) -> Result<Value, HarnessError> {
+    // Devin selects one advertised member of the requested model's group;
+    // effort and speed baked into a saved id apply unless the run chose
+    // its own.
+    let mut request = request.clone();
+    if rules.harness == HarnessId::Devin
+        && let Some(model) = request.model.clone()
+    {
+        let selection = devin_selection.unwrap_or_default();
+        let advertised = devin_models::wait_for_model(
+            client,
+            incoming,
+            session_id,
+            &mut session_response,
+            &model,
+            &selection.members,
+        )
+        .await?;
+        request.model = Some(advertised);
+        if request.reasoning.is_none() {
+            request.reasoning = selection.effort;
+        }
+        if selection.fast && !request.model_options.contains_key("speed") {
+            request
+                .model_options
+                .insert("speed".into(), Value::String("fast".into()));
+        }
+    }
+    // ACP has had two model-selection surfaces. Newer config-option agents
+    // use category=model below; Grok Build currently advertises only the
+    // first-class `models` state and requires `session/set_model`. Other
+    // ACP clients follow the same split. Unlike the best-effort auxiliary options,
+    // an explicit model switch is strict: prompting with a different
+    // model than the picker shows is worse than surfacing the RPC error.
+    let requested_model: Option<String> = match request.model.as_deref() {
+        Some(model) if rules.effort_in_model_id => Some(effort_variant_id(
+            &session_response,
+            model,
+            request.reasoning,
+        )),
+        model => model.map(str::to_owned),
+    };
+    if rules.harness == HarnessId::Antigravity {
+        validate_config_model_selection(
+            &session_response,
+            requested_model.as_deref(),
+            &request.model_options,
+        )?;
+    }
+    if let Some(model) = first_class_model_change(&session_response, requested_model.as_deref())? {
+        request_draining(
+            client,
+            incoming,
+            "session/set_model",
+            json!({
+                "sessionId": session_id,
+                "modelId": model,
+            }),
+        )
+        .await
+        .map_err(|error| {
+            HarnessError::Protocol(format!("agent rejected model switch to {model}: {error}"))
+        })?;
+        // The next switch compares against the model now current.
+        if let Some(models) = session_response.get_mut("models") {
+            models["currentModelId"] = Value::String(model);
+        }
+    }
+    // Apply the run's model + effort + model options through the
+    // session's advertised config options. Best-effort for effort and
+    // traits: a rejected auxiliary set is logged and the agent default
+    // runs.
+    let efforts = (rules.effort_values)(request.reasoning, request.model.as_deref());
+    let mut options_snapshot = session_response;
+    let mut sets = config_option_sets(
+        &options_snapshot,
+        requested_model.as_deref(),
+        &efforts,
+        &request.model_options,
+    );
+    // Devin's effort and speed choices depend on the selected model:
+    // switch the model first, then choose them from what it offers.
+    let deferred = rules.harness == HarnessId::Devin
+        && sets
+            .iter()
+            .any(|(id, _)| is_model_config_option(&options_snapshot, id));
+    if deferred {
+        sets.retain(|(id, _)| is_model_config_option(&options_snapshot, id));
+    }
+    let mut pass = 0;
+    loop {
+        for (config_id, payload) in std::mem::take(&mut sets) {
+            let mut params = serde_json::Map::new();
+            params.insert("sessionId".into(), session_id.into());
+            params.insert("configId".into(), config_id.clone().into());
+            if let Some(payload) = payload.as_object() {
+                for (k, v) in payload {
+                    params.insert(k.clone(), v.clone());
+                }
+            }
+            match request_draining(
+                client,
+                incoming,
+                "session/set_config_option",
+                Value::Object(params),
+            )
+            .await
+            {
+                Ok(response) => {
+                    if let Some(options) = response.get("configOptions") {
+                        options_snapshot["configOptions"] = options.clone();
+                    } else if let Some(value) = payload.get("value")
+                        && let Some(option) = options_snapshot["configOptions"]
+                            .as_array_mut()
+                            .and_then(|options| {
+                                options.iter_mut().find(|o| o["id"] == config_id.as_str())
+                            })
+                    {
+                        // The next switch compares against the value now set.
+                        option["currentValue"] = value.clone();
+                    }
+                }
+                Err(e) => {
+                    if matches!(rules.harness, HarnessId::Antigravity | HarnessId::Devin)
+                        && requested_model.is_some()
+                        && is_model_config_option(&options_snapshot, &config_id)
+                    {
+                        return Err(HarnessError::Protocol(format!(
+                            "agent rejected requested model {}: {e}",
+                            requested_model.as_deref().unwrap_or_default()
+                        )));
+                    }
+                    tracing::debug!(
+                        target: "zeron_harness::acp",
+                        "session/set_config_option {config_id}={payload} rejected (agent default runs): {e}"
+                    );
+                }
+            }
+        }
+        pass += 1;
+        if !deferred || pass > 1 {
+            break;
+        }
+        sets = config_option_sets(
+            &options_snapshot,
+            requested_model.as_deref(),
+            &efforts,
+            &request.model_options,
+        );
+        sets.retain(|(id, _)| !is_model_config_option(&options_snapshot, id));
+    }
+    Ok(options_snapshot)
+}
+
 async fn run_session(session: Session) {
     let Session {
         // Locals drop in reverse binding order: reap the child before cleanup.
@@ -3484,12 +3701,13 @@ async fn run_session(session: Session) {
         mut incoming,
         event_tx,
         controls,
-        request,
+        mut request,
         harness,
         agent_name,
         prompt_complete_extension,
         preempt_steers,
         devin_selection,
+        devin_catalog,
         resend_unstarted,
         prompt_stall,
         stall_hint,
@@ -3510,8 +3728,14 @@ async fn run_session(session: Session) {
         request_input,
         mut steering,
         interrupt,
+        turn: turn_control,
     } = controls;
     let request_input = std::sync::Arc::new(request_input);
+    let rules = ConfigRules {
+        harness,
+        effort_in_model_id,
+        effort_values,
+    };
 
     // ---- handshake + session (interruptible) ------------------------------
     let setup = async {
@@ -3525,7 +3749,7 @@ async fn run_session(session: Session) {
             "cwd": request.cwd,
             "mcpServers": acp_mcp_servers(request.mcp.as_ref()),
         });
-        let (session_id, mut session_response) = if let Some(resume) = &request.resume {
+        let (session_id, session_response) = if let Some(resume) = &request.resume {
             let mut load = session_params.clone();
             load["sessionId"] = Value::String(resume.clone());
             match request_draining(&client, &mut incoming, "session/load", load).await {
@@ -3581,159 +3805,31 @@ async fn run_session(session: Session) {
                 "session/new returned no sessionId".into(),
             ));
         }
-        // Devin selects one advertised member of the requested model's group;
-        // effort and speed baked into a saved id apply unless the run chose
-        // its own.
-        let mut request = request.clone();
-        if harness == HarnessId::Devin
-            && let Some(model) = request.model.clone()
-        {
-            let selection = devin_selection.clone().unwrap_or_default();
-            let advertised = devin_models::wait_for_model(
-                &client,
-                &mut incoming,
-                &session_id,
-                &mut session_response,
-                &model,
-                &selection.members,
-            )
-            .await?;
-            request.model = Some(advertised);
-            if request.reasoning.is_none() {
-                request.reasoning = selection.effort;
-            }
-            if selection.fast && !request.model_options.contains_key("speed") {
-                request
-                    .model_options
-                    .insert("speed".into(), Value::String("fast".into()));
-            }
-        }
-        // ACP has had two model-selection surfaces. Newer config-option agents
-        // use category=model below; Grok Build currently advertises only the
-        // first-class `models` state and requires `session/set_model`. Other
-        // ACP clients follow the same split. Unlike the best-effort auxiliary options,
-        // an explicit model switch is strict: prompting with a different
-        // model than the picker shows is worse than surfacing the RPC error.
-        let requested_model: Option<String> = match request.model.as_deref() {
-            Some(model) if effort_in_model_id => Some(effort_variant_id(
-                &session_response,
-                model,
-                request.reasoning,
-            )),
-            model => model.map(str::to_owned),
-        };
-        if harness == HarnessId::Antigravity {
-            validate_config_model_selection(
-                &session_response,
-                requested_model.as_deref(),
-                &request.model_options,
-            )?;
-        }
-        if let Some(model) =
-            first_class_model_change(&session_response, requested_model.as_deref())?
-        {
-            request_draining(
-                &client,
-                &mut incoming,
-                "session/set_model",
-                json!({
-                    "sessionId": session_id,
-                    "modelId": model,
-                }),
-            )
-            .await
-            .map_err(|error| {
-                HarnessError::Protocol(format!("agent rejected model switch to {model}: {error}"))
-            })?;
-        }
-        // Apply the run's model + effort + model options through the
-        // session's advertised config options. Best-effort for effort and
-        // traits: a rejected auxiliary set is logged and the agent default
-        // runs.
-        let efforts = effort_values(request.reasoning, request.model.as_deref());
         let session_commands = scan_available_commands(&session_response);
         let init_commands = if session_commands.is_empty() {
             init_commands
         } else {
             session_commands
         };
-        let mut options_snapshot = session_response;
-        let mut sets = config_option_sets(
-            &options_snapshot,
-            requested_model.as_deref(),
-            &efforts,
-            &request.model_options,
-        );
-        // Devin's effort and speed choices depend on the selected model:
-        // switch the model first, then choose them from what it offers.
-        let deferred = harness == HarnessId::Devin
-            && sets
-                .iter()
-                .any(|(id, _)| is_model_config_option(&options_snapshot, id));
-        if deferred {
-            sets.retain(|(id, _)| is_model_config_option(&options_snapshot, id));
-        }
-        let mut pass = 0;
-        loop {
-            for (config_id, payload) in std::mem::take(&mut sets) {
-                let mut params = serde_json::Map::new();
-                params.insert("sessionId".into(), session_id.clone().into());
-                params.insert("configId".into(), config_id.clone().into());
-                if let Some(payload) = payload.as_object() {
-                    for (k, v) in payload {
-                        params.insert(k.clone(), v.clone());
-                    }
-                }
-                match request_draining(
-                    &client,
-                    &mut incoming,
-                    "session/set_config_option",
-                    Value::Object(params),
-                )
-                .await
-                {
-                    Ok(response) => {
-                        if let Some(options) = response.get("configOptions") {
-                            options_snapshot["configOptions"] = options.clone();
-                        }
-                    }
-                    Err(e) => {
-                        if matches!(harness, HarnessId::Antigravity | HarnessId::Devin)
-                            && requested_model.is_some()
-                            && is_model_config_option(&options_snapshot, &config_id)
-                        {
-                            return Err(HarnessError::Protocol(format!(
-                                "agent rejected requested model {}: {e}",
-                                requested_model.as_deref().unwrap_or_default()
-                            )));
-                        }
-                        tracing::debug!(
-                            target: "zeron_harness::acp",
-                            "session/set_config_option {config_id}={payload} rejected (agent default runs): {e}"
-                        );
-                    }
-                }
-            }
-            pass += 1;
-            if !deferred || pass > 1 {
-                break;
-            }
-            sets = config_option_sets(
-                &options_snapshot,
-                requested_model.as_deref(),
-                &efforts,
-                &request.model_options,
-            );
-            sets.retain(|(id, _)| !is_model_config_option(&options_snapshot, id));
-        }
-        Ok::<(String, bool, Vec<SlashCommand>), HarnessError>((
+        let session_options = select_session_config(
+            &client,
+            &mut incoming,
+            rules,
+            &session_id,
+            session_response,
+            &request,
+            devin_selection.clone(),
+        )
+        .await?;
+        Ok::<(String, bool, Vec<SlashCommand>, Value), HarnessError>((
             session_id,
             steer_ext,
             init_commands,
+            session_options,
         ))
     };
     let setup = unless_sign_in_prompted(setup, &sign_in_prompted, agent_name);
-    let (session_id, steer_ext, init_commands) = tokio::select! {
+    let (session_id, steer_ext, init_commands, mut session_options) = tokio::select! {
         res = tokio::time::timeout(handshake_timeout, setup) => {
             let res = res.unwrap_or_else(|_| {
                 // A hung handshake (agent waiting on a login it can never
@@ -3896,6 +3992,9 @@ async fn run_session(session: Session) {
     let mut progress_seq: u64 = 0;
     let mut interrupted = false;
     let mut interrupt_sent = false;
+    // A turn stop (`TurnControl::stop_turn`) in flight: `session/cancel`
+    // ends the prompt and the session stays up for the next one.
+    let mut stopping = false;
     let mut done_current = false;
     let mut done_after_interrupt = false;
     let mut escalation_target = None;
@@ -3933,6 +4032,32 @@ async fn run_session(session: Session) {
     const BUSY_RECENT: Duration = Duration::from_secs(3);
     const CANCEL_FLUSH: Duration = Duration::from_secs(2);
     let mut cancel_flush_deadline: Option<tokio::time::Instant> = None;
+    // When our last prompt settled. Only traffic arriving past it (and past
+    // the settled turn's own trailing frames) is an unowned turn: counting
+    // the tail of our own turn as "busy" cancelled an idle session for every
+    // prompt sent within BUSY_RECENT of the last one — and an idle-session
+    // cancel is not harmless (Hermes 0.20 fails the next prompt with an
+    // internal error).
+    const OWN_TAIL: Duration = Duration::from_millis(500);
+    let mut prompt_settled_at: Option<tokio::time::Instant> = None;
+    // Messages that change the model, effort or options: the session takes a
+    // change only between turns, so one sent mid-turn waits here — and the
+    // messages after it in the mailbox wait behind it — until the session is
+    // quiet. `released` hands the next one to the steering branch.
+    let mut deferred: VecDeque<crate::SteerMessage> = VecDeque::new();
+    let mut released: Option<crate::SteerMessage> = None;
+    macro_rules! quiet {
+        () => {
+            turn.is_none()
+                && cancel_flush_deadline.is_none()
+                && queued_steers.is_empty()
+                && steering_call.is_none()
+                && steer_backlog.is_empty()
+                && open_tools.is_empty()
+                && !(last_update_at.elapsed() < BUSY_RECENT
+                    && prompt_settled_at.is_none_or(|settled| last_update_at > settled + OWN_TAIL))
+        };
+    }
 
     let mut child_exit = None;
     let mut exit_drain_deadline = None;
@@ -3966,6 +4091,10 @@ async fn run_session(session: Session) {
                 if res.is_err() && client.is_closed() {
                     break 'main;
                 }
+                prompt_settled_at = Some(tokio::time::Instant::now());
+                // The settled prompt's tool calls are over with it; a tool
+                // still reported open would read as an unowned turn.
+                open_tools.clear();
                 starve_deadline = None;
                 prompt_stall_deadline = None;
                 if let Some(id) = current_prompt_id.take() {
@@ -4000,7 +4129,7 @@ async fn run_session(session: Session) {
                             .to_owned(),
                         Ok(Err(_)) | Err(_) => "promptRequired".to_owned(),
                     };
-                    if interrupted {
+                    if interrupted || stopping {
                         // Winding down; abandoned like any queued steer.
                     } else if outcome != "promptRequired" {
                         let (prev, next) = rotate(&mut assistant_message_id);
@@ -4082,13 +4211,15 @@ async fn run_session(session: Session) {
                 }
                 // A steer preempted this turn: the session lives on and the
                 // steers continue it below, so there is no turn end to report.
+                let stopped = std::mem::take(&mut stopping);
                 let preempted = std::mem::take(&mut preempt_sent)
                     && !interrupted
+                    && !stopped
                     && res.is_ok()
                     && !queued_steers.is_empty();
                 preempt_pending = false;
                 if !preempted {
-                    let (status, mut error) = stop_outcome(&res, interrupted);
+                    let (status, mut error) = stop_outcome(&res, interrupted || stopped);
                     if !interrupted
                         && auth_method.is_some()
                         && res.as_ref().is_err_and(is_auth_required)
@@ -4112,7 +4243,7 @@ async fn run_session(session: Session) {
                     {
                         break 'main;
                     }
-                    if interrupted || res.is_err() {
+                    if interrupted || (res.is_err() && !stopped) {
                         break 'main;
                     }
                 }
@@ -4339,9 +4470,9 @@ async fn run_session(session: Session) {
                         "promptRequired".to_owned()
                     }
                 };
-                if interrupted {
-                    // The run is winding down; the steer is abandoned like
-                    // any queued steer at interrupt.
+                if interrupted || stopping {
+                    // The run is winding down, or its turn stopping: the
+                    // steer is abandoned like any queued steer.
                 } else if outcome != "promptRequired" {
                     // Injected into a live turn → a Steered boundary. But if
                     // the turn ended while the call was in flight, the
@@ -4551,7 +4682,11 @@ async fn run_session(session: Session) {
                 if !send(
                     &event_tx,
                     AgentEvent::Done {
-                        status: DoneStatus::Completed,
+                        status: if std::mem::take(&mut stopping) {
+                            DoneStatus::Interrupted
+                        } else {
+                            DoneStatus::Completed
+                        },
                         result: None,
                         error: None,
                         session_id: Some(session_id.clone()),
@@ -4596,8 +4731,70 @@ async fn run_session(session: Session) {
                 }
             },
 
-            steer = steering.recv(), if steering_open && !interrupted => match steer {
+            _ = tokio::time::sleep(Duration::from_millis(100)),
+                if released.is_none() && !deferred.is_empty() && !interrupted && quiet!() =>
+            {
+                released = deferred.pop_front();
+            },
+
+            steer = async {
+                match released.take() {
+                    Some(msg) => Some(msg),
+                    None => steering.recv().await,
+                }
+            }, if (released.is_some() || (steering_open && deferred.is_empty())) && !interrupted => match steer {
                 Some(msg) => {
+                    if msg.config.is_some() && !quiet!() {
+                        deferred.push_back(msg);
+                        continue 'main;
+                    }
+                    if let Some(next) = msg.config.as_deref() {
+                        let selection = match (&devin_catalog, next.model.as_deref()) {
+                            (Some(devin), Some(model)) => {
+                                devin.selection(model, &next.model_options).await
+                            }
+                            _ => None,
+                        };
+                        match select_session_config(
+                            &client,
+                            &mut incoming,
+                            rules,
+                            &session_id,
+                            session_options.clone(),
+                            next,
+                            selection,
+                        )
+                        .await
+                        {
+                            Ok(options) => {
+                                session_options = options;
+                                request.model = next.model.clone();
+                                request.reasoning = next.reasoning;
+                                request.model_options = next.model_options.clone();
+                            }
+                            Err(e) => {
+                                // The message cannot run as it was sent.
+                                let (prev, next) = rotate(&mut assistant_message_id);
+                                let message = e.to_string();
+                                done_current = true;
+                                if !send(&event_tx, AgentEvent::Steered {
+                                    assistant_message_id: Some(prev),
+                                    next_assistant_message_id: Some(next),
+                                }).await
+                                    || !send(&event_tx, AgentEvent::Error { message: message.clone() }).await
+                                    || !send(&event_tx, AgentEvent::Done {
+                                        status: DoneStatus::Errored,
+                                        result: None,
+                                        error: Some(message),
+                                        session_id: Some(session_id.clone()),
+                                    }).await
+                                {
+                                    break 'main;
+                                }
+                                continue 'main;
+                            }
+                        }
+                    }
                     // Same transform as the initial prompt: Claude's
                     // Ultrathink prefix rides every steer too.
                     let text = prompt_transform(request.reasoning, &msg.prompt);
@@ -4607,7 +4804,9 @@ async fn run_session(session: Session) {
                         queued_steers.push_back(text);
                     } else if turn.is_none()
                         && (!open_tools.is_empty()
-                            || last_update_at.elapsed() < BUSY_RECENT)
+                            || (last_update_at.elapsed() < BUSY_RECENT
+                                && prompt_settled_at
+                                    .is_none_or(|settled| last_update_at > settled + OWN_TAIL)))
                     {
                         // Mid self-continued turn (see BUSY_RECENT above):
                         // cancel it rather than prompt into the starve.
@@ -4689,6 +4888,40 @@ async fn run_session(session: Session) {
                 }
             },
 
+            // End the prompt in flight, not the agent: `session/cancel`
+            // settles it `cancelled` and the session takes the next prompt
+            // (background work the agent holds keeps running). Steers still
+            // waiting for this turn's end go with it.
+            _ = turn_control.stop_requested(), if !interrupted => {
+                queued_steers.clear();
+                steer_backlog.clear();
+                // A steer still in flight goes with the turn too: its answer
+                // (promptRequired, once the turn is cancelled) would queue it
+                // again and run the cancelled message after all.
+                steering_call = None;
+                deferred.clear();
+                released = None;
+                preempt_pending = false;
+                if turn.is_some() {
+                    stopping = true;
+                    if !preempt_sent {
+                        client.notify("session/cancel", Some(json!({ "sessionId": session_id })));
+                    }
+                } else {
+                    // Between turns: nothing to cancel. Settle the stop so the
+                    // host sees the turn over.
+                    done_current = true;
+                    if !send(&event_tx, AgentEvent::Done {
+                        status: DoneStatus::Interrupted,
+                        result: None,
+                        error: None,
+                        session_id: Some(session_id.clone()),
+                    }).await {
+                        break 'main;
+                    }
+                }
+            },
+
             _ = interrupt.cancelled(), if !interrupt_sent => {
                 interrupt_sent = true;
                 interrupted = true;
diff --git a/crates/harness/src/claude/mod.rs b/crates/harness/src/claude/mod.rs
index ed03dc5bb2..abacbc3d4b 100644
--- a/crates/harness/src/claude/mod.rs
+++ b/crates/harness/src/claude/mod.rs
@@ -25,11 +25,23 @@
 //!   NEVER folded into the parent feed (a background subagent interleaves
 //!   with the parent's own stream — folding them in split contiguous text
 //!   around phantom tool calls).
+//! - A `result` that is not a turn's end: every stdin user line carries a
+//!   uuid, and the CLI reports each one's `command_lifecycle`. A result
+//!   while one of ours is still written/queued is a boundary (a `now` steer
+//!   aborting the turn, resume settling dead background tasks) — that
+//!   message's turn ends with its own result. See [`Commands`].
 //! - Steering: queued [`SteerMessage`]s are written to stdin as user lines at
 //!   any time; the CLI folds them into the running turn at its own step
-//!   boundary.
-//! - Interrupt: cancelling [`RunControls::interrupt`] sends the protocol-level
-//!   interrupt control request, then escalates to SIGTERM and SIGKILL.
+//!   boundary. A steer's changed model/effort/options apply to the live
+//!   process first (`set_model`, `apply_flag_settings`) — never a restart.
+//! - Turn stop ([`crate::TurnControl::stop_turn`]): the `interrupt` control
+//!   request with `cancel_queued` ends the turn and the CLI keeps reading
+//!   stdin. The run opens with an `initialize` declaring
+//!   `perTaskStopAffordance`, which makes that interrupt spare background
+//!   agents (the CLI otherwise stops them all); background shells survive
+//!   either way. `background_tasks_changed` reports the live set to the host.
+//! - Interrupt: cancelling [`RunControls::interrupt`] tears the runtime down —
+//!   the interrupt control request, then SIGTERM and SIGKILL.
 
 pub mod catalog;
 mod discovery;
@@ -91,6 +103,36 @@ fn mcp_config_arg(mcp: &zeron_proto::McpServer) -> String {
     .to_string()
 }
 
+/// The `--model` value: the 1M context window is selected via a model-id
+/// suffix (`sonnet[1m]`), exactly how the CLI itself does it.
+fn model_arg(request: &RunRequest) -> Option<String> {
+    let model = request.model.as_ref()?;
+    let one_m = request
+        .model_options
+        .get("contextWindow")
+        .and_then(Value::as_str)
+        == Some("1m");
+    Some(if one_m {
+        format!("{model}[1m]")
+    } else {
+        model.clone()
+    })
+}
+
+/// Every flag-layer setting a request launches with, for
+/// `apply_flag_settings` on a live process: `null` drops the override back
+/// to the user's own settings, exactly as a launch without the flag
+/// (verified live on 2.1.286 through `get_settings`).
+fn flag_settings(request: &RunRequest) -> Value {
+    let on = |set: bool| if set { Value::Bool(true) } else { Value::Null };
+    serde_json::json!({
+        "effortLevel": to_effort(request.reasoning, request.model.as_deref()),
+        "fastMode": on(option_is_on(&request.model_options, "fastMode")),
+        "alwaysThinkingEnabled": on(option_is_on(&request.model_options, "thinking")),
+        "ultracode": on(request.reasoning == Some(ReasoningLevel::Ultracode)),
+    })
+}
+
 fn option_is_on(options: &serde_json::Map<String, Value>, key: &str) -> bool {
     match options.get(key) {
         Some(Value::Bool(b)) => *b,
@@ -164,10 +206,11 @@ impl ClaudeHarness {
         })
     }
 
-    fn build_command(&self, exe: &PathBuf, request: &RunRequest) -> Command {
-        let mut cmd = Command::new(exe);
-        crate::compose_child_path(&mut cmd, exe);
-        cmd.args([
+    /// The configuration arguments a run launches with — everything the
+    /// process bakes in at spawn except the session to resume. Two requests
+    /// with equal arguments (and cwd) are the same runtime.
+    fn launch_args(request: &RunRequest) -> Vec<String> {
+        let mut args: Vec<String> = [
             "--print",
             "--input-format",
             "stream-json",
@@ -186,37 +229,27 @@ impl ClaudeHarness {
             // Undocumented flag; validated live against 2.1.228.
             "--permission-prompt-tool",
             "stdio",
-        ]);
-        // The 1M context window is selected via a model-id suffix
-        // (`sonnet[1m]`), exactly how the CLI itself does it; fast mode and
-        // always-on thinking are settings overrides.
-        if let Some(model) = &request.model {
-            let one_m = request
-                .model_options
-                .get("contextWindow")
-                .and_then(Value::as_str)
-                == Some("1m");
-            cmd.arg("--model");
-            cmd.arg(if one_m {
-                format!("{model}[1m]")
-            } else {
-                model.clone()
-            });
+        ]
+        .map(str::to_owned)
+        .into();
+        if let Some(model) = model_arg(request) {
+            args.push("--model".into());
+            args.push(model);
         }
         if let Some(effort) = to_effort(request.reasoning, request.model.as_deref()) {
-            cmd.args(["--effort", effort]);
+            args.extend(["--effort".into(), effort.into()]);
         }
         if request.auto_approve {
-            cmd.args([
-                "--permission-mode",
-                "bypassPermissions",
-                "--dangerously-skip-permissions",
-            ]);
+            args.extend(
+                [
+                    "--permission-mode",
+                    "bypassPermissions",
+                    "--dangerously-skip-permissions",
+                ]
+                .map(str::to_owned),
+            );
         } else {
-            cmd.args(["--permission-mode", "default"]);
-        }
-        if let Some(resume) = &request.resume {
-            cmd.arg(format!("--resume={resume}"));
+            args.extend(["--permission-mode".into(), "default".into()]);
         }
         let mut settings = serde_json::Map::new();
         if option_is_on(&request.model_options, "fastMode") {
@@ -229,8 +262,18 @@ impl ClaudeHarness {
             settings.insert("ultracode".into(), Value::Bool(true));
         }
         if !settings.is_empty() {
-            cmd.arg("--settings");
-            cmd.arg(Value::Object(settings).to_string());
+            args.push("--settings".into());
+            args.push(Value::Object(settings).to_string());
+        }
+        args
+    }
+
+    fn build_command(&self, exe: &PathBuf, request: &RunRequest) -> Command {
+        let mut cmd = Command::new(exe);
+        crate::compose_child_path(&mut cmd, exe);
+        cmd.args(Self::launch_args(request));
+        if let Some(resume) = &request.resume {
+            cmd.arg(format!("--resume={resume}"));
         }
         if !request.cwd.is_empty() {
             cmd.current_dir(&request.cwd);
@@ -411,6 +454,22 @@ impl Harness for ClaudeHarness {
     fn deterministic_turn_end(&self) -> bool {
         true
     }
+    /// The `interrupt` control request ends the turn and the CLI keeps
+    /// reading stdin; background agents and shells run on.
+    fn stops_turn_in_place(&self) -> bool {
+        true
+    }
+    /// Same launch arguments and cwd. The CLI ignores the sandbox level, and
+    /// option spellings that launch the same flags are the same runtime.
+    fn same_runtime(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd && Self::launch_args(live) == Self::launch_args(next)
+    }
+    /// Model, context window, effort, fast mode, thinking and ultracode all
+    /// change on the live process (`set_model`, `apply_flag_settings`). Only
+    /// the directory and the permission mode it launched with need a new one.
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd && live.auto_approve == next.auto_approve
+    }
 
     /// Credential and executable identity scopes both initialize and catalog caches.
     fn model_context(&self) -> Result<Option<crate::ModelContext>, HarnessError> {
@@ -583,6 +642,11 @@ impl ClaudeHarness {
 
         let (stdin_tx, stdin_rx) = mpsc::unbounded_channel::<StdinMsg>();
         tokio::spawn(stdin_writer(stdin, stdin_rx));
+        if !title_only {
+            let _ = stdin_tx.send(StdinMsg::Line(wire::initialize_request_line(
+                "zeron_initialize",
+            )));
+        }
 
         // The initial prompt as the first stdin user line (streaming-input
         // mode). Ultrathink rides every user message — steers included.
@@ -591,8 +655,10 @@ impl ClaudeHarness {
         // also ride the prompt text, so a skipped/unreadable file degrades to
         // the old-app behavior (the agent opens the path with its Read tool).
         let images = load_image_blocks(&request.attachments).await;
-        let first = wire::user_message_line_with_images(
+        let first_command = uuid::Uuid::new_v4().to_string();
+        let first = wire::prompt_line(
             &apply_ultrathink(request.reasoning, &request.prompt),
+            &first_command,
             &images,
         );
         let _ = stdin_tx.send(StdinMsg::Line(first));
@@ -603,10 +669,11 @@ impl ClaudeHarness {
             title_only,
             child,
             stdout_lines: BufReader::new(stdout).lines(),
+            first_command,
             stdin_tx,
             event_tx,
             controls,
-            reasoning: request.reasoning,
+            config: request,
             interrupt_grace: self.interrupt_grace,
             kill_grace: self.kill_grace,
             stderr_tail,
@@ -728,10 +795,14 @@ struct Session {
     title_only: bool,
     child: Child,
     stdout_lines: tokio::io::Lines<BufReader<crate::process::ChildStdout>>,
+    /// The uuid the opening prompt was written with.
+    first_command: String,
     stdin_tx: mpsc::UnboundedSender<StdinMsg>,
     event_tx: mpsc::Sender<Result<AgentEvent, HarnessError>>,
     controls: RunControls,
-    reasoning: Option<ReasoningLevel>,
+    /// The configuration the process runs with now: its launch request, then
+    /// whatever a steer's `config` applied in place.
+    config: RunRequest,
     interrupt_grace: Duration,
     kill_grace: Duration,
     /// Rolling stderr tail for the crash message on an unexpected exit.
@@ -746,10 +817,11 @@ async fn run_session(session: Session) {
         title_only,
         mut child,
         mut stdout_lines,
+        first_command,
         stdin_tx,
         event_tx,
         controls,
-        reasoning,
+        mut config,
         interrupt_grace,
         kill_grace,
         stderr_tail,
@@ -760,10 +832,12 @@ async fn run_session(session: Session) {
         request_input,
         mut steering,
         interrupt,
+        turn,
     } = controls;
     let request_input = Arc::new(request_input);
 
     let mut pending_steers = std::collections::VecDeque::new();
+    let mut reconfigures = 0u64;
     // Top-level tool calls in flight: a steer must not abort them (see
     // `wire::steer_message_line`).
     let mut open_tools = std::collections::HashSet::new();
@@ -771,15 +845,42 @@ async fn run_session(session: Session) {
     let mut interrupted = false;
     let mut interrupt_sent = false;
     let mut any_done = false;
-    // A turn end held back while steers wait for their replay. Rapid `now`
-    // steers each interrupt the turn the previous one started, and the CLI
-    // replays only the last (verified on 2.1.280; the earlier texts still
-    // reach the model). If nothing follows the held result, the steers were
-    // absorbed: release them and the turn end instead of spinning forever.
-    const HELD_DONE_SETTLE: Duration = Duration::from_secs(5);
-    let mut held_done: Option<(AgentEvent, tokio::time::Instant)> = None;
+    // A turn stop in flight (`TurnControl::stop_turn`): its request id, and
+    // once the CLI has answered, how long a turn-ending `result` may still
+    // take. The CLI answers a stop between turns without any result — the
+    // deadline settles that shape so the host never waits on it.
+    const STOP_SETTLE: Duration = Duration::from_secs(3);
+    let mut stops_sent = 0u64;
+    let mut stopping: Option<String> = None;
+    let mut stop_settle_at: Option<tokio::time::Instant> = None;
+    // A turn end held for steers when the stop came: that turn's end, sent
+    // as stopped once the stop settles — never before. Released early, the
+    // host started the replacement prompt while the stopped turn could still
+    // report, and that late result settled the replacement.
+    let mut stopped_end: Option<AgentEvent> = None;
+    // When the stopped turn's one Done went out, and whether anything has
+    // happened since — a message of ours written, or new output streamed. A
+    // result in that window with neither can only be the stopped turn
+    // reporting late, and is dropped. Anything else is reconciled like any
+    // result (held for unconfirmed messages, settled by their fallback):
+    // dropping on time alone lost a quick replacement's own end.
+    let mut stop_done_at: Option<tokio::time::Instant> = None;
+    let mut active_since_stop = false;
+    let mut commands = Commands::default();
+    commands.written(first_command);
+    // A `result` that is a steer boundary rather than the turn's end (see
+    // [`Commands`]). It is superseded — dropped — once the waiting message
+    // starts its own turn, which ends with its own result; it is released
+    // as the turn's end if that message is cancelled before it starts.
+    let mut held_done: Option<AgentEvent> = None;
+    // Last stdout activity, for the held result's settle fallback.
+    let mut last_frame_at = tokio::time::Instant::now();
     let mut done_after_interrupt = false;
     let mut escalation: Option<tokio::task::JoinHandle<()>> = None;
+    // The runtime's process tree when its teardown began (see
+    // [`crate::shutdown_agent`]).
+    #[cfg_attr(not(unix), allow(unused_mut))]
+    let mut torn_down: Vec<i32> = Vec::new();
 
     'main: loop {
         tokio::select! {
@@ -790,10 +891,8 @@ async fn run_session(session: Session) {
                         continue;
                     }
                     // The CLI is still producing: whatever it is doing is not
-                    // the quiet end the held turn end waits for.
-                    if let Some((_, deadline)) = held_done.as_mut() {
-                        *deadline = tokio::time::Instant::now() + HELD_DONE_SETTLE;
-                    }
+                    // the quiet end a held turn end's fallback waits for.
+                    last_frame_at = tokio::time::Instant::now();
                     let frame = match wire::parse_frame(line) {
                         Ok(frame) => frame,
                         Err(e) => {
@@ -801,6 +900,17 @@ async fn run_session(session: Session) {
                             continue;
                         }
                     };
+                    if let Frame::ControlResponse(response) = &frame {
+                        if stopping.as_deref() == Some(response.response.request_id.as_str()) {
+                            stop_settle_at = Some(tokio::time::Instant::now() + STOP_SETTLE);
+                        }
+                        continue;
+                    }
+                    if let Frame::System(system) = &frame
+                        && system.subtype == "background_tasks_changed"
+                    {
+                        turn.set_background(system.tasks.as_ref().map_or(0, Vec::len));
+                    }
                     if let Frame::ControlRequest(req) = frame {
                         if title_only {
                             let line = control_response_line(&req.request_id, serde_json::json!({
@@ -812,27 +922,70 @@ async fn run_session(session: Session) {
                         }
                         continue;
                     }
-                    // Only the CLI's replay confirms that a prompt joined its
-                    // conversation. Writing stdin must not split ongoing text.
-                    if let Frame::User(ref user) = frame {
-                        // A replay confirms its steer and every earlier one:
-                        // superseded steers are never replayed themselves.
-                        if user.parent_tool_use_id.is_none()
-                            && let Some(at) = user
-                                .uuid
-                                .as_ref()
-                                .and_then(|id| pending_steers.iter().position(|p| p == id))
-                        {
-                            for _ in 0..=at {
-                                pending_steers.pop_front();
-                                let (prev, next) = norm.rotate_for_steer();
-                                if event_tx.send(Ok(AgentEvent::Steered {
-                                    assistant_message_id: Some(prev), next_assistant_message_id: Some(next),
-                                })).await.is_err() { break 'main; }
-                            }
+                    // Only the CLI confirms that a prompt joined its
+                    // conversation — its lifecycle or its replay, whichever
+                    // comes first. Writing stdin must not split ongoing text.
+                    // A confirmation covers its steer and every earlier one:
+                    // superseded steers are never replayed themselves. A
+                    // message a turn took up (started, or replayed) also
+                    // supersedes a result held for it: that result was only
+                    // the boundary, and the message's turn ends with its own.
+                    let (confirmed, taken_up) = match &frame {
+                        Frame::CommandLifecycle(cmd) => {
+                            let started = commands.lifecycle(&cmd.command_uuid, &cmd.state);
+                            let confirmed = started || Commands::is_terminal(&cmd.state);
+                            (confirmed.then(|| cmd.command_uuid.clone()), started)
+                        }
+                        Frame::User(user) if user.parent_tool_use_id.is_none() => {
+                            let replayed = user.uuid.clone().filter(|id| pending_steers.contains(id));
+                            let taken_up = replayed.is_some();
+                            (replayed, taken_up)
+                        }
+                        _ => (None, false),
+                    };
+                    if taken_up {
+                        held_done = None;
+                        active_since_stop = true;
+                    }
+                    if let Some(at) = confirmed
+                        .and_then(|id| pending_steers.iter().position(|p| *p == id))
+                    {
+                        for _ in 0..=at {
+                            pending_steers.pop_front();
+                            let (prev, next) = norm.rotate_for_steer();
+                            if event_tx.send(Ok(AgentEvent::Steered {
+                                assistant_message_id: Some(prev), next_assistant_message_id: Some(next),
+                            })).await.is_err() { break 'main; }
+                        }
+                    }
+                    // Every waiting message was cancelled before it started:
+                    // the held result was the turn's real end after all.
+                    if matches!(frame, Frame::CommandLifecycle(_))
+                        && !commands.waiting()
+                        && let Some(done) = held_done.take()
+                    {
+                        if event_tx.send(Ok(done)).await.is_err() {
+                            break 'main;
                         }
+                        any_done = true;
+                    }
+                    // The stopped turn reporting late: a result with nothing
+                    // since the stop's Done. Judged on the frame, before it
+                    // expands — its own Usage is not new activity — and
+                    // dropped whole, usage included.
+                    if matches!(frame, Frame::Result(_))
+                        && !interrupted
+                        && stopping.is_none()
+                        && !active_since_stop
+                        && stop_done_at.is_some_and(|at| at.elapsed() < STOP_SETTLE)
+                    {
+                        tracing::debug!(
+                            target: "zeron_harness::claude",
+                            "late result of a stopped turn dropped"
+                        );
+                        continue;
                     }
-                    for ev in norm.normalize(frame, interrupted) {
+                    for ev in norm.normalize(frame, interrupted || stopping.is_some()) {
                         match &ev {
                             AgentEvent::ToolCall { id, .. } => {
                                 open_tools.insert(id.clone());
@@ -845,15 +998,41 @@ async fn run_session(session: Session) {
                         }
                         let is_done = matches!(ev, AgentEvent::Done { .. });
                         // A `now` steer ends the turn it interrupts with a
-                        // result frame; the steer continues the run, so that
+                        // result frame, and a message queued behind a turn
+                        // that just ended starts another: either way that
                         // result is a steer boundary, not the end of the turn.
-                        if is_done && !interrupted && !pending_steers.is_empty() {
-                            held_done =
-                                Some((ev, tokio::time::Instant::now() + HELD_DONE_SETTLE));
+                        let boundary = if commands.reported {
+                            commands.waiting()
+                        } else {
+                            !pending_steers.is_empty()
+                        };
+                        // New content is a new turn's: its result is its own.
+                        if stop_done_at.is_some()
+                            && match &ev {
+                                AgentEvent::TextDelta { text }
+                                | AgentEvent::ReasoningDelta { text } => !text.is_empty(),
+                                AgentEvent::ToolCall { .. }
+                                | AgentEvent::ToolResult { .. }
+                                | AgentEvent::InputRequested { .. }
+                                | AgentEvent::Subagent { .. } => true,
+                                _ => false,
+                            }
+                        {
+                            active_since_stop = true;
+                        }
+                        if is_done && !interrupted && stopping.is_none() && boundary {
+                            held_done = Some(ev);
                             continue;
                         }
                         if is_done {
                             held_done = None;
+                            // The stopped turn has ended; the runtime lives on.
+                            if stopping.take().is_some() {
+                                stopped_end = None;
+                                stop_done_at = Some(tokio::time::Instant::now());
+                                active_since_stop = false;
+                            }
+                            stop_settle_at = None;
                         }
                         if event_tx.send(Ok(ev)).await.is_err() {
                             break 'main; // consumer gone — reap below
@@ -876,13 +1055,38 @@ async fn run_session(session: Session) {
 
             steer = steering.recv(), if steering_open && !interrupted => match steer {
                 Some(msg) => {
+                    // A message of ours now owns whatever result comes next.
+                    active_since_stop = true;
+                    // A changed configuration applies before the prompt, on
+                    // the same stdin the CLI reads in order.
+                    if let Some(next) = msg.config {
+                        reconfigures += 1;
+                        if model_arg(&next) != model_arg(&config) {
+                            let line = wire::set_model_request_line(
+                                &format!("zeron_model_{reconfigures}"),
+                                model_arg(&next).as_deref(),
+                            );
+                            if stdin_tx.send(StdinMsg::Line(line)).is_err() { break 'main; }
+                        }
+                        if flag_settings(&next) != flag_settings(&config) {
+                            let line = wire::apply_flag_settings_line(
+                                &format!("zeron_settings_{reconfigures}"),
+                                flag_settings(&next),
+                            );
+                            if stdin_tx.send(StdinMsg::Line(line)).is_err() { break 'main; }
+                        }
+                        config = *next;
+                    }
                     let id = uuid::Uuid::new_v4().to_string();
-                    let line = wire::steer_message_line(
-                        &apply_ultrathink(reasoning, &msg.prompt),
+                    let images = load_image_blocks(&msg.attachments).await;
+                    let line = wire::steer_message_line_with_images(
+                        &apply_ultrathink(config.reasoning, &msg.prompt),
                         &id,
                         open_tools.is_empty(),
+                        &images,
                     );
-                    pending_steers.push_back(id);
+                    pending_steers.push_back(id.clone());
+                    commands.written(id);
                     if stdin_tx.send(StdinMsg::Line(line)).is_err() { break 'main; }
                 }
                 None => {
@@ -893,9 +1097,62 @@ async fn run_session(session: Session) {
                 }
             },
 
+            // End the in-flight turn, not the session: the CLI stays up, so
+            // its background agents and shells keep running. Steers written
+            // before the stop are cancelled with it (`cancel_queued`) — a
+            // stopped turn must not continue into them.
+            _ = turn.stop_requested(), if !interrupted => {
+                stops_sent += 1;
+                let id = format!("zeron_stop_{stops_sent}");
+                pending_steers.clear();
+                commands.cancel_waiting();
+                stopping = Some(id.clone());
+                stop_settle_at = None;
+                stop_done_at = None;
+                if stdin_tx.send(StdinMsg::Line(wire::stop_turn_request_line(&id))).is_err() {
+                    break 'main;
+                }
+                // A turn end held for steer replays is that turn's real end:
+                // its steers were just cancelled, so it ends stopped — once
+                // the stop settles. A turn the CLI had already begun for
+                // those steers reports first, and that report is the end.
+                if let Some(mut done) = held_done.take() {
+                    if let AgentEvent::Done { status, .. } = &mut done {
+                        *status = DoneStatus::Interrupted;
+                    }
+                    stopped_end = Some(done);
+                }
+            },
+
+            // The CLI answered the stop and no turn ended: it was between
+            // turns. Settle the stop so the host sees the turn over.
+            _ = tokio::time::sleep_until(stop_settle_at.unwrap_or_else(tokio::time::Instant::now)),
+                if stop_settle_at.is_some() => {
+                stop_settle_at = None;
+                if stopping.take().is_some() {
+                    let done = stopped_end.take().unwrap_or(AgentEvent::Done {
+                        status: DoneStatus::Interrupted,
+                        result: None,
+                        error: None,
+                        session_id: norm.session_id.clone(),
+                    });
+                    if event_tx.send(Ok(done)).await.is_err() {
+                        break 'main;
+                    }
+                    any_done = true;
+                    stop_done_at = Some(tokio::time::Instant::now());
+                    active_since_stop = false;
+                }
+            },
+
             _ = interrupt.cancelled(), if !interrupt_sent => {
                 interrupt_sent = true;
                 interrupted = true;
+                // The runtime is going: so is everything it started.
+                #[cfg(unix)]
+                if let Some(pid) = child.id() {
+                    torn_down = crate::process::descendants(pid).await;
+                }
                 let _ = stdin_tx.send(StdinMsg::Line(wire::interrupt_request_line("int_1")));
                 // Escalate if the CLI doesn't wind down within the grace
                 // periods: SIGTERM (kills bash trees, runs SessionEnd hooks),
@@ -911,16 +1168,17 @@ async fn run_session(session: Session) {
             },
 
             _ = tokio::time::sleep_until(
-                held_done.as_ref().map_or_else(tokio::time::Instant::now, |(_, d)| *d)
-            ), if held_done.is_some() => {
+                last_frame_at + commands.held_settle().unwrap_or_default()
+            ), if held_done.is_some() && commands.held_settle().is_some() => {
                 // The steers were absorbed into the turn that just ended.
+                commands.cancel_waiting();
                 while pending_steers.pop_front().is_some() {
                     let (prev, next) = norm.rotate_for_steer();
                     if event_tx.send(Ok(AgentEvent::Steered {
                         assistant_message_id: Some(prev), next_assistant_message_id: Some(next),
                     })).await.is_err() { break 'main; }
                 }
-                let (done, _) = held_done.take().expect("guarded by if");
+                let done = held_done.take().expect("guarded by if");
                 if event_tx.send(Ok(done)).await.is_err() {
                     break 'main;
                 }
@@ -932,7 +1190,7 @@ async fn run_session(session: Session) {
     }
 
     // A turn end still held when the CLI exited is the run's real end.
-    if let Some((done, _)) = held_done.take()
+    if let Some(done) = held_done.take()
         && !event_tx.is_closed()
         && event_tx.send(Ok(done)).await.is_ok()
     {
@@ -964,12 +1222,101 @@ async fn run_session(session: Session) {
         }
     }
 
-    shutdown_child(&mut child, kill_grace).await;
+    crate::shutdown_agent(&mut child, torn_down, kill_grace).await;
     if let Some(handle) = escalation {
         handle.abort();
     }
 }
 
+/// How far the CLI has taken each stdin user message we wrote, by the uuid
+/// it was written with. A `result` frame ends the TURN only when no message
+/// is still waiting to be taken up. A waiting one makes the result a steer
+/// boundary — a `now` steer aborting the turn it interrupts, or a message
+/// queued behind a turn that just finished — and that message's own turn
+/// ends with its own result. Deciding this from the CLI's own lifecycle
+/// rather than from quiet time: a held result released by a quiet timer
+/// marked the steered turn done mid-way through any long tool call.
+#[derive(Default)]
+struct Commands {
+    /// Uuid → how far it got. Ended commands are dropped.
+    open: std::collections::HashMap<String, CommandState>,
+    /// The CLI reports `command_lifecycle`. Older CLIs never do: their only
+    /// confirmation is the replay, and the settle fallback covers the rest.
+    reported: bool,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum CommandState {
+    /// On stdin; the CLI has not acknowledged it yet.
+    Written,
+    /// The CLI read it and will start or cancel it.
+    Queued,
+    /// A turn took it up.
+    Started,
+}
+
+impl Commands {
+    /// Without lifecycle reports, how long a held result waits in silence
+    /// for the replay that supersedes it.
+    const UNREPORTED_SETTLE: Duration = Duration::from_secs(5);
+    /// A lifecycle-reporting CLI acknowledges a message as soon as it reads
+    /// it. A hold resting only on unacknowledged messages is a safety net
+    /// against a message the CLI never reports, not a timing guess.
+    const UNACKNOWLEDGED_SETTLE: Duration = Duration::from_secs(30);
+
+    fn written(&mut self, id: String) {
+        self.open.insert(id, CommandState::Written);
+    }
+
+    fn is_terminal(state: &str) -> bool {
+        matches!(state, "completed" | "cancelled" | "canceled" | "failed")
+    }
+
+    /// Apply one `command_lifecycle` frame. True when a turn took the
+    /// command up (`started`).
+    fn lifecycle(&mut self, id: &str, state: &str) -> bool {
+        self.reported = true;
+        if Self::is_terminal(state) {
+            self.open.remove(id);
+            return false;
+        }
+        let next = match state {
+            "started" => CommandState::Started,
+            "queued" => CommandState::Queued,
+            _ => return false,
+        };
+        if let Some(current) = self.open.get_mut(id)
+            && *current != CommandState::Started
+        {
+            *current = next;
+        }
+        next == CommandState::Started
+    }
+
+    /// A message is written or queued but no turn has taken it up.
+    fn waiting(&self) -> bool {
+        self.open.values().any(|s| *s != CommandState::Started)
+    }
+
+    /// A stop's `cancel_queued` drops every message not yet taken up.
+    fn cancel_waiting(&mut self) {
+        self.open.retain(|_, s| *s == CommandState::Started);
+    }
+
+    /// The quiet time after which a held result is released as the turn's
+    /// end; `None` = only the CLI's own lifecycle settles it.
+    fn held_settle(&self) -> Option<Duration> {
+        if !self.reported {
+            Some(Self::UNREPORTED_SETTLE)
+        } else if self.open.values().any(|s| *s == CommandState::Queued) {
+            // A queued message always starts or is cancelled.
+            None
+        } else {
+            Some(Self::UNACKNOWLEDGED_SETTLE)
+        }
+    }
+}
+
 type RequestInputFn = Box<
     dyn Fn(Vec<UserInputQuestion>) -> tokio::sync::oneshot::Receiver<Vec<UserInputAnswer>>
         + Send
diff --git a/crates/harness/src/claude/normalize.rs b/crates/harness/src/claude/normalize.rs
index da3dfbe521..5ae737c2ab 100644
--- a/crates/harness/src/claude/normalize.rs
+++ b/crates/harness/src/claude/normalize.rs
@@ -655,9 +655,10 @@ impl Normalizer {
             }
 
             // A claude.ai plan window was hit. A hard `rejected` blocks the
-            // turn — make it visible; allowed/allowed_warning stay quiet.
+            // turn — make it visible; allowed/allowed_warning stay quiet, and
+            // so does a reject the account's overage carries past.
             Frame::RateLimit(f) => {
-                if f.rate_limit_info.status != "rejected" {
+                if !f.rate_limit_info.blocks() {
                     return Vec::new();
                 }
                 let window =
@@ -770,7 +771,10 @@ impl Normalizer {
             }
 
             // Control frames are handled by the run loop, not normalized.
-            Frame::ControlRequest(_) | Frame::Other => Vec::new(),
+            Frame::ControlRequest(_)
+            | Frame::ControlResponse(_)
+            | Frame::CommandLifecycle(_)
+            | Frame::Other => Vec::new(),
         }
     }
 }
@@ -847,6 +851,24 @@ mod tests {
         Normalizer::new().normalize(frame, false)
     }
 
+    #[test]
+    fn a_rejected_window_carried_by_overage_is_not_an_error() {
+        let blocked = normalize_one(
+            r#"{"type":"rate_limit_event","rate_limit_info":{"status":"rejected","rateLimitType":"five_hour","overageStatus":"rejected"}}"#,
+        );
+        assert!(matches!(blocked.as_slice(), [AgentEvent::Error { .. }]));
+        for overage in [
+            r#""overageStatus":"allowed""#,
+            r#""overageStatus":"allowed_warning""#,
+            r#""isUsingOverage":true"#,
+        ] {
+            let raw = format!(
+                r#"{{"type":"rate_limit_event","rate_limit_info":{{"status":"rejected","rateLimitType":"five_hour",{overage}}}}}"#
+            );
+            assert!(normalize_one(&raw).is_empty(), "{overage}");
+        }
+    }
+
     fn result_done(raw: &str) -> AgentEvent {
         let events = normalize_one(raw);
         assert_eq!(events.len(), 2, "usage + done");
diff --git a/crates/harness/src/claude/wire.rs b/crates/harness/src/claude/wire.rs
index af75a6ab62..1f25d8ac9e 100644
--- a/crates/harness/src/claude/wire.rs
+++ b/crates/harness/src/claude/wire.rs
@@ -17,10 +17,40 @@ pub(crate) enum Frame {
     RateLimit(RateLimitFrame),
     Result(ResultFrame),
     ControlRequest(ControlRequestFrame),
-    /// control_response / control_cancel_request / anything unknown.
+    /// The CLI's answer to one of our control requests.
+    ControlResponse(ControlResponseFrame),
+    /// Where the CLI has taken one of our stdin user messages.
+    CommandLifecycle(CommandLifecycleFrame),
+    /// control_cancel_request / anything unknown.
     Other,
 }
 
+#[derive(Debug, Default, Deserialize)]
+pub(crate) struct ControlResponseFrame {
+    #[serde(default)]
+    pub response: ControlResponseBody,
+}
+
+#[derive(Debug, Default, Deserialize)]
+pub(crate) struct ControlResponseBody {
+    #[serde(default)]
+    pub request_id: String,
+}
+
+/// `{"type":"command_lifecycle","command_uuid":…,"state":…}` — emitted for
+/// every stdin user message carrying a `uuid` (verified live against CLI
+/// 2.1.286): `queued` when read, `started` when a turn takes it up (a `next`
+/// steer starts mid-turn, at the step boundary it folds into), then
+/// `completed` or `cancelled` (its turn was aborted by a later `now` steer
+/// or an interrupt). Background-task wake turns carry no command at all.
+#[derive(Debug, Default, Deserialize)]
+pub(crate) struct CommandLifecycleFrame {
+    #[serde(default)]
+    pub command_uuid: String,
+    #[serde(default)]
+    pub state: String,
+}
+
 #[derive(Debug, Default, Deserialize)]
 pub(crate) struct SystemFrame {
     #[serde(default)]
@@ -48,6 +78,10 @@ pub(crate) struct SystemFrame {
     /// absent on subagent-owned background shell tasks.
     #[serde(default)]
     pub subagent_type: Option<String>,
+    /// `background_tasks_changed`: every background task the session holds
+    /// now (agents and shells) — the authoritative set, not a delta.
+    #[serde(default)]
+    pub tasks: Option<Vec<Value>>,
 }
 
 #[derive(Debug, Default, Deserialize)]
@@ -142,6 +176,28 @@ pub(crate) struct RateLimitInfo {
     pub status: String,
     #[serde(rename = "rateLimitType", default)]
     pub rate_limit_type: Option<String>,
+    /// `allowed`/`allowed_warning` when the account may spend provisioned
+    /// overage past a rejected window.
+    #[serde(rename = "overageStatus", default)]
+    pub overage_status: Option<String>,
+    #[serde(rename = "isUsingOverage", default)]
+    pub is_using_overage: bool,
+    #[serde(rename = "overageInUse", default)]
+    pub overage_in_use: bool,
+}
+
+impl RateLimitInfo {
+    /// A rejected window that actually blocks the turn: an account spending
+    /// provisioned overage keeps running despite the reject.
+    pub fn blocks(&self) -> bool {
+        self.status == "rejected"
+            && !matches!(
+                self.overage_status.as_deref(),
+                Some("allowed" | "allowed_warning")
+            )
+            && !self.is_using_overage
+            && !self.overage_in_use
+    }
 }
 
 #[derive(Debug, Default, Deserialize)]
@@ -199,6 +255,8 @@ pub(crate) fn parse_frame(line: &str) -> Result<Frame, serde_json::Error> {
         "rate_limit_event" => Frame::RateLimit(serde_json::from_value(value)?),
         "result" => Frame::Result(serde_json::from_value(value)?),
         "control_request" => Frame::ControlRequest(serde_json::from_value(value)?),
+        "control_response" => Frame::ControlResponse(serde_json::from_value(value)?),
+        "command_lifecycle" => Frame::CommandLifecycle(serde_json::from_value(value)?),
         _ => Frame::Other,
     };
     Ok(frame)
@@ -206,6 +264,7 @@ pub(crate) fn parse_frame(line: &str) -> Result<Frame, serde_json::Error> {
 
 /// A stdin user turn: `{"type":"user","message":{...},"parent_tool_use_id":null}`.
 /// Steering = another such line mid-run (consumed at a step boundary).
+#[cfg(test)]
 pub(crate) fn user_message_line(text: &str) -> String {
     json!({
         "type": "user",
@@ -222,9 +281,26 @@ pub(crate) fn user_message_line(text: &str) -> String {
 /// was interrupted before a result was received"), so while any tool is open
 /// the steer goes as `next`: the tool finishes and the steer lands right after
 /// its result, in the same turn. An interrupted turn still emits a `result`.
+#[cfg(test)]
 pub(crate) fn steer_message_line(text: &str, id: &str, immediate: bool) -> String {
+    steer_message_line_with_images(text, id, immediate, &[])
+}
+
+/// [`steer_message_line`] carrying inline images ahead of the text, in the
+/// same block shape as [`user_message_line_with_images`].
+pub(crate) fn steer_message_line_with_images(
+    text: &str,
+    id: &str,
+    immediate: bool,
+    images: &[ImageBlock],
+) -> String {
+    let content = if images.is_empty() {
+        Value::String(text.to_owned())
+    } else {
+        Value::Array(content_blocks(text, images))
+    };
     serde_json::json!({"type":"user", "uuid":id, "priority": if immediate { "now" } else { "next" },
-        "message":{"role":"user","content":text}, "parent_tool_use_id":null})
+        "message":{"role":"user","content":content}, "parent_tool_use_id":null})
     .to_string()
 }
 
@@ -240,10 +316,38 @@ pub(crate) struct ImageBlock {
 /// first, then the text — the standard Anthropic image+text message shape
 /// (verified against the real CLI: `--input-format stream-json` accepts image
 /// content blocks in user frames). Empty `images` degrades to the plain line.
+/// The run's opening prompt, tagged with `id` so its `command_lifecycle`
+/// frames can be told apart from a steer's. Images precede the text, as in
+/// [`user_message_line_with_images`].
+pub(crate) fn prompt_line(text: &str, id: &str, images: &[ImageBlock]) -> String {
+    let content = if images.is_empty() {
+        Value::String(text.to_owned())
+    } else {
+        Value::Array(content_blocks(text, images))
+    };
+    json!({
+        "type": "user",
+        "uuid": id,
+        "message": { "role": "user", "content": content },
+        "parent_tool_use_id": null,
+    })
+    .to_string()
+}
+
+#[cfg(test)]
 pub(crate) fn user_message_line_with_images(text: &str, images: &[ImageBlock]) -> String {
     if images.is_empty() {
         return user_message_line(text);
     }
+    json!({
+        "type": "user",
+        "message": { "role": "user", "content": content_blocks(text, images) },
+        "parent_tool_use_id": null,
+    })
+    .to_string()
+}
+
+fn content_blocks(text: &str, images: &[ImageBlock]) -> Vec<Value> {
     let mut blocks: Vec<Value> = images
         .iter()
         .map(|img| {
@@ -258,10 +362,50 @@ pub(crate) fn user_message_line_with_images(text: &str, images: &[ImageBlock]) -
         })
         .collect();
     blocks.push(json!({ "type": "text", "text": text }));
+    blocks
+}
+
+/// The run's opening control request. `perTaskStopAffordance` tells the CLI
+/// this host stops tasks individually, so an interrupt ends the turn and
+/// spares background agents — without it the CLI stops every background
+/// agent on interrupt (verified live against 2.1.285; background shells
+/// survive either way).
+pub(crate) fn initialize_request_line(request_id: &str) -> String {
     json!({
-        "type": "user",
-        "message": { "role": "user", "content": blocks },
-        "parent_tool_use_id": null,
+        "type": "control_request",
+        "request_id": request_id,
+        "request": { "subtype": "initialize", "perTaskStopAffordance": true },
+    })
+    .to_string()
+}
+
+/// Switch the live process's model (`None` = the user's default model).
+pub(crate) fn set_model_request_line(request_id: &str, model: Option<&str>) -> String {
+    json!({
+        "type": "control_request",
+        "request_id": request_id,
+        "request": { "subtype": "set_model", "model": model },
+    })
+    .to_string()
+}
+
+/// Replace the live process's flag-layer settings (effort, fast mode, …).
+pub(crate) fn apply_flag_settings_line(request_id: &str, settings: Value) -> String {
+    json!({
+        "type": "control_request",
+        "request_id": request_id,
+        "request": { "subtype": "apply_flag_settings", "settings": settings },
+    })
+    .to_string()
+}
+
+/// Stop the in-flight turn only. `cancel_queued` drops steers the CLI has
+/// queued but not yet consumed: a stopped turn never continues into them.
+pub(crate) fn stop_turn_request_line(request_id: &str) -> String {
+    json!({
+        "type": "control_request",
+        "request_id": request_id,
+        "request": { "subtype": "interrupt", "cancel_queued": true },
     })
     .to_string()
 }
diff --git a/crates/harness/src/codex/mod.rs b/crates/harness/src/codex/mod.rs
index e9d1744d13..a10d582449 100644
--- a/crates/harness/src/codex/mod.rs
+++ b/crates/harness/src/codex/mod.rs
@@ -28,13 +28,21 @@
 //!   become tagged [`AgentEvent::Subagent`] events; unrelated child bookkeeping is
 //!   consumed so it can never settle the parent turn, and unknown methods
 //!   fall through to the parent path (fail open, never silent loss).
-//! - Steering: `turn/steer { expectedTurnId }` into the live turn; a rejected
-//!   steer (the turn-completed race) is queued and delivered as the next
-//!   `turn/start` on the same thread. The session is persistent across turns
-//!   while the steering mailbox lives.
-//! - Interrupt: cancelling [`RunControls::interrupt`] sends `turn/interrupt`,
-//!   escalating to SIGTERM → SIGKILL if the child is unresponsive; the stream
-//!   always ends with `Done { status: Interrupted }`.
+//! - Steering: `turn/steer { expectedTurnId, clientUserMessageId }` into the
+//!   live turn, confirmed when its userMessage item (carrying that id) joins
+//!   the turn; a rejected steer (the turn-completed race) is queued and
+//!   delivered as the next `turn/start` on the same thread. The session is
+//!   persistent across turns while the steering mailbox lives; a steer's
+//!   changed model/effort/tier rides the next `turn/start`.
+//! - Only the turn in flight settles: a stale or duplicate completion is
+//!   ignored. Commands still running past their turn report as background
+//!   work, so the host never reaps the app-server from under them.
+//! - Turn stop ([`crate::TurnControl::stop_turn`]): `turn/interrupt` ends the
+//!   turn `Interrupted`; the app-server and its threads (child agents
+//!   included) stay up for the next `turn/start`.
+//! - Interrupt: cancelling [`RunControls::interrupt`] tears the runtime down —
+//!   `turn/interrupt`, escalating to SIGTERM → SIGKILL if the child is
+//!   unresponsive; the stream always ends with `Done { status: Interrupted }`.
 
 pub(crate) mod catalog;
 mod normalize;
@@ -347,6 +355,16 @@ impl CodexHarness {
     }
 }
 
+/// The `serviceTier` a request runs with; "default" (Standard) is omitted.
+fn service_tier(request: &RunRequest) -> Option<String> {
+    request
+        .model_options
+        .get("serviceTier")
+        .and_then(Value::as_str)
+        .filter(|t| *t != "default")
+        .map(str::to_owned)
+}
+
 fn reasoning_level(value: &str) -> Option<ReasoningLevel> {
     Some(match value {
         "minimal" => ReasoningLevel::Minimal,
@@ -606,6 +624,31 @@ impl Harness for CodexHarness {
     fn deterministic_turn_end(&self) -> bool {
         true
     }
+    /// `turn/interrupt` ends the turn; the app-server and its thread — child
+    /// agent threads included — stay up for the next `turn/start`.
+    fn stops_turn_in_place(&self) -> bool {
+        true
+    }
+    /// What the app-server launch and its turns read: the sandbox is forced
+    /// to full access, and `serviceTier` is the only model option used.
+    fn same_runtime(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd
+            && live.model == next.model
+            && to_effort(live.reasoning) == to_effort(next.reasoning)
+            && service_tier(live) == service_tier(next)
+            && live.auto_approve == next.auto_approve
+    }
+    /// `turn/start` carries model, effort and service tier, and each sticks
+    /// for later turns — so a change applies from the next turn without a
+    /// new app-server. Clearing one back to the default cannot be expressed
+    /// that way (an omitted parameter keeps the previous value).
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd
+            && live.auto_approve == next.auto_approve
+            && (next.model.is_some() || live.model.is_none())
+            && (to_effort(next.reasoning).is_some() || to_effort(live.reasoning).is_none())
+            && (service_tier(next).is_some() || service_tier(live).is_none())
+    }
 
     /// The signed-in account's visible `model/list` is authoritative. A
     /// curated snapshot keeps the picker operational when the experimental
@@ -825,6 +868,11 @@ struct Session {
 #[derive(Default)]
 struct TurnRouter {
     active: Option<String>,
+    /// The app-server announced `active` (`turn/started`). Until then it may
+    /// not have registered the turn: `turn/interrupt` answers "no active
+    /// turn to interrupt" (live, 0.159.3, an interrupt right after the
+    /// `turn/start` response) and the turn would run to its end.
+    announced: bool,
     completed: VecDeque<String>,
 }
 
@@ -845,6 +893,7 @@ impl TurnRouter {
             self.remember_completed(prev);
         }
         self.active = Some(id);
+        self.announced = true;
     }
 
     fn note_completed(&mut self, id: &str) {
@@ -854,13 +903,28 @@ impl TurnRouter {
         self.remember_completed(id.to_owned());
         if self.active.as_deref() == Some(id) {
             self.active = None;
+            self.announced = false;
         }
     }
 
     /// Adopt a turn id from a `turn/start` RESPONSE (the notification is
-    /// allowed to beat it).
+    /// allowed to beat it). A turn already running keeps its id: a follow-up
+    /// `turn/start` folds into it and answers with that same id anyway, and
+    /// an announced turn is authoritative.
     fn adopt_started(&mut self, id: String) {
-        self.active = (!id.is_empty() && !self.is_completed(&id)).then_some(id);
+        if self.active.is_some() || id.is_empty() || self.is_completed(&id) {
+            return;
+        }
+        self.active = Some(id);
+        self.announced = false;
+    }
+
+    /// Whether a `turn/completed` (or failed/aborted) for `id` ends the turn
+    /// in flight. A completion for a turn already settled, or for another
+    /// turn while ours runs, is stale: settling on it marked the running
+    /// turn done mid-way.
+    fn settles(&self, id: &str) -> bool {
+        id.is_empty() || (!self.is_completed(id) && self.active.as_deref().is_none_or(|a| a == id))
     }
 
     fn remember_completed(&mut self, id: String) {
@@ -1000,6 +1064,7 @@ async fn run_session(session: Session) {
         request_input,
         mut steering,
         interrupt,
+        turn,
     } = controls;
     let request_input = Arc::new(request_input);
 
@@ -1012,15 +1077,7 @@ async fn run_session(session: Session) {
     // approval at every step"). The approval-as-input plumbing below stays for
     // stray requests and a future explicit permission-mode setting.
     let approval_policy = "never";
-    let effort = to_effort(request.reasoning);
-    // Service tier rides thread-start and every turn (mirrors the Codex IDE
-    // client). "default" means Standard — omit it entirely.
-    let service_tier = request
-        .model_options
-        .get("serviceTier")
-        .and_then(Value::as_str)
-        .filter(|t| *t != "default")
-        .map(str::to_owned);
+    let start_tier = service_tier(&request);
 
     let start_params = {
         let mut p = serde_json::Map::new();
@@ -1067,7 +1124,7 @@ async fn run_session(session: Session) {
         if let Some(model) = &request.model {
             p.insert("model".into(), Value::String(model.clone()));
         }
-        if let Some(tier) = &service_tier {
+        if let Some(tier) = &start_tier {
             p.insert("serviceTier".into(), Value::String(tier.clone()));
         }
         p
@@ -1180,28 +1237,29 @@ async fn run_session(session: Session) {
         }
     };
 
-    let turn_params = |text: &str| -> Value {
+    // Model, effort and service tier ride every `turn/start` (each sticks
+    // for later turns): a steer's in-place `config` takes effect from the
+    // next turn the runtime starts.
+    let mut live = request.clone();
+    let turn_params = |live: &RunRequest, text: &str| -> Value {
         let mut p = serde_json::Map::new();
         p.insert("threadId".into(), Value::String(thread_id.clone()));
         p.insert("input".into(), prompt_input(text));
         p.insert("approvalPolicy".into(), approval_policy.into());
-        p.insert(
-            "sandboxPolicy".into(),
-            sandbox_policy_value(request.sandbox),
-        );
+        p.insert("sandboxPolicy".into(), sandbox_policy_value(live.sandbox));
         // Reasoning summaries stream (`item/reasoning/summaryTextDelta`) only
         // when asked for — without this codex "thinks" in silence for minutes:
         // nothing renders and the UI's 45s staleness gate flips Working off
         // (user report: "not streaming, doesn't say it's working").
         p.insert("summary".into(), "auto".into());
-        if let Some(model) = &request.model {
+        if let Some(model) = &live.model {
             p.insert("model".into(), Value::String(model.clone()));
         }
-        if let Some(effort) = effort {
+        if let Some(effort) = to_effort(live.reasoning) {
             p.insert("effort".into(), effort.into());
         }
-        if let Some(tier) = &service_tier {
-            p.insert("serviceTier".into(), Value::String(tier.clone()));
+        if let Some(tier) = service_tier(live) {
+            p.insert("serviceTier".into(), Value::String(tier));
         }
         Value::Object(p)
     };
@@ -1235,7 +1293,7 @@ async fn run_session(session: Session) {
         )
     });
     if !idle {
-        match start_turn(&client, turn_params(&request.prompt)).await {
+        match start_turn(&client, turn_params(&live, &request.prompt)).await {
             Ok(id) => router.adopt_started(id),
             Err(e) => {
                 let _ = event_tx
@@ -1261,10 +1319,34 @@ async fn run_session(session: Session) {
     let mut pending_usage: Option<AgentEvent> = None;
     // Steers whose `turn/steer` lost the turn-completed race; delivered as the
     // next `turn/start` when the expected turn's end notification arrives.
-    let mut queued_steers: VecDeque<String> = VecDeque::new();
+    // Each carries the configuration it was sent with, adopted when its own
+    // `turn/start` goes out.
+    let mut queued_steers: VecDeque<(String, Option<Box<RunRequest>>)> = VecDeque::new();
+    // Steers the app-server accepted into the running turn, by the
+    // `clientUserMessageId` they were sent with. Each is confirmed
+    // (`Steered`) when its userMessage item joins the turn — not when
+    // `turn/steer` returns, which split the reply still streaming ahead of
+    // it into the steer's segment.
+    let mut accepted_steers: VecDeque<String> = VecDeque::new();
+    // A turn stop waiting for the app-server to announce the turn.
+    let mut stop_when_announced = false;
+    // Commands the parent thread started and the app-server has not reported
+    // finished, with their process id and the turn that started them. One
+    // still open after its turn is background work (a dev server, a
+    // watcher): its `item/completed` arrives when the process exits, turns
+    // later (live, 0.159.3). The host's idle reaper must not retire the
+    // app-server — and the process with it — while it runs.
+    let mut open_commands: HashMap<String, (Option<String>, Option<String>)> = HashMap::new();
+    // An interrupted turn's foreground command is killed WITHOUT an
+    // `item/completed`: once its process has had a moment to go, drop the
+    // turn's commands whose process is gone (background ones live on).
+    let mut prune_at: Option<(tokio::time::Instant, String)> = None;
     let mut steering_open = true;
     let mut interrupted = false;
     let mut interrupt_sent = false;
+    // A turn stop (`TurnControl::stop_turn`) in flight: the turn's end reads
+    // as Interrupted and the app-server stays up for the next turn.
+    let mut stopping = false;
     // A Done has been emitted for the turn currently/last in flight.
     let mut done_current = idle;
     let mut current_native = command_request(&request.prompt, &thread_id)
@@ -1273,6 +1355,10 @@ async fn run_session(session: Session) {
         .is_some();
     let mut done_after_interrupt = false;
     let mut escalation: Option<tokio::task::JoinHandle<()>> = None;
+    // The runtime's process tree when its teardown began (see
+    // [`crate::shutdown_agent`]).
+    #[cfg_attr(not(unix), allow(unused_mut))]
+    let mut torn_down: Vec<i32> = Vec::new();
 
     'main: loop {
         tokio::select! {
@@ -1304,16 +1390,26 @@ async fn run_session(session: Session) {
                 }
                 match method.as_str() {
                     "turn/started" => {
-                        let id=turn_id(&params);
+                        let id = turn_id(&params);
                         // Native voice handoffs start a turn without going through turn/start.
                         // Publish the boundary before its text/tool deltas reach the parked engine.
                         if done_current && !id.is_empty() && !router.is_completed(&id) {
-                            done_current=false;
-                            let (prev,next)=rotate(&mut assistant_message_id);
-                            if !send(&event_tx,AgentEvent::Steered{assistant_message_id:Some(prev),next_assistant_message_id:Some(next)}).await {break 'main;}
+                            done_current = false;
+                            let (prev, next) = rotate(&mut assistant_message_id);
+                            if !send(&event_tx, AgentEvent::Steered {
+                                assistant_message_id: Some(prev),
+                                next_assistant_message_id: Some(next),
+                            }).await {
+                                break 'main;
+                            }
                         }
                         router.note_started(id);
-                    },
+                        if std::mem::take(&mut stop_when_announced)
+                            && let Some(active) = router.active.clone()
+                        {
+                            send_turn_interrupt(&client, &thread_id, active);
+                        }
+                    }
 
                     "item/agentMessage/delta" => {
                         streamed_text.insert(item_id(&params));
@@ -1342,6 +1438,35 @@ async fn run_session(session: Session) {
                             Phase::Completed
                         };
                         let item = params.get("item").unwrap_or(&Value::Null);
+                        if matches!(item_type(item), "commandExecution" | "command_execution") {
+                            let id = item.get("id").and_then(Value::as_str).unwrap_or_default();
+                            let changed = if phase == Phase::Started {
+                                let pid = item.get("processId").and_then(Value::as_str).map(str::to_owned);
+                                open_commands.insert(id.to_owned(), (pid, router.active.clone())).is_none()
+                            } else {
+                                open_commands.remove(id).is_some()
+                            };
+                            if changed {
+                                turn.set_background(open_commands.len());
+                            }
+                        }
+                        if matches!(item_type(item), "userMessage" | "user_message")
+                            && let Some(at) = item
+                                .get("clientId")
+                                .and_then(Value::as_str)
+                                .and_then(|id| accepted_steers.iter().position(|s| s == id))
+                        {
+                            for _ in 0..=at {
+                                accepted_steers.pop_front();
+                                let (prev, next) = rotate(&mut assistant_message_id);
+                                if !send(&event_tx, AgentEvent::Steered {
+                                    assistant_message_id: Some(prev),
+                                    next_assistant_message_id: Some(next),
+                                }).await {
+                                    break 'main;
+                                }
+                            }
+                        }
                         if phase == Phase::Completed {
                             let output = match item_type(item) {
                                 "exitedReviewMode" => item.get("review").and_then(Value::as_str),
@@ -1422,7 +1547,28 @@ async fn run_session(session: Session) {
 
                     "turn/completed" => {
                         let id = turn_id(&params);
+                        if !router.settles(&id) {
+                            tracing::debug!(
+                                target: "zeron_harness::codex",
+                                turn = %id,
+                                "stale turn/completed ignored (not the turn in flight)"
+                            );
+                            router.note_completed(&id);
+                            continue 'main;
+                        }
                         router.note_completed(&id);
+                        stop_when_announced = false;
+                        // Accepted steers whose item never surfaced still
+                        // joined this turn: confirm them before its end.
+                        while accepted_steers.pop_front().is_some() {
+                            let (prev, next) = rotate(&mut assistant_message_id);
+                            if !send(&event_tx, AgentEvent::Steered {
+                                assistant_message_id: Some(prev),
+                                next_assistant_message_id: Some(next),
+                            }).await {
+                                break 'main;
+                            }
+                        }
                         // Item ids never span turns; without this the set grew
                         // one entry per message for a persistent session's life.
                         streamed_text.clear();
@@ -1438,13 +1584,19 @@ async fn run_session(session: Session) {
                                 == Some("failed"))
                             .then(|| "Codex turn failed".to_owned())
                         });
-                        let status = if interrupted {
+                        let status = if interrupted || stopping {
                             DoneStatus::Interrupted
                         } else if error.is_some() {
                             DoneStatus::Errored
                         } else {
                             DoneStatus::Completed
                         };
+                        if status == DoneStatus::Interrupted
+                            || params.pointer("/turn/status").and_then(Value::as_str) == Some("interrupted")
+                        {
+                            prune_at = Some((tokio::time::Instant::now() + COMMAND_EXIT_GRACE, id.clone()));
+                        }
+                        stopping = false;
                         done_current = true;
                         if !send(
                             &event_tx,
@@ -1467,11 +1619,14 @@ async fn run_session(session: Session) {
                         // this turn's end becomes the next turn now; otherwise
                         // stay alive for the mailbox — the caller owns teardown.
                         current_native = false;
-                        if let Some(text) = queued_steers.pop_front() {
+                        if let Some((text, config)) = queued_steers.pop_front() {
+                            if let Some(next) = config {
+                                live = *next;
+                            }
                             current_native = command_request(&text, &thread_id).ok().flatten().is_some();
                             if !steer_as_new_turn(
                                 &client,
-                                turn_params(&text),
+                                turn_params(&live, &text),
                                 &mut router,
                                 &event_tx,
                                 &mut assistant_message_id,
@@ -1487,13 +1642,32 @@ async fn run_session(session: Session) {
                     }
 
                     "turn/failed" => {
-                        router.note_completed(&turn_id(&params));
+                        let id = turn_id(&params);
+                        if !router.settles(&id) {
+                            router.note_completed(&id);
+                            continue 'main;
+                        }
+                        router.note_completed(&id);
+                        stop_when_announced = false;
+                        accepted_steers.clear();
                         if let Some(usage) = pending_usage.take()
                             && !send(&event_tx, usage).await
                         {
                             break 'main;
                         }
                         done_current = true;
+                        if std::mem::take(&mut stopping) && !interrupted {
+                            // The stopped turn's end: the thread lives on.
+                            if !send(&event_tx, AgentEvent::Done {
+                                status: DoneStatus::Interrupted,
+                                result: None,
+                                error: None,
+                                session_id: Some(thread_id.clone()),
+                            }).await {
+                                break 'main;
+                            }
+                            continue 'main;
+                        }
                         if interrupted {
                             done_after_interrupt = true;
                         }
@@ -1518,8 +1692,27 @@ async fn run_session(session: Session) {
                     }
 
                     "turn/aborted" => {
-                        router.note_completed(&turn_id(&params));
+                        let id = turn_id(&params);
+                        if !router.settles(&id) {
+                            router.note_completed(&id);
+                            continue 'main;
+                        }
+                        router.note_completed(&id);
+                        stop_when_announced = false;
+                        accepted_steers.clear();
                         done_current = true;
+                        prune_at = Some((tokio::time::Instant::now() + COMMAND_EXIT_GRACE, id.clone()));
+                        if std::mem::take(&mut stopping) && !interrupted {
+                            if !send(&event_tx, AgentEvent::Done {
+                                status: DoneStatus::Interrupted,
+                                result: None,
+                                error: None,
+                                session_id: Some(thread_id.clone()),
+                            }).await {
+                                break 'main;
+                            }
+                            continue 'main;
+                        }
                         if interrupted {
                             done_after_interrupt = true;
                         }
@@ -1575,34 +1768,34 @@ async fn run_session(session: Session) {
                 Some(msg) => {
                     let text = msg.prompt;
                     // Native operations run at a turn boundary, never as text
-                    // injected into an already running model turn. Later messages
-                    // must stay behind queued commands: Steered acknowledgments
-                    // retire the engine's accepted-message ledger in FIFO order.
-                    if !done_current && (!queued_steers.is_empty() || current_native || !matches!(command_request(&text, &thread_id), Ok(None))) {
-                        queued_steers.push_back(text);
+                    // injected into an already running model turn. So does a
+                    // changed configuration: `turn/steer` carries no model,
+                    // effort or tier, and only a `turn/start` applies them.
+                    // Later messages must stay behind queued ones: Steered
+                    // acknowledgments retire the engine's accepted-message
+                    // ledger in FIFO order.
+                    if !done_current
+                        && (!queued_steers.is_empty()
+                            || current_native
+                            || msg.config.is_some()
+                            || !matches!(command_request(&text, &thread_id), Ok(None)))
+                    {
+                        queued_steers.push_back((text, msg.config));
                         continue 'main;
                     }
+                    if let Some(next) = msg.config {
+                        live = *next;
+                    }
                     if let Some(expected) = router.active.clone() {
+                        let client_id = new_message_id();
                         let steer_params = json!({
                             "threadId": thread_id,
                             "expectedTurnId": expected,
+                            "clientUserMessageId": client_id,
                             "input": prompt_input(&text),
                         });
                         match client.request("turn/steer", steer_params).await {
-                            Ok(_) => {
-                                let (prev, next) = rotate(&mut assistant_message_id);
-                                if !send(
-                                    &event_tx,
-                                    AgentEvent::Steered {
-                                        assistant_message_id: Some(prev),
-                                        next_assistant_message_id: Some(next),
-                                    },
-                                )
-                                .await
-                                {
-                                    break 'main;
-                                }
-                            }
+                            Ok(_) => accepted_steers.push_back(client_id),
                             // A failed `turn/steer` does NOT mean the text is
                             // bad: most commonly the active turn finished
                             // between the UI send and this request. Queue it
@@ -1617,11 +1810,11 @@ async fn run_session(session: Session) {
                                 if router.active.as_deref() == Some(expected.as_str())
                                     && !router.is_completed(&expected)
                                 {
-                                    queued_steers.push_back(text);
+                                    queued_steers.push_back((text, None));
                                 } else {
                                     current_native = command_request(&text, &thread_id).ok().flatten().is_some();
                                     if !steer_as_new_turn(
-                                        &client, turn_params(&text), &mut router, &event_tx,
+                                        &client, turn_params(&live, &text), &mut router, &event_tx,
                                         &mut assistant_message_id, &mut done_current,
                                     ).await { break 'main; }
                                 }
@@ -1630,7 +1823,7 @@ async fn run_session(session: Session) {
                     } else {
                         current_native = command_request(&text, &thread_id).ok().flatten().is_some();
                         if !steer_as_new_turn(
-                            &client, turn_params(&text), &mut router, &event_tx,
+                            &client, turn_params(&live, &text), &mut router, &event_tx,
                             &mut assistant_message_id, &mut done_current,
                         ).await { break 'main; }
                     }
@@ -1646,9 +1839,44 @@ async fn run_session(session: Session) {
                 }
             },
 
+            // End the in-flight turn, not the app-server: its threads (child
+            // agents included) keep running. Steers still waiting for this
+            // turn's end go with it — a stopped turn never continues.
+            _ = turn.stop_requested(), if !interrupted => {
+                queued_steers.clear();
+                match router.active.clone() {
+                    Some(active) if !done_current => {
+                        stopping = true;
+                        if router.announced {
+                            send_turn_interrupt(&client, &thread_id, active);
+                        } else {
+                            stop_when_announced = true;
+                        }
+                    }
+                    // Between turns: nothing to interrupt. Settle the stop so
+                    // the host sees the turn over.
+                    _ => {
+                        done_current = true;
+                        if !send(&event_tx, AgentEvent::Done {
+                            status: DoneStatus::Interrupted,
+                            result: None,
+                            error: None,
+                            session_id: Some(thread_id.clone()),
+                        }).await {
+                            break 'main;
+                        }
+                    }
+                }
+            },
+
             _ = interrupt.cancelled(), if !interrupt_sent => {
                 interrupt_sent = true;
                 interrupted = true;
+                // The runtime is going: so is everything it started.
+                #[cfg(unix)]
+                if let Some(pid) = child.id() {
+                    torn_down = crate::process::descendants(pid).await;
+                }
                 if let Some(turn) = router.active.clone() {
                     let client = client.clone();
                     let thread = thread_id.clone();
@@ -1680,6 +1908,17 @@ async fn run_session(session: Session) {
                 }
             },
 
+            _ = tokio::time::sleep_until(
+                prune_at.as_ref().map_or_else(tokio::time::Instant::now, |(at, _)| *at)
+            ), if prune_at.is_some() => {
+                let (_, stopped) = prune_at.take().expect("guarded by if");
+                open_commands.retain(|_, (pid, started_in)| {
+                    started_in.as_deref() != Some(stopped.as_str())
+                        || pid.as_deref().is_some_and(process_alive)
+                });
+                turn.set_background(open_commands.len());
+            },
+
             _ = event_tx.closed() => break 'main,
         }
     }
@@ -1716,12 +1955,50 @@ async fn run_session(session: Session) {
         }
     }
 
-    shutdown_child(&mut child, kill_grace).await;
+    crate::shutdown_agent(&mut child, torn_down, kill_grace).await;
     if let Some(handle) = escalation {
         handle.abort();
     }
 }
 
+/// How long an interrupted turn's commands get to exit before a process
+/// still running counts as background work.
+const COMMAND_EXIT_GRACE: Duration = Duration::from_secs(3);
+
+/// Whether a process the app-server reported is still running.
+fn process_alive(pid: &str) -> bool {
+    #[cfg(unix)]
+    {
+        // SAFETY: signal 0 only probes for existence; nothing is delivered.
+        pid.parse::<i32>()
+            .is_ok_and(|pid| pid > 0 && unsafe { libc::kill(pid, 0) } == 0)
+    }
+    #[cfg(not(unix))]
+    {
+        // Unknown: count it gone, which leaves the idle reaper as it was.
+        let _ = pid;
+        false
+    }
+}
+
+/// Ask the app-server to end `turn` (fire-and-forget: its end arrives as the
+/// turn's own completion notification).
+fn send_turn_interrupt(client: &RpcClient, thread_id: &str, turn: String) {
+    let client = client.clone();
+    let thread = thread_id.to_owned();
+    tokio::spawn(async move {
+        if let Err(e) = client
+            .request(
+                "turn/interrupt",
+                json!({ "threadId": thread, "turnId": turn }),
+            )
+            .await
+        {
+            tracing::warn!(target: "zeron_harness::codex", "turn/interrupt failed: {e}");
+        }
+    });
+}
+
 /// Deliver a steer as a fresh `turn/start` on the same thread (the fallback
 /// leg of the steer race, and the between-turns delivery path). Returns false
 /// when the loop should end (turn/start failed or the consumer hung up).
diff --git a/crates/harness/src/cursor/mod.rs b/crates/harness/src/cursor/mod.rs
index 2b4e3c1a53..ff363f32aa 100644
--- a/crates/harness/src/cursor/mod.rs
+++ b/crates/harness/src/cursor/mod.rs
@@ -252,6 +252,16 @@ impl Harness for CursorHarness {
     fn deterministic_turn_end(&self) -> bool {
         true
     }
+    /// The shim's `stop` cancels the turn's SDK run; the agent (and the
+    /// shim holding it) take the next prompt.
+    fn stops_turn_in_place(&self) -> bool {
+        true
+    }
+    /// Each SDK send names its model, so a change runs from the next turn on
+    /// the same agent; no model is Cursor's `auto`.
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd
+    }
 
     /// Keep a successful catalog during transient outages. A cold failure
     /// is an error, never a fabricated two-model success.
@@ -521,6 +531,7 @@ async fn run_session(session: Session) {
         request_input: _request_input,
         mut steering,
         interrupt,
+        turn,
     } = controls;
 
     let mut assistant_message_id = new_message_id();
@@ -528,6 +539,9 @@ async fn run_session(session: Session) {
     let mut steering_open = true;
     let mut interrupted = false;
     let mut interrupt_sent = false;
+    // A turn stop (`TurnControl::stop_turn`) in flight: the shim cancels the
+    // run; the agent stays up for the next prompt.
+    let mut stopping = false;
     let mut any_done = false;
     let mut done_after_interrupt = false;
     // A turn is settled and the session is parked awaiting the next prompt.
@@ -558,6 +572,24 @@ async fn run_session(session: Session) {
                 }
             },
 
+            // Cancel this turn's SDK run, not the agent: the shim answers
+            // with a cancelled turn and takes the next prompt. Steers still
+            // undelivered go with the stopped turn.
+            _ = turn.stop_requested(), if !interrupted => {
+                if parked {
+                    if !send(AgentEvent::Done {
+                        status: DoneStatus::Interrupted,
+                        result: None,
+                        error: None,
+                        session_id: session_id.clone(),
+                    }).await { break 'main; }
+                } else {
+                    stopping = true;
+                    pending_steers = 0;
+                    let _ = stdin_tx.send(json!({ "op": "stop" }).to_string());
+                }
+            },
+
             line = stdout_lines.next_line() => match line {
                 Ok(Some(line)) => {
                     let line = line.trim();
@@ -613,7 +645,7 @@ async fn run_session(session: Session) {
                                     error = ?frame.get("error").or_else(|| frame.get("message")),
                                     "Cursor SDK run failed");
                             }
-                            for ev in map_shim_frame(&frame, interrupted) {
+                            for ev in map_shim_frame(&frame, interrupted || stopping) {
                                 let is_done = matches!(ev, AgentEvent::Done { .. });
                                 let failed = matches!(ev, AgentEvent::Done { status: DoneStatus::Errored, .. });
                                 // Stamp the session id onto Dones the mapper
@@ -628,6 +660,7 @@ async fn run_session(session: Session) {
                                 }
                                 if is_done {
                                     any_done = true;
+                                    stopping = false;
                                     if interrupted {
                                         done_after_interrupt = true;
                                         break 'main;
@@ -654,7 +687,14 @@ async fn run_session(session: Session) {
                     pending_steers += 1;
                     parked = false;
                     any_done = false;
-                    let _ = stdin_tx.send(json!({ "op": "steer", "prompt": msg.prompt }).to_string());
+                    let mut line = json!({ "op": "steer", "prompt": msg.prompt });
+                    // A changed model runs from this message's own turn.
+                    if let Some(next) = msg.config {
+                        line["reconfigure"] = Value::Bool(true);
+                        line["model"] = json!(next.model);
+                        line["modelOptions"] = Value::Object(next.model_options);
+                    }
+                    let _ = stdin_tx.send(line.to_string());
                 }
                 None => {
                     steering_open = false;
@@ -698,6 +738,13 @@ async fn run_session(session: Session) {
         }
     }
 
+    // The SDK runs tools in the shim's process: snapshot them before it
+    // goes, so none outlives the runtime (see [`crate::shutdown_agent`]).
+    #[cfg(unix)]
+    let tree = match child.id() {
+        Some(pid) => crate::process::descendants(pid).await,
+        None => Vec::new(),
+    };
     drop(stdin_tx);
     // EOF asks the shim to cancel/close the SDK and settle its durable state.
     // Signals remain the bounded fallback when the SDK cannot shut down.
@@ -707,6 +754,8 @@ async fn run_session(session: Session) {
     ) {
         shutdown_child(&mut child, kill_grace).await;
     }
+    #[cfg(unix)]
+    crate::process::terminate_tree(&tree, kill_grace).await;
     if let Some(handle) = escalation {
         handle.abort();
     }
diff --git a/crates/harness/src/cursor/shim.mjs b/crates/harness/src/cursor/shim.mjs
index 9b433b8dc8..6e2ca376c1 100644
--- a/crates/harness/src/cursor/shim.mjs
+++ b/crates/harness/src/cursor/shim.mjs
@@ -13,8 +13,12 @@
 //   stdin  (engine → shim):
 //     {"op":"run","prompt","cwd","model"?,"modelOptions"?,"resume"?}   start / first turn
 //     {"op":"user","prompt"}                            explicit next turn
-//     {"op":"steer","prompt"}                           native mid-turn input
+//     {"op":"steer","prompt","model"?,"modelOptions"?,"reconfigure"?}
+//                                                       native mid-turn input;
+//                                                       `reconfigure` = runs as
+//                                                       its own turn on `model`
 //     {"op":"interrupt"}                                cancel the live run
+//     {"op":"stop"}                                     cancel this turn only; the agent stays up
 //   stdout (shim → engine):
 //     {"ev":"ready","agentId","model"?}
 //     {"ev":"steered"}                                   input consumed
@@ -330,6 +334,8 @@ if (process.argv[2] === "login") {
 let agent = null;
 let run = null;
 let interrupted = false;
+// A turn stop: this turn is cancelled, the agent takes the next prompt.
+let stopping = false;
 let closing = false;
 let cleanupPromise;
 beforeExit = () => cleanupPromise ??= (async () => {
@@ -445,6 +451,16 @@ function withAuthHint(message) {
 // Keep ownership until Cursor confirms that the active turn appended the text.
 // A boundary race returns revert_to_followup; only those messages start a turn.
 const pendingSteers = [];
+// The model the agent runs: set at start, replaced by a reconfiguring
+// message. Once replaced, every send names it (a send's model is per-run).
+let currentModel = null;
+let modelChanged = false;
+// Messages up to (not including) the first that changes the model: only
+// those may ride the running turn, natively or batched.
+function steerableNow() {
+  const at = pendingSteers.findIndex(message => message.selection);
+  return at < 0 ? pendingSteers : pendingSteers.slice(0, at);
+}
 const steerDeliveries = new Set();
 let steerPump = null;
 let turnActive = false;
@@ -461,7 +477,7 @@ let preemptedRun = null;
 const NATIVE_STEER_ONLY = process.env.ZERON_CURSOR_NATIVE_STEER_ONLY === "1";
 function preemptForSteer() {
   if (NATIVE_STEER_ONLY) return false;
-  if (!turnActive || !run || activeTools.size || preempting || interrupted || closing) return false;
+  if (!turnActive || !run || activeTools.size || preempting || interrupted || stopping || closing) return false;
   preempting = true;
   preemptedRun = run;
   run.cancel().catch(() => {});
@@ -490,7 +506,7 @@ function pumpSteers() {
       if (typeof target.steer !== "function") {
         throw new Error("Cursor SDK lacks native steering; update the managed SDK");
       }
-      const message = pendingSteers.find(message => !message.submitted && message.revertedRun !== target);
+      const message = steerableNow().find(message => !message.submitted && message.revertedRun !== target);
       if (!message) return;
       const reverted = await recordNativeSteer(message.prompt);
       // History lookup can yield while another tool starts. Never let native
@@ -522,7 +538,14 @@ function pumpSteers() {
 }
 async function followupSteers() {
   while (pendingSteers.length && !interrupted && !closing) {
-    const batch = pendingSteers.splice(0);
+    // A model change starts its own turn: it never joins the messages sent
+    // before it, and those after it run on its model.
+    if (pendingSteers[0].selection) {
+      currentModel = pendingSteers[0].selection;
+      modelChanged = true;
+    }
+    const next = pendingSteers.findIndex((message, i) => i > 0 && message.selection);
+    const batch = pendingSteers.splice(0, next < 0 ? pendingSteers.length : next);
     // A later input can be delivered before an earlier one is rejected.
     // Never replay the delivered input when draining the rejected prefix.
     const undelivered = batch.filter(message => !message.delivered);
@@ -535,6 +558,7 @@ async function followupSteers() {
   }
 }
 function acceptSteer(message) {
+  if (message.reconfigure) message.selection = modelSelection(message);
   pendingSteers.push(message);
   if (turnActive) {
     if (!preemptForSteer()) void pumpSteers().catch(fatal);
@@ -549,13 +573,16 @@ async function runTurn(prompt, ready, accepted) {
   try {
     prompt = await preserveInterruptedContext(prompt);
     ready?.();
-    if (interrupted || closing) {
+    if (interrupted || stopping || closing) {
+      stopping = false;
+      turnActive = false;
       out({ev: "turn", status: "cancelled"});
       return;
     }
     accepted?.();
     let thisRun = null;
     run = thisRun = await agent.send(prompt, {
+      ...(modelChanged ? { model: currentModel } : {}),
       onDelta: ({ update }) => {
         if (thisRun && thisRun === preemptedRun) return;
         try {
@@ -574,29 +601,39 @@ async function runTurn(prompt, ready, accepted) {
   // A steer that arrived while send() was creating the run preempts now.
   if (!pendingSteers.length || !preemptForSteer()) void pumpSteers().catch(fatal);
   // Interrupt may arrive while send() is still creating the run.
-  if (interrupted || closing) await run.cancel().catch(() => {});
+  if (interrupted || stopping || closing) await run.cancel().catch(() => {});
   let result;
   try {
     result = await run.wait();
   } catch (e) {
-    if (preempting && !interrupted && !closing) return continueAfterPreempt();
+    if (preempting && !interrupted && !stopping && !closing) return continueAfterPreempt();
+    const stopped = stopping;
+    stopping = false;
+    if (stopped) {
+      // The agent lives on; the next prompt starts a fresh run.
+      activeTools.clear();
+      run = null;
+      turnActive = false;
+    }
     out({
       ev: "turn",
-      status: interrupted ? "cancelled" : "error",
-      error: withAuthHint(formatError(e, run?.requestId)),
+      status: interrupted || stopped ? "cancelled" : "error",
+      ...(interrupted || stopped ? {} : { error: withAuthHint(formatError(e, run?.requestId)) }),
     });
     return;
   }
-  if (preempting && !interrupted && !closing) return continueAfterPreempt();
+  if (preempting && !interrupted && !stopping && !closing) return continueAfterPreempt();
   activeTools.clear();
   await pumpSteers();
   await Promise.all(steerDeliveries);
   run = null;
   turnActive = false;
+  const stopped = stopping;
+  stopping = false;
   out({
     ev: "turn",
-    status: result?.status ?? "finished",
-    ...(result?.error?.message ? { error: withAuthHint(formatError(result.error, result.requestId)) } : {}),
+    status: stopped ? "cancelled" : result?.status ?? "finished",
+    ...(!stopped && result?.error?.message ? { error: withAuthHint(formatError(result.error, result.requestId)) } : {}),
   });
   if (pendingSteers.length) chain = chain.then(followupSteers).catch(fatal);
 }
@@ -621,6 +658,7 @@ function modelSelection(msg) {
 
 async function start(msg) {
   const model = modelSelection(msg);
+  currentModel = model;
   // The SDK loads NO ambient settings unless asked: without settingSources the
   // user's ~/.cursor/mcp.json and plugins are invisible and the inline zeron
   // server is the only MCP the agent sees. "project" (and so "all") is left
@@ -726,6 +764,16 @@ rl.on("line", (line) => {
       interrupted = true;
       if (run) run.cancel().catch(() => {});
       break;
+    case "stop":
+      // Undelivered steers go with the stopped turn.
+      pendingSteers.splice(0);
+      if (!turnActive) {
+        out({ev: "turn", status: "cancelled"});
+      } else {
+        stopping = true;
+        if (run) run.cancel().catch(() => {});
+      }
+      break;
     default:
       break;
   }
diff --git a/crates/harness/src/lib.rs b/crates/harness/src/lib.rs
index f82edf6b56..02b8b75b44 100644
--- a/crates/harness/src/lib.rs
+++ b/crates/harness/src/lib.rs
@@ -44,6 +44,83 @@ pub enum HarnessError {
 pub struct SteerMessage {
     pub prompt: String,
     pub message_id: Option<String>,
+    /// Staged image paths sent with this prompt. Drivers that inline images
+    /// deliver them with the text; the rest rely on the path refs the prompt
+    /// text already carries.
+    pub attachments: Vec<String>,
+    /// The run configuration this prompt was sent with, when it differs
+    /// from the live runtime's and the driver adopts it in place
+    /// ([`Harness::reconfigures_in_place`]): apply it before the prompt.
+    pub config: Option<Box<RunRequest>>,
+}
+
+impl SteerMessage {
+    pub fn text(prompt: impl Into<String>) -> Self {
+        Self {
+            prompt: prompt.into(),
+            message_id: None,
+            attachments: Vec::new(),
+            config: None,
+        }
+    }
+}
+
+/// Host ↔ runtime signals that span a persistent runtime's turns.
+///
+/// Stopping a turn is not tearing down the runtime: a runtime holds work the
+/// user never asked to stop (background subagents, background shells). A
+/// driver that returns true from [`Harness::stops_turn_in_place`] answers
+/// [`Self::stop_turn`] by ending only the in-flight turn with
+/// `Done { status: Interrupted }` and staying alive for the next prompt; the
+/// `interrupt` token remains the runtime teardown.
+#[derive(Clone, Default)]
+pub struct TurnControl {
+    stop: std::sync::Arc<tokio::sync::Notify>,
+    background: std::sync::Arc<std::sync::atomic::AtomicUsize>,
+}
+
+impl TurnControl {
+    /// Host: end the in-flight turn, keeping the runtime and its background work.
+    pub fn stop_turn(&self) {
+        self.stop.notify_one();
+    }
+
+    /// Driver: resolves once per [`Self::stop_turn`].
+    pub async fn stop_requested(&self) {
+        self.stop.notified().await;
+    }
+
+    /// Driver: how many background tasks the runtime currently holds.
+    pub fn set_background(&self, tasks: usize) {
+        self.background
+            .store(tasks, std::sync::atomic::Ordering::Release);
+    }
+
+    /// Host: the runtime reports live background work, so retiring it now
+    /// would kill work nobody asked to stop.
+    pub fn background_live(&self) -> bool {
+        self.background.load(std::sync::atomic::Ordering::Acquire) > 0
+    }
+}
+
+/// Run-config values compared as their wire meaning, not their JSON type:
+/// clients disagree on spelling (the phone sends `"true"` where the desktop
+/// sends `true`), and neither spelling is a different configuration.
+pub fn same_model_options(
+    a: &serde_json::Map<String, serde_json::Value>,
+    b: &serde_json::Map<String, serde_json::Value>,
+) -> bool {
+    fn canonical(value: &serde_json::Value) -> Option<String> {
+        match value {
+            serde_json::Value::Null => None,
+            serde_json::Value::String(s) if s.is_empty() => None,
+            serde_json::Value::String(s) => Some(s.clone()),
+            other => Some(other.to_string()),
+        }
+    }
+    let keys: std::collections::BTreeSet<&String> = a.keys().chain(b.keys()).collect();
+    keys.into_iter()
+        .all(|key| a.get(key).and_then(canonical) == b.get(key).and_then(canonical))
 }
 
 /// Host-side controls handed to a run: input-request bridge + steering mailbox.
@@ -64,6 +141,8 @@ pub struct RunControls {
     /// interrupt, then escalates to SIGTERM/SIGKILL on the child after a grace
     /// period. The run's stream ends with `Done { status: Interrupted }`.
     pub interrupt: CancellationToken,
+    /// Turn-level stop and background-work reporting (see [`TurnControl`]).
+    pub turn: TurnControl,
 }
 
 /// Catalog provenance stays internal; RPC clients retain the Vec<Model> shape.
@@ -113,6 +192,33 @@ pub trait Harness: Send + Sync {
     fn authoritative_prompt_end(&self) -> bool {
         self.deterministic_turn_end()
     }
+    /// Whether this driver honors [`TurnControl::stop_turn`]: it ends only
+    /// the in-flight turn (`Done { Interrupted }`) and the runtime stays up
+    /// with its background work. Otherwise stopping a turn tears the runtime
+    /// down through the `interrupt` token.
+    fn stops_turn_in_place(&self) -> bool {
+        false
+    }
+    /// Whether a live runtime started for `live` can take `next` as its
+    /// next prompt. Only a difference that changes how the runtime was
+    /// launched needs a fresh one — replacing a runtime kills its background
+    /// work. The default covers what every driver's launch reads (the
+    /// sandbox level and auto-approve are read only by drivers that
+    /// override this); drivers narrow it further to their own launch.
+    /// Whether a live runtime started for `live` adopts `next`'s differing
+    /// configuration in place, before `next`'s prompt, instead of being
+    /// replaced (which kills its background work). The prompt then arrives
+    /// with [`SteerMessage::config`] set. Consulted only when
+    /// [`Self::same_runtime`] is false.
+    fn reconfigures_in_place(&self, _live: &RunRequest, _next: &RunRequest) -> bool {
+        false
+    }
+    fn same_runtime(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.model == next.model
+            && live.reasoning == next.reasoning
+            && same_model_options(&live.model_options, &next.model_options)
+            && live.cwd == next.cwd
+    }
     async fn models(&self) -> Result<Vec<Model>, HarnessError>;
     fn model_context(&self) -> Result<Option<ModelContext>, HarnessError> {
         Ok(None)
@@ -407,6 +513,35 @@ pub use pi::PiHarness;
 // Child lifecycle (shared by the codex and ACP harnesses)
 // ---------------------------------------------------------------------------
 
+/// End an agent runtime together with every process it started. `earlier`
+/// is a descendant snapshot taken when the teardown began, in case the
+/// agent exits before this one: its orphans can no longer be traced then.
+/// Windows' job object already owns the whole tree.
+pub(crate) async fn shutdown_agent(
+    child: &mut process::Child,
+    earlier: Vec<i32>,
+    kill_grace: std::time::Duration,
+) {
+    #[cfg(unix)]
+    {
+        let mut tree = earlier;
+        if let Some(pid) = child.id() {
+            for pid in process::descendants(pid).await {
+                if !tree.contains(&pid) {
+                    tree.push(pid);
+                }
+            }
+        }
+        shutdown_child(child, kill_grace).await;
+        process::terminate_tree(&tree, kill_grace).await;
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = earlier;
+        shutdown_child(child, kill_grace).await;
+    }
+}
+
 /// Reap the child: Unix sends SIGTERM then SIGKILL after `kill_grace`;
 /// Windows terminates the owned job after protocol shutdown has finished.
 pub(crate) async fn shutdown_child(child: &mut process::Child, kill_grace: std::time::Duration) {
diff --git a/crates/harness/src/opencode/mod.rs b/crates/harness/src/opencode/mod.rs
index 74dc4b4ec6..c19f450c85 100644
--- a/crates/harness/src/opencode/mod.rs
+++ b/crates/harness/src/opencode/mod.rs
@@ -66,7 +66,7 @@ use zeron_proto::{
 };
 
 use crate::process::{Child, Command, Stdio};
-use crate::{Harness, HarnessError, RunControls, shutdown_child};
+use crate::{Harness, HarnessError, RunControls};
 
 /// opencode loads plugins and MCP config before the server answers; cold
 /// plugin-heavy starts can take minutes. Shared by chat startup and model
@@ -372,6 +372,19 @@ impl Harness for OpencodeHarness {
     fn deterministic_turn_end(&self) -> bool {
         true
     }
+    /// Aborting the session ends the turn; the server and the session take
+    /// the next prompt.
+    fn stops_turn_in_place(&self) -> bool {
+        true
+    }
+    /// The model and effort ride each prompt (1.x) or are set on the
+    /// session (2.x), so a change applies from the next prompt without a new
+    /// server. Clearing one back to the default cannot be expressed that way.
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        live.cwd == next.cwd
+            && (next.model.is_some() || live.model.is_none())
+            && (next.reasoning.is_some() || live.reasoning.is_none())
+    }
 
     /// Live discovery off `GET /provider` (what the desktop app populates its
     /// picker from). Account/config changes invalidate the last-good catalog;
@@ -845,7 +858,8 @@ impl Server {
 
     async fn shutdown(&mut self, kill_grace: Duration) {
         if let Some(child) = self.child.as_mut() {
-            shutdown_child(child, kill_grace).await;
+            // The server and every command it started.
+            crate::shutdown_agent(child, Vec::new(), kill_grace).await;
         }
     }
 
@@ -1488,6 +1502,7 @@ async fn run_session(session: Session) {
         request_input,
         mut steering,
         interrupt,
+        turn: turn_control,
     } = controls;
     let request_input = Arc::new(request_input);
     let directory = (!request.cwd.is_empty()).then(|| request.cwd.clone());
@@ -1582,14 +1597,7 @@ async fn run_session(session: Session) {
         }
     };
 
-    let model = request
-        .model
-        .as_deref()
-        .and_then(|m| m.split_once('/'))
-        .map(|(provider, model)| (provider.to_owned(), model.to_owned()));
-    let variant = model.as_ref().and_then(|(provider, model_id)| {
-        pick_variant(&providers, provider, model_id, request.reasoning)
-    });
+    let (mut model, mut variant) = model_selection(&providers, &request);
     let context_windows: HashMap<String, u64> = providers
         .all
         .iter()
@@ -1729,9 +1737,15 @@ async fn run_session(session: Session) {
     let mut pending_spawns: VecDeque<PendingSpawn> = VecDeque::new();
     // Child sessions created before their spawn chip was seen (id → title).
     let mut unbound_children: HashMap<String, String> = HashMap::new();
-    let mut queued_steers: VecDeque<(String, bool)> = VecDeque::new();
+    let mut queued_steers: VecDeque<QueuedSteer> = VecDeque::new();
     let mut steering_open = true;
     let mut interrupt_requested = false;
+    // A turn stop (`TurnControl::stop_turn`) in flight: the session is
+    // aborted like an interrupt, but the server and session stay up.
+    let mut stopping = false;
+    // A stop the server never acknowledged: the turn may still be running,
+    // so the runtime is torn down and the stop reported only once it is gone.
+    let mut stop_teardown = false;
     let mut pending_usage: Option<AgentEvent> = None;
     let mut done_sent = false;
 
@@ -1752,11 +1766,12 @@ async fn run_session(session: Session) {
             turn.active = false;
             if let Some(usage) = pending_usage.take()
                 && !interrupt_requested
+                && !stopping
                 && !send(&event_tx, usage).await
             {
                 break $label;
             }
-            if interrupt_requested {
+            if interrupt_requested || stopping {
                 settle_children(&mut children, &event_tx, DoneStatus::Interrupted).await;
                 let _ = send(&event_tx, AgentEvent::Done {
                     status: DoneStatus::Interrupted,
@@ -1765,18 +1780,32 @@ async fn run_session(session: Session) {
                     session_id: Some(session_id.clone()),
                 }).await;
                 done_sent = true;
-                break $label;
+                if interrupt_requested {
+                    break $label;
+                }
+                // A stopped turn: the server and session take the next prompt.
+                stopping = false;
+                abort_deadline = None;
+                continue $label;
             }
-            if let Some((first, native_command_selected)) = queued_steers.pop_front() {
+            if let Some(first) = queued_steers.pop_front() {
                 turn_generation = turn_generation.wrapping_add(1);
+                let native_command_selected = first.native;
+                let config = first.config;
+                let mut attachments = first.attachments;
                 // Plain-text steers waiting together go out as one prompt,
                 // each confirmed by its own Steered boundary; a native
-                // command always travels alone.
-                let mut texts = vec![first];
+                // command always travels alone, and a changed configuration
+                // starts a new prompt (the ones after it were sent with it).
+                let mut texts = vec![first.text];
                 while !native_command_selected
-                    && queued_steers.front().is_some_and(|(_, native)| !native)
+                    && queued_steers
+                        .front()
+                        .is_some_and(|next| !next.native && next.config.is_none())
                 {
-                    texts.push(queued_steers.pop_front().expect("front checked").0);
+                    let next = queued_steers.pop_front().expect("front checked");
+                    texts.push(next.text);
+                    attachments.extend(next.attachments);
                 }
                 let mut consumer_gone = false;
                 for _ in &texts {
@@ -1793,24 +1822,33 @@ async fn run_session(session: Session) {
                     break $label;
                 }
                 let steer = texts.join("\n\n");
-                match post_prompt(
-                    &server,
-                    &bus_tx,
-                    &session_id,
-                    dir,
-                    &commands,
-                    &steer,
-                    native_command_selected,
-                    turn_generation,
-                    &command_failure_tx,
-                    TurnSpec {
-                        model: model.as_ref(),
-                        variant: variant.as_deref(),
-                        attachments: &[],
-                    },
-                )
-                .await
-                {
+                let adopted = match config {
+                    Some(next) => adopt_config(&server, &session_id, dir, &next)
+                        .await
+                        .map(|selection| (model, variant) = selection),
+                    None => Ok(()),
+                };
+                let sent = match adopted {
+                    Ok(()) => post_prompt(
+                        &server,
+                        &bus_tx,
+                        &session_id,
+                        dir,
+                        &commands,
+                        &steer,
+                        native_command_selected,
+                        turn_generation,
+                        &command_failure_tx,
+                        TurnSpec {
+                            model: model.as_ref(),
+                            variant: variant.as_deref(),
+                            attachments: &attachments,
+                        },
+                    )
+                    .await,
+                    Err(e) => Err(e),
+                };
+                match sent {
                     Ok(()) => {
                         turn = TurnState::begin(stall);
                         continue $label;
@@ -1862,6 +1900,7 @@ async fn run_session(session: Session) {
             if turn.active
                 && !turn.preempted
                 && !interrupt_requested
+                && !stopping
                 && !queued_steers.is_empty()
                 && turn.open_tools.is_empty()
             {
@@ -1905,6 +1944,44 @@ async fn run_session(session: Session) {
 
             _ = event_tx.closed() => break 'main,
 
+            // End the turn, not the server: abort the session's generation
+            // and keep both up for the next prompt. Steers still waiting for
+            // this turn's end go with it.
+            _ = turn_control.stop_requested(), if !interrupt_requested => {
+                queued_steers.clear();
+                if turn.active && !stopping {
+                    stopping = true;
+                    turn.idle_ready = true;
+                    let abort = tokio::time::timeout(
+                        Duration::from_secs(5),
+                        server.abort_session(&session_id, dir),
+                    )
+                    .await;
+                    if matches!(abort, Ok(Ok(_))) {
+                        abort_deadline = Some(tokio::time::Instant::now() + interrupt_grace);
+                    } else {
+                        // The turn may still be running: this session must
+                        // never take a prompt on top of it.
+                        tracing::warn!(
+                            target: "zeron_harness::opencode",
+                            "turn stop abort failed; tearing the runtime down"
+                        );
+                        stop_teardown = true;
+                        break 'main;
+                    }
+                } else if !turn.active {
+                    // Between turns: nothing to abort. Settle the stop so the
+                    // host sees the turn over.
+                    let _ = send(&event_tx, AgentEvent::Done {
+                        status: DoneStatus::Interrupted,
+                        result: None,
+                        error: None,
+                        session_id: Some(session_id.clone()),
+                    }).await;
+                    done_sent = true;
+                }
+            }
+
             _ = interrupt.cancelled(), if !interrupt_requested => {
                 interrupt_requested = true;
                 if turn.active {
@@ -1945,7 +2022,7 @@ async fn run_session(session: Session) {
 
             failure = command_failure_rx.recv() => {
                 let Some(failure) = failure else { continue 'main; };
-                if failure.generation != turn_generation || !turn.active || interrupt_requested {
+                if failure.generation != turn_generation || !turn.active || interrupt_requested || stopping {
                     tracing::debug!(
                         target: "zeron_harness::opencode",
                         failed_generation = failure.generation,
@@ -1985,35 +2062,49 @@ async fn run_session(session: Session) {
                             HarnessId::Opencode,
                         );
                         if turn.active {
-                            queued_steers.push_back((prompt, native_command_selected));
+                            queued_steers.push_back(QueuedSteer {
+                                text: prompt,
+                                native: native_command_selected,
+                                attachments: steer.attachments,
+                                config: steer.config,
+                            });
                             maybe_preempt!();
                         } else {
                             turn_generation = turn_generation.wrapping_add(1);
-                            // Between turns (shouldn't happen — the engine
-                            // steers live runs — but deliver, don't drop).
+                            // Between turns: the engine routes the next message
+                            // of a parked session here — images included.
                             let (prev, next) = rotate(&mut assistant_message_id);
                             let _ = send(&event_tx, AgentEvent::Steered {
                                 assistant_message_id: Some(prev),
                                 next_assistant_message_id: Some(next),
                             }).await;
-                            match post_prompt(
-                                &server,
-                                &bus_tx,
-                                &session_id,
-                                dir,
-                                &commands,
-                                &prompt,
-                                native_command_selected,
-                                turn_generation,
-                                &command_failure_tx,
-                                TurnSpec {
-                                    model: model.as_ref(),
-                                    variant: variant.as_deref(),
-                                    attachments: &[],
-                                },
-                            )
-                            .await
-                            {
+                            let adopted = match &steer.config {
+                                Some(next) => adopt_config(&server, &session_id, dir, next)
+                                    .await
+                                    .map(|selection| (model, variant) = selection),
+                                None => Ok(()),
+                            };
+                            let sent = match adopted {
+                                Ok(()) => post_prompt(
+                                    &server,
+                                    &bus_tx,
+                                    &session_id,
+                                    dir,
+                                    &commands,
+                                    &prompt,
+                                    native_command_selected,
+                                    turn_generation,
+                                    &command_failure_tx,
+                                    TurnSpec {
+                                        model: model.as_ref(),
+                                        variant: variant.as_deref(),
+                                        attachments: &steer.attachments,
+                                    },
+                                )
+                                .await,
+                                Err(e) => Err(e),
+                            };
+                            match sent {
                                 Ok(()) => turn = TurnState::begin(stall),
                                 Err(error) => {
                                     let message = error.to_string();
@@ -2048,6 +2139,16 @@ async fn run_session(session: Session) {
             }
 
             _ = stall_sleep => {
+                if abort_deadline.is_some() && stopping {
+                    // The stop's abort acknowledged nothing within the grace:
+                    // the turn may still be running. Tear the runtime down.
+                    tracing::warn!(
+                        target: "zeron_harness::opencode",
+                        "turn stop unacknowledged; tearing the runtime down"
+                    );
+                    stop_teardown = true;
+                    break 'main;
+                }
                 if abort_deadline.is_some() {
                     // Abort acknowledged nothing within the grace: hard stop.
                     settle_children(&mut children, &event_tx, DoneStatus::Interrupted).await;
@@ -2091,7 +2192,7 @@ async fn run_session(session: Session) {
             msg = bus_rx.recv() => {
                 let Some(msg) = msg else { break 'main };
                 match msg {
-                    BusMsg::CommandFailed(_) if interrupt_requested => {}
+                    BusMsg::CommandFailed(_) if interrupt_requested || stopping => {}
                     BusMsg::CommandFailed(message) => {
                         let _ = send(&event_tx, AgentEvent::Done {
                             status: DoneStatus::Errored, result: None,
@@ -2143,13 +2244,18 @@ async fn run_session(session: Session) {
                         break 'main;
                     }
                     BusMsg::Event(event) => {
-                        if interrupt_requested {
+                        if interrupt_requested || stopping {
                             // Only the terminal idle/interrupt acknowledgement may
                             // affect an aborted turn; discard late content and usage.
-                            let kind = event.get("type").and_then(Value::as_str);
-                            let ours = event.pointer("/properties/sessionID").and_then(Value::as_str) == Some(session_id.as_str());
+                            // v1's /global/event wraps it ({payload}), like
+                            // `handle_bus_event` reads: matching the envelope
+                            // missed every acknowledgement, and each stop
+                            // waited out the grace.
+                            let payload = event.get("payload").unwrap_or(&event);
+                            let kind = payload.get("type").and_then(Value::as_str);
+                            let ours = payload.pointer("/properties/sessionID").and_then(Value::as_str) == Some(session_id.as_str());
                             let idle = kind == Some("session.idle") || kind == Some("session.interrupted")
-                                || (kind == Some("session.status") && event.pointer("/properties/status/type").and_then(Value::as_str) == Some("idle"));
+                                || (kind == Some("session.status") && payload.pointer("/properties/status/type").and_then(Value::as_str) == Some("idle"));
                             if ours && idle { settle_idle!('main); }
                             continue;
                         }
@@ -2174,7 +2280,7 @@ async fn run_session(session: Session) {
                             BusOutcome::TurnIdle => settle_idle!('main),
                             // Our own steer preempt: a steer boundary.
                             BusOutcome::TurnInterrupted
-                                if turn.preempted && !interrupt_requested =>
+                                if turn.preempted && !interrupt_requested && !stopping =>
                             {
                                 settle_idle!('main)
                             }
@@ -2189,6 +2295,25 @@ async fn run_session(session: Session) {
         }
     }
 
+    if stop_teardown {
+        // Close the mailbox before the stop reads settled: the next prompt
+        // must start a fresh runtime, never land in this one.
+        drop(steering);
+        bus_handle.abort();
+        server.shutdown(kill_grace).await;
+        settle_children(&mut children, &event_tx, DoneStatus::Interrupted).await;
+        let _ = send(
+            &event_tx,
+            AgentEvent::Done {
+                status: DoneStatus::Interrupted,
+                result: None,
+                error: None,
+                session_id: Some(session_id.clone()),
+            },
+        )
+        .await;
+        return;
+    }
     if !done_sent {
         // Consumer went away (stream dropped): nothing to report to.
         tracing::debug!(target: "zeron_harness::opencode", "run loop ended without settling");
@@ -2291,6 +2416,53 @@ fn context_usage_event(info: &Value, context_windows: &HashMap<String, u64>) ->
 }
 
 /// The requested effort as a variant id the model actually advertises.
+/// A message waiting for the turn's end.
+struct QueuedSteer {
+    text: String,
+    /// It selects a native command (which always travels alone).
+    native: bool,
+    attachments: Vec<String>,
+    /// The configuration it was sent with, adopted before its prompt.
+    config: Option<Box<RunRequest>>,
+}
+
+/// The `provider/model` pair and reasoning variant a request runs with.
+fn model_selection(
+    providers: &ProviderCatalog,
+    request: &RunRequest,
+) -> (Option<(String, String)>, Option<String>) {
+    let model = request
+        .model
+        .as_deref()
+        .and_then(|m| m.split_once('/'))
+        .map(|(provider, model)| (provider.to_owned(), model.to_owned()));
+    let variant = model.as_ref().and_then(|(provider, model_id)| {
+        pick_variant(providers, provider, model_id, request.reasoning)
+    });
+    (model, variant)
+}
+
+/// Adopt `next`'s model and effort for the prompts that follow: 1.x carries
+/// them on each prompt, 2.x sets them on the session first. The catalog is
+/// fetched again here rather than held for the session's life.
+async fn adopt_config(
+    server: &Server,
+    session_id: &str,
+    dir: Option<&str>,
+    next: &RunRequest,
+) -> Result<(Option<(String, String)>, Option<String>), HarnessError> {
+    let providers = server.provider_catalog(dir).await.unwrap_or_default();
+    let (model, variant) = model_selection(&providers, next);
+    if server.protocol().await == Protocol::V2
+        && let Some((provider, model_id)) = &model
+    {
+        server
+            .set_model(session_id, provider, model_id, variant.as_deref(), dir)
+            .await?;
+    }
+    Ok((model, variant))
+}
+
 fn pick_variant(
     providers: &ProviderCatalog,
     provider_id: &str,
diff --git a/crates/harness/src/opencode/tests.rs b/crates/harness/src/opencode/tests.rs
index 8b3c4a72ff..f362de441b 100644
--- a/crates/harness/src/opencode/tests.rs
+++ b/crates/harness/src/opencode/tests.rs
@@ -237,6 +237,8 @@ impl TurnWire {
                 .send(crate::SteerMessage {
                     prompt: "second".into(),
                     message_id: None,
+                    attachments: Vec::new(),
+                    config: None,
                 })
                 .await
                 .unwrap();
@@ -273,6 +275,7 @@ impl TurnWire {
                 }),
                 steering,
                 interrupt: interrupt.clone(),
+                turn: Default::default(),
             },
             request: serde_json::from_value(request).unwrap(),
             interrupt_grace: Duration::from_secs(2),
@@ -412,6 +415,8 @@ async fn completed_turn_keeps_mailbox_alive_for_the_next_queued_request() {
         .send(crate::SteerMessage {
             prompt: "after completion".into(),
             message_id: Some("second".into()),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
diff --git a/crates/harness/src/pi/mod.rs b/crates/harness/src/pi/mod.rs
index 743e7daf92..a990028abc 100644
--- a/crates/harness/src/pi/mod.rs
+++ b/crates/harness/src/pi/mod.rs
@@ -228,6 +228,14 @@ impl Process {
         self.child.shutdown(grace).await;
     }
 }
+/// Whether `request` picks a thinking level (an effort, or thinking off).
+fn thinking_selected(request: &RunRequest) -> bool {
+    request.reasoning.is_some()
+        || request
+            .model_options
+            .get("pi_thinking")
+            .is_some_and(|v| v == "off")
+}
 fn response_data(frame: Value) -> Result<Value, HarnessError> {
     if frame["success"] == true {
         Ok(frame["data"].clone())
@@ -265,6 +273,14 @@ impl Harness for PiHarness {
     fn deterministic_turn_end(&self) -> bool {
         true
     }
+    /// `set_model` and `set_thinking_level` change the live process. Clearing
+    /// either back to the default cannot be expressed that way.
+    fn reconfigures_in_place(&self, live: &RunRequest, next: &RunRequest) -> bool {
+        let model = |r: &RunRequest| r.model.as_deref().filter(|m| *m != "default").is_some();
+        live.cwd == next.cwd
+            && (model(next) || !model(live))
+            && (thinking_selected(next) || !thinking_selected(live))
+    }
     async fn models(&self) -> Result<Vec<Model>, HarnessError> {
         Ok(self.model_catalog(false).await?.models)
     }
@@ -379,6 +395,7 @@ impl Harness for PiHarness {
                 request_input,
                 mut steering,
                 interrupt,
+                turn: _,
             } = controls;
             runner.process.dialogs.input = Some(std::sync::Arc::from(request_input));
             let consumer = runner.tx.clone();
@@ -520,7 +537,34 @@ impl Runner {
                 .query(json!({"type":"set_steering_mode","mode":"all"}), backlog)
                 .await?;
         }
-        if let Some(model) = self.request.model.as_deref().filter(|s| *s != "default") {
+        let request = self.request.clone();
+        self.configure(&request, backlog).await?;
+        let commands = self
+            .process
+            .query(json!({"type":"get_commands"}), backlog)
+            .await?;
+        self.extension_commands = commands["commands"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter(|c| c["source"] == "extension")
+            .map(|c| string(c, "name").to_owned())
+            .collect();
+        self.emit(AgentEvent::AvailableCommands {
+            commands: catalog::commands(&commands),
+        })
+        .await?;
+        self.process
+            .query(json!({"type":"get_state"}), backlog)
+            .await
+    }
+    /// Select `request`'s model and thinking level on the live process.
+    async fn configure(
+        &mut self,
+        request: &RunRequest,
+        backlog: &mut Vec<Value>,
+    ) -> Result<(), HarnessError> {
+        if let Some(model) = request.model.as_deref().filter(|s| *s != "default") {
             let models = self
                 .process
                 .query(json!({"type":"get_available_models"}), backlog)
@@ -546,27 +590,20 @@ impl Runner {
                 )
                 .await?;
         }
-        if self.request.reasoning.is_some()
-            || self
-                .request
-                .model_options
-                .get("pi_thinking")
-                .is_some_and(|v| v == "off")
-        {
+        if thinking_selected(request) {
             let supported = self
                 .process
                 .query(json!({"type":"get_available_thinking_levels"}), backlog)
                 .await?;
             let levels = supported["levels"].as_array().cloned().unwrap_or_default();
-            let desired = if self
-                .request
+            let desired = if request
                 .model_options
                 .get("pi_thinking")
                 .is_some_and(|v| v == "off")
             {
                 "off".to_string()
             } else {
-                serde_json::to_value(self.request.reasoning)
+                serde_json::to_value(request.reasoning)
                     .unwrap()
                     .as_str()
                     .unwrap_or("medium")
@@ -591,24 +628,7 @@ impl Runner {
                 )
                 .await?;
         }
-        let commands = self
-            .process
-            .query(json!({"type":"get_commands"}), backlog)
-            .await?;
-        self.extension_commands = commands["commands"]
-            .as_array()
-            .into_iter()
-            .flatten()
-            .filter(|c| c["source"] == "extension")
-            .map(|c| string(c, "name").to_owned())
-            .collect();
-        self.emit(AgentEvent::AvailableCommands {
-            commands: catalog::commands(&commands),
-        })
-        .await?;
-        self.process
-            .query(json!({"type":"get_state"}), backlog)
-            .await
+        Ok(())
     }
     async fn run(
         &mut self,
@@ -674,6 +694,18 @@ impl Runner {
                             }))
                 }) {
                     if let Some(steer) = self.queued.pop_front() {
+                        // A changed model or thinking level applies on the
+                        // live process before the message it was sent with.
+                        if let Some(next) = &steer.config {
+                            let mut backlog = vec![];
+                            self.configure(next, &mut backlog).await?;
+                            self.request.model = next.model.clone();
+                            self.request.reasoning = next.reasoning;
+                            self.request.model_options = next.model_options.clone();
+                            for frame in backlog {
+                                self.frame(frame).await?;
+                            }
+                        }
                         if !self.active {
                             self.norm.reset();
                         }
@@ -681,7 +713,8 @@ impl Runner {
                         self.active = true;
                         // Atomic Pi operation: queue at a step boundary if busy, start if idle.
                         // A separate get_state + steer pair would strand an input on the idle race.
-                        self.submit(steer.prompt.clone(), json!([]), true)?;
+                        let images = load_images(&steer.attachments).await;
+                        self.submit(steer.prompt.clone(), images, true)?;
                         self.deliveries.push_back(Delivery {
                             epoch: self.epoch,
                             queued: false,
diff --git a/crates/harness/src/process.rs b/crates/harness/src/process.rs
index de5b7ebdbe..ac99237089 100644
--- a/crates/harness/src/process.rs
+++ b/crates/harness/src/process.rs
@@ -25,10 +25,132 @@ pub(crate) fn signal_target(child: &Child) -> Option<std::sync::Arc<crate::windo
     Some(child.job.clone())
 }
 
+/// Every live descendant of `root` — children, grandchildren, … — from one
+/// process-table snapshot. Agent CLIs start each shell in its OWN process
+/// group (Claude's background Bash, Codex's exec sessions), so neither a
+/// signal to the agent nor to its group reaches them, and a background
+/// shell outlives its agent (verified live, Claude 2.1.286: its own task
+/// stop and SIGTERM both leave the shell running). Snapshot while the agent
+/// is alive: once it exits, its orphans are reparented and untraceable.
+#[cfg(unix)]
+pub(crate) async fn descendants(root: u32) -> Vec<i32> {
+    let Ok(out) = tokio::process::Command::new("ps")
+        .args(["-A", "-o", "pid=,ppid="])
+        .stdin(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .output()
+        .await
+    else {
+        return Vec::new();
+    };
+    let table: Vec<(i32, i32)> = String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter_map(|line| {
+            let mut cols = line.split_whitespace().map(str::parse::<i32>);
+            Some((cols.next()?.ok()?, cols.next()?.ok()?))
+        })
+        .collect();
+    let mut found = Vec::new();
+    let mut frontier = vec![root as i32];
+    while let Some(parent) = frontier.pop() {
+        for &(pid, ppid) in &table {
+            if ppid == parent && pid > 1 && !found.contains(&pid) {
+                found.push(pid);
+                frontier.push(pid);
+            }
+        }
+    }
+    found
+}
+
+/// Terminate `pids` and the process groups they lead: SIGTERM, then SIGKILL
+/// whatever is still running after `grace`.
+#[cfg(unix)]
+pub(crate) async fn terminate_tree(pids: &[i32], grace: std::time::Duration) {
+    // A group leader's whole group (its own children included); anything
+    // else by pid.
+    let targets: Vec<i32> = pids
+        .iter()
+        .map(|&pid| {
+            // SAFETY: getpgid only inspects; a vanished pid returns -1.
+            if unsafe { libc::getpgid(pid) } == pid {
+                -pid
+            } else {
+                pid
+            }
+        })
+        .collect();
+    let alive = |target: i32| unsafe { libc::kill(target, 0) } == 0;
+    for &target in &targets {
+        crate::send_signal(&target, crate::Signal::Term);
+    }
+    let deadline = tokio::time::Instant::now() + grace;
+    while targets.iter().any(|&t| alive(t)) && tokio::time::Instant::now() < deadline {
+        tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+    }
+    for &target in &targets {
+        if alive(target) {
+            crate::send_signal(&target, crate::Signal::Kill);
+        }
+    }
+}
+
 #[cfg(all(test, unix))]
 mod tests {
     use super::*;
 
+    /// A grandchild in its own process group (how agent CLIs start shells)
+    /// survives its parent's death; the descendant snapshot still finds it
+    /// and `terminate_tree` ends it.
+    #[tokio::test]
+    async fn tree_teardown_reaches_shells_in_their_own_process_group() {
+        /// Ends the fixture shell even when an assertion fails first.
+        struct Reap(i32);
+        impl Drop for Reap {
+            fn drop(&mut self) {
+                // SAFETY: SIGKILL to the fixture's own pid.
+                unsafe { libc::kill(self.0, libc::SIGKILL) };
+            }
+        }
+        let dir = tempfile::tempdir().unwrap();
+        let ready = dir.path().join("ready");
+        // The child reports its pid only once it leads its own group: waiting
+        // for it to exist was not enough (it had not called setpgid yet).
+        let script = format!(
+            "python3 -c 'import os, time; os.setpgid(0, 0); open(\"{}\", \"w\").write(str(os.getpid())); time.sleep(60)' & sleep 60",
+            ready.display()
+        );
+        let mut parent = tokio::process::Command::new("sh")
+            .args(["-c", &script])
+            .kill_on_drop(true)
+            .spawn()
+            .unwrap();
+        let root = parent.id().unwrap();
+        let mut shell = None;
+        for _ in 0..250 {
+            if let Some(pid) = std::fs::read_to_string(&ready)
+                .ok()
+                .and_then(|s| s.trim().parse::<i32>().ok())
+            {
+                shell = Some(pid);
+                break;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+        }
+        let shell = shell.expect("the shell leads its own process group");
+        let _reap = Reap(shell);
+        assert_eq!(unsafe { libc::getpgid(shell) }, shell);
+        let tree = descendants(root).await;
+        assert!(tree.contains(&shell), "{tree:?}");
+        // The parent dies hard (an unresponsive agent's SIGKILL): the shell
+        // is orphaned, not killed.
+        parent.kill().await.unwrap();
+        assert_eq!(unsafe { libc::kill(shell, 0) }, 0, "orphan survives");
+        terminate_tree(&tree, std::time::Duration::from_secs(2)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+        assert_ne!(unsafe { libc::kill(shell, 0) }, 0, "orphan ended");
+    }
+
     #[tokio::test]
     async fn unix_launch_retains_tokio_types_and_output() {
         let mut command: tokio::process::Command = Command::new(std::env::current_exe().unwrap());
diff --git a/crates/harness/src/process/owned.rs b/crates/harness/src/process/owned.rs
index bb799a50cf..2926cf35e0 100644
--- a/crates/harness/src/process/owned.rs
+++ b/crates/harness/src/process/owned.rs
@@ -32,6 +32,14 @@ impl Child {
     }
 
     pub(crate) async fn shutdown(&mut self, grace: std::time::Duration) {
+        // Everything the agent started, taken while it is still attached:
+        // a command the agent ran in its own session (Devin does) is not in
+        // the agent's process group and would outlive the runtime.
+        #[cfg(unix)]
+        let tree = match (self.group, self.inner.id()) {
+            (Some(_), Some(pid)) => crate::process::descendants(pid).await,
+            _ => Vec::new(),
+        };
         #[cfg(unix)]
         if let Some(group) = self.group.take() {
             crate::send_signal(&group, crate::Signal::Term);
@@ -52,6 +60,8 @@ impl Child {
             }
         }
         crate::shutdown_child(&mut self.inner, grace).await;
+        #[cfg(unix)]
+        crate::process::terminate_tree(&tree, grace).await;
     }
 
     pub(crate) fn request_group_shutdown(&self) {
diff --git a/crates/harness/tests/acp.rs b/crates/harness/tests/acp.rs
index 3768f72cba..f6aa77c6f1 100644
--- a/crates/harness/tests/acp.rs
+++ b/crates/harness/tests/acp.rs
@@ -72,6 +72,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
@@ -233,6 +234,162 @@ async fn config_options_apply_requested_model_and_effort() {
     assert_eq!(dones(&events), vec![(DoneStatus::Completed, None)]);
 }
 
+/// A model switch reaches the live session: between turns before the
+/// message's prompt, and — sent mid-turn — only once the turn has ended,
+/// still ahead of its own prompt. No new agent either way.
+#[tokio::test]
+async fn a_model_switch_is_selected_on_the_live_session() {
+    let (controls, steer, _token) = controls();
+    let opening = request("scenario:reconfigure");
+    let mut fast = opening.clone();
+    fast.model = Some("grok-4-fast".into());
+    assert!(harness().reconfigures_in_place(&opening, &fast));
+    let mut stream = harness()
+        .run(opening.clone(), controls)
+        .await
+        .expect("run starts");
+    let mut texts = Vec::new();
+    let mut started = 0;
+    let mut dones = 0;
+    while dones < 3 {
+        let event = tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .expect("stream open")
+            .expect("stream event");
+        match event {
+            AgentEvent::SessionStarted { .. } => started += 1,
+            AgentEvent::TextDelta { text } => {
+                if text == "on fast" {
+                    // Mid-turn: back to the opening model.
+                    steer
+                        .send(SteerMessage {
+                            config: Some(Box::new(opening.clone())),
+                            ..SteerMessage::text("back")
+                        })
+                        .await
+                        .unwrap();
+                }
+                texts.push(text);
+            }
+            AgentEvent::Done { status, error, .. } => {
+                assert_eq!(status, DoneStatus::Completed, "{error:?}");
+                dones += 1;
+                if dones == 1 {
+                    steer
+                        .send(SteerMessage {
+                            config: Some(Box::new(fast.clone())),
+                            ..SteerMessage::text("go fast")
+                        })
+                        .await
+                        .unwrap();
+                }
+            }
+            _ => {}
+        }
+    }
+    assert_eq!(started, 1);
+    assert_eq!(texts, ["turn1", "on fast", "back on 4.5"]);
+}
+
+/// Tearing the runtime down ends everything the agent started — a command
+/// it ran in its own session included (live, Devin: it outlived quitting
+/// the app).
+#[cfg(unix)]
+#[tokio::test]
+async fn teardown_ends_a_command_the_agent_detached() {
+    let dir = tempfile::tempdir().unwrap();
+    let pidfile = dir.path().join("detached.pid");
+    let (controls, _steer, token) = controls();
+    let mut stream = harness()
+        .run(
+            request(&format!("scenario:detached {}", pidfile.display())),
+            controls,
+        )
+        .await
+        .expect("run starts");
+    loop {
+        let event = tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .expect("stream open")
+            .expect("stream event");
+        if matches!(event, AgentEvent::Done { .. }) {
+            break;
+        }
+    }
+    let pid: i32 = std::fs::read_to_string(&pidfile)
+        .unwrap()
+        .trim()
+        .parse()
+        .unwrap();
+    // SAFETY: signal 0 only probes for existence.
+    let alive = || unsafe { libc::kill(pid, 0) } == 0;
+    assert!(alive(), "the detached command runs");
+    token.cancel();
+    while tokio::time::timeout(Duration::from_secs(10), stream.next())
+        .await
+        .expect("teardown in time")
+        .is_some()
+    {}
+    let deadline = std::time::Instant::now() + Duration::from_secs(5);
+    while alive() && std::time::Instant::now() < deadline {
+        tokio::time::sleep(Duration::from_millis(50)).await;
+    }
+    assert!(!alive(), "the detached command outlived the runtime");
+}
+
+/// "Send now" while a steer's request is still in flight: the stop cancels
+/// that steer with the turn. Its late promptRequired answer must not queue
+/// it again, or the cancelled message runs after all.
+#[tokio::test]
+async fn a_turn_stop_cancels_a_steer_still_in_flight() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls();
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    let mut stream = harness()
+        .run(request("scenario:stop-steer"), controls)
+        .await
+        .expect("run starts");
+    macro_rules! next {
+        () => {
+            tokio::time::timeout(Duration::from_secs(10), stream.next())
+                .await
+                .expect("event in time")
+                .expect("stream open")
+                .expect("stream event")
+        };
+    }
+    loop {
+        if matches!(next!(), AgentEvent::TextDelta { text } if text == "working") {
+            break;
+        }
+    }
+    steer
+        .send(SteerMessage::text("cancelled steer"))
+        .await
+        .unwrap();
+    tokio::time::sleep(Duration::from_millis(200)).await;
+    turn.stop_turn();
+    loop {
+        if let AgentEvent::Done { status, .. } = next!() {
+            assert_eq!(status, DoneStatus::Interrupted);
+            break;
+        }
+    }
+    steer.send(SteerMessage::text("after")).await.unwrap();
+    let mut texts = Vec::new();
+    loop {
+        match next!() {
+            AgentEvent::TextDelta { text } => texts.push(text),
+            AgentEvent::Done { .. } => break,
+            _ => {}
+        }
+    }
+    assert_eq!(texts, ["fresh"], "the cancelled steer ran after the stop");
+}
+
 #[tokio::test]
 async fn resumed_first_class_model_is_switched_before_prompt() {
     let (controls, _steer, _token) = controls();
@@ -277,6 +434,8 @@ async fn steering_extension_injects_mid_turn() {
                     .send(SteerMessage {
                         prompt: "redirect please".into(),
                         message_id: None,
+                        attachments: Vec::new(),
+                        config: None,
                     })
                     .await
                     .expect("steer sent");
@@ -323,6 +482,8 @@ async fn steer_racing_the_turn_end_never_emits_steered_after_done() {
                     .send(SteerMessage {
                         prompt: "redirect please".into(),
                         message_id: None,
+                        attachments: Vec::new(),
+                        config: None,
                     })
                     .await
                     .expect("steer sent");
@@ -374,6 +535,8 @@ async fn rejected_steer_queues_and_delivers_at_the_turn_boundary() {
                     .send(SteerMessage {
                         prompt: "redirect please".into(),
                         message_id: None,
+                        attachments: Vec::new(),
+                        config: None,
                     })
                     .await
                     .expect("steer sent");
@@ -2010,6 +2173,8 @@ async fn acp_boundary_steer(scenario: &str, trigger_on_done: bool) {
                     .send(zeron_harness::SteerMessage {
                         prompt: "second".into(),
                         message_id: None,
+                        attachments: Vec::new(),
+                        config: None,
                     })
                     .await
                     .unwrap();
@@ -2275,3 +2440,68 @@ async fn shared_acp_skills_require_explicit_native_command_classification() {
         );
     }
 }
+
+#[tokio::test]
+async fn a_stopped_turn_keeps_the_agent_for_the_next_prompt() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls();
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    assert!(harness().stops_turn_in_place());
+    let mut stream = harness()
+        .run(request("scenario:stop-in-place"), controls)
+        .await
+        .expect("run starts");
+    async fn next_event(
+        stream: &mut futures::stream::BoxStream<'static, Result<AgentEvent, HarnessError>>,
+    ) -> Option<AgentEvent> {
+        tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .map(|r| r.expect("stream event"))
+    }
+    loop {
+        match next_event(&mut stream).await {
+            Some(AgentEvent::TextDelta { text }) if text == "working" => break,
+            Some(_) => {}
+            None => panic!("stream ended before the turn streamed"),
+        }
+    }
+    turn.stop_turn();
+    loop {
+        match next_event(&mut stream).await {
+            Some(AgentEvent::Done { status, .. }) => {
+                assert_eq!(status, DoneStatus::Interrupted);
+                break;
+            }
+            Some(_) => {}
+            None => panic!("a stopped turn must not end the agent's stream"),
+        }
+    }
+    // Sent right after the stop: our own turn's tail is not an unowned
+    // turn, so no second `session/cancel` precedes this prompt.
+    steer.send(SteerMessage::text("carry on")).await.unwrap();
+    let mut resumed = Vec::new();
+    loop {
+        match next_event(&mut stream).await {
+            Some(done @ AgentEvent::Done { .. }) => {
+                resumed.push(done);
+                break;
+            }
+            Some(event) => resumed.push(event),
+            None => panic!("stream ended before the next turn finished"),
+        }
+    }
+    assert!(resumed.contains(&AgentEvent::TextDelta {
+        text: "resumed".into()
+    }));
+    assert!(matches!(
+        resumed.last(),
+        Some(AgentEvent::Done {
+            status: DoneStatus::Completed,
+            ..
+        })
+    ));
+    drop(steer);
+    assert!(next_event(&mut stream).await.is_none());
+}
diff --git a/crates/harness/tests/acp_quiet.rs b/crates/harness/tests/acp_quiet.rs
index 1793dbe652..c5def1f42d 100644
--- a/crates/harness/tests/acp_quiet.rs
+++ b/crates/harness/tests/acp_quiet.rs
@@ -76,6 +76,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
@@ -159,6 +160,8 @@ async fn delayed_turn(scenario: &str) {
         .send(SteerMessage {
             message_id: None,
             prompt: "second".into(),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
@@ -166,6 +169,8 @@ async fn delayed_turn(scenario: &str) {
         .send(SteerMessage {
             message_id: None,
             prompt: "third".into(),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
@@ -208,6 +213,8 @@ async fn delayed_turn(scenario: &str) {
         .send(SteerMessage {
             message_id: None,
             prompt: "fourth".into(),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
@@ -272,6 +279,8 @@ async fn cancel_quiet(scenario: &str) {
         .send(SteerMessage {
             message_id: None,
             prompt: "must not run".into(),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
diff --git a/crates/harness/tests/acp_stall.rs b/crates/harness/tests/acp_stall.rs
index 463cc2698a..783b314c71 100644
--- a/crates/harness/tests/acp_stall.rs
+++ b/crates/harness/tests/acp_stall.rs
@@ -46,6 +46,7 @@ async fn silent_agent_errors_via_the_prompt_stall_watchdog() {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
diff --git a/crates/harness/tests/claude.rs b/crates/harness/tests/claude.rs
index 8809cea04a..7fb98a1bbc 100644
--- a/crates/harness/tests/claude.rs
+++ b/crates/harness/tests/claude.rs
@@ -76,6 +76,7 @@ fn controls(
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
@@ -309,6 +310,7 @@ async fn ask_user_question_round_trips_through_the_control_channel() {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     let events = run_to_end(&harness(), request("scenario:askuser"), controls).await;
 
@@ -380,6 +382,8 @@ async fn ultrathink_preserves_selected_commands_on_initial_and_steered_sends() {
                 .send(SteerMessage {
                     prompt,
                     message_id: None,
+                    attachments: Vec::new(),
+                    config: None,
                 })
                 .await
                 .unwrap();
@@ -403,6 +407,8 @@ async fn steering_lines_are_written_to_stdin_mid_run() {
         .send(SteerMessage {
             prompt: "redirect please".into(),
             message_id: None,
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .expect("steer queued");
@@ -868,6 +874,8 @@ async fn a_replay_confirms_superseded_steers_and_the_turn_ends() {
             .send(SteerMessage {
                 prompt: prompt.into(),
                 message_id: None,
+                attachments: Vec::new(),
+                config: None,
             })
             .await
             .expect("steer queued");
@@ -900,6 +908,399 @@ async fn a_replay_confirms_superseded_steers_and_the_turn_ends() {
     ));
 }
 
+fn steer_msg(prompt: &str) -> SteerMessage {
+    SteerMessage {
+        prompt: prompt.into(),
+        message_id: None,
+        attachments: Vec::new(),
+        config: None,
+    }
+}
+
+/// The premature-"done" bug: a `now` steer aborts the streaming turn, whose
+/// result was held for the steer — and released by a 5s quiet timer while
+/// the steered turn ran a long tool. The engine read that stale Done as the
+/// steered turn completing (sound, notification, parked mid-turn).
+#[tokio::test]
+async fn a_steered_turn_running_a_long_tool_is_not_marked_done() {
+    let (controls, steer, _token) = controls("A");
+    steer.send(steer_msg("stop and sleep")).await.unwrap();
+    let stream = harness()
+        .run(request("scenario:lifecycle-now-steer"), controls)
+        .await
+        .expect("run starts");
+    let events = tokio::time::timeout(
+        Duration::from_secs(20),
+        stream.map(|r| r.expect("event")).collect::<Vec<_>>(),
+    )
+    .await
+    .expect("run ends");
+    let dones: Vec<_> = events
+        .iter()
+        .filter(|e| matches!(e, AgentEvent::Done { .. }))
+        .collect();
+    assert_eq!(
+        dones.len(),
+        1,
+        "exactly the steered turn's own end: {events:?}"
+    );
+    let done_at = events
+        .iter()
+        .position(|e| matches!(e, AgentEvent::Done { .. }))
+        .unwrap();
+    let tool_result_at = events
+        .iter()
+        .position(|e| matches!(e, AgentEvent::ToolResult { id, .. } if id == "tool-sleep"))
+        .expect("tool result");
+    assert!(
+        done_at > tool_result_at,
+        "Done before the tool finished: {events:?}"
+    );
+    assert!(matches!(
+        dones[0],
+        AgentEvent::Done {
+            status: DoneStatus::Completed,
+            ..
+        }
+    ));
+    assert_eq!(
+        events
+            .iter()
+            .filter(|e| matches!(e, AgentEvent::Steered { .. }))
+            .count(),
+        1
+    );
+}
+
+/// A message queued behind a turn that just finished: that turn's result is
+/// a boundary; the run's one Done is the queued message's own.
+#[tokio::test]
+async fn a_message_queued_behind_a_finishing_turn_owns_the_turn_end() {
+    let (controls, steer, _token) = controls("A");
+    steer.send(steer_msg("follow up")).await.unwrap();
+    let events = run_to_end(
+        &harness(),
+        request("scenario:lifecycle-queued-behind-end"),
+        controls,
+    )
+    .await;
+    let dones = events
+        .iter()
+        .filter(|e| matches!(e, AgentEvent::Done { .. }))
+        .count();
+    assert_eq!(dones, 1, "{events:?}");
+    let steered_at = events
+        .iter()
+        .position(|e| matches!(e, AgentEvent::Steered { .. }))
+        .expect("steered");
+    let second_at = events
+        .iter()
+        .position(|e| matches!(e, AgentEvent::TextDelta { text } if text == "second answer"))
+        .expect("second answer");
+    assert!(steered_at < second_at);
+    assert!(matches!(events.last(), Some(AgentEvent::Done { .. })));
+}
+
+/// "Send now" while a turn end is held for a queued steer: the stop's one
+/// Done waits for the stop to settle, so the replacement prompt — sent the
+/// moment that Done arrives — runs to its own end, never settled by the
+/// stopped turn's late result.
+#[tokio::test]
+async fn send_now_over_a_held_turn_end_never_settles_the_replacement() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls("A");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    let mut stream = harness()
+        .run(request("scenario:stop-held"), controls)
+        .await
+        .expect("run starts");
+    steer.send(steer_msg("queued steer")).await.unwrap();
+    macro_rules! next {
+        () => {
+            tokio::time::timeout(Duration::from_secs(10), stream.next())
+                .await
+                .expect("event in time")
+                .expect("stream open")
+                .expect("stream event")
+        };
+    }
+    loop {
+        if matches!(next!(), AgentEvent::TextDelta { text } if text == "first answer") {
+            break;
+        }
+    }
+    // Let the result be held behind the queued steer, then stop.
+    tokio::time::sleep(Duration::from_millis(200)).await;
+    turn.stop_turn();
+    let stopped = loop {
+        if let done @ AgentEvent::Done { .. } = next!() {
+            break done;
+        }
+    };
+    assert!(
+        matches!(
+            stopped,
+            AgentEvent::Done {
+                status: DoneStatus::Interrupted,
+                ..
+            }
+        ),
+        "{stopped:?}"
+    );
+    // The replacement goes out the moment the stop settles.
+    steer.send(steer_msg("replacement")).await.unwrap();
+    let mut after = Vec::new();
+    let end = loop {
+        match next!() {
+            done @ AgentEvent::Done { .. } => break done,
+            event => after.push(event),
+        }
+    };
+    assert!(
+        after.contains(&AgentEvent::TextDelta {
+            text: "replacement".into()
+        }),
+        "the replacement turn was settled before its reply: {after:?} then {end:?}"
+    );
+    assert!(
+        matches!(
+            end,
+            AgentEvent::Done {
+                status: DoneStatus::Completed,
+                ..
+            }
+        ),
+        "{end:?}"
+    );
+}
+
+/// After a stop, a replacement that answers within the stop's settle window
+/// from a CLI that confirms nothing (no lifecycle, no replay) still ends: its
+/// result is reconciled like any unconfirmed steer's, never dropped as the
+/// stopped turn reporting late (which left the chat Working).
+#[tokio::test]
+async fn a_quick_unconfirmed_replacement_after_a_stop_still_completes() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls("A");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    let mut stream = harness()
+        .run(request("scenario:stop-unconfirmed-replacement"), controls)
+        .await
+        .expect("run starts");
+    macro_rules! next {
+        () => {
+            tokio::time::timeout(Duration::from_secs(15), stream.next())
+                .await
+                .expect("event in time")
+                .expect("stream open")
+                .expect("stream event")
+        };
+    }
+    loop {
+        if matches!(next!(), AgentEvent::TextDelta { text } if text == "working") {
+            break;
+        }
+    }
+    turn.stop_turn();
+    loop {
+        if let AgentEvent::Done { status, .. } = next!() {
+            assert_eq!(status, DoneStatus::Interrupted);
+            break;
+        }
+    }
+    steer.send(steer_msg("replacement")).await.unwrap();
+    let mut after = Vec::new();
+    let end = loop {
+        match next!() {
+            done @ AgentEvent::Done { .. } => break done,
+            event => after.push(event),
+        }
+    };
+    assert!(
+        after.contains(&AgentEvent::TextDelta {
+            text: "new reply".into()
+        }),
+        "{after:?}"
+    );
+    assert!(
+        matches!(
+            end,
+            AgentEvent::Done {
+                status: DoneStatus::Completed,
+                ..
+            }
+        ),
+        "{end:?}"
+    );
+}
+
+/// A stopped turn reporting a second, delayed result — no new prompt, no
+/// new content — is dropped whole: no second Done (an Errored one failed
+/// the parked session), and none of its usage.
+#[tokio::test]
+async fn a_stopped_turns_delayed_duplicate_result_is_dropped() {
+    use zeron_harness::TurnControl;
+    let (mut controls, _steer, _token) = controls("A");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    let mut stream = harness()
+        .run(request("scenario:stop-late-duplicate"), controls)
+        .await
+        .expect("run starts");
+    loop {
+        let event = tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .expect("stream open")
+            .expect("stream event");
+        if matches!(event, AgentEvent::TextDelta { text } if text == "working") {
+            break;
+        }
+    }
+    turn.stop_turn();
+    loop {
+        let event = tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .expect("stream open")
+            .expect("stream event");
+        if let AgentEvent::Done { status, .. } = event {
+            assert_eq!(status, DoneStatus::Interrupted);
+            break;
+        }
+    }
+    let mut after = Vec::new();
+    let quiet = tokio::time::timeout(Duration::from_secs(2), async {
+        while let Some(event) = stream.next().await {
+            after.push(event.expect("stream event"));
+        }
+    })
+    .await;
+    assert!(quiet.is_err(), "the stream ended: {after:?}");
+    assert!(
+        !after
+            .iter()
+            .any(|e| matches!(e, AgentEvent::Done { .. } | AgentEvent::Usage { .. })),
+        "the stopped turn's late duplicate was forwarded: {after:?}"
+    );
+}
+
+/// A queued message the CLI cancels before starting releases the held turn
+/// end at once, from the lifecycle frame — not after a quiet timer.
+#[tokio::test]
+async fn a_cancelled_queued_message_releases_the_turn_end_immediately() {
+    let (controls, steer, _token) = controls("A");
+    steer.send(steer_msg("never started")).await.unwrap();
+    let started = std::time::Instant::now();
+    let mut stream = harness()
+        .run(request("scenario:lifecycle-queued-cancelled"), controls)
+        .await
+        .expect("run starts");
+    let status = tokio::time::timeout(Duration::from_secs(10), async {
+        while let Some(event) = stream.next().await {
+            if let AgentEvent::Done { status, .. } = event.expect("event") {
+                return status;
+            }
+        }
+        panic!("stream ended without Done");
+    })
+    .await
+    .expect("released");
+    assert_eq!(status, DoneStatus::Completed);
+    assert!(
+        started.elapsed() < Duration::from_secs(3),
+        "{:?}",
+        started.elapsed()
+    );
+}
+
+/// A follow-up sent with another model/effort is adopted by the live process
+/// instead of replacing it (which killed its background agents and shells).
+#[tokio::test]
+async fn a_changed_model_and_effort_apply_to_the_live_process() {
+    use zeron_proto::ReasoningLevel;
+    assert!(harness().reconfigures_in_place(&request("a"), &{
+        let mut next = request("b");
+        next.model = Some("claude-haiku-4-5".into());
+        next
+    }));
+    let mut cwd_moved = request("b");
+    cwd_moved.cwd = "/elsewhere".into();
+    assert!(!harness().reconfigures_in_place(&request("a"), &cwd_moved));
+
+    let (controls, steer, _token) = controls("A");
+    let mut launch = request("scenario:reconfigure");
+    launch.model = Some("claude-sonnet-5-5".into());
+    launch.reasoning = Some(ReasoningLevel::Low);
+    launch
+        .model_options
+        .insert("fastMode".into(), serde_json::json!(true));
+    let mut next = launch.clone();
+    next.model = Some("claude-haiku-4-5".into());
+    next.reasoning = Some(ReasoningLevel::High);
+    next.model_options.clear();
+    let mut switched = steer_msg("switched");
+    switched.config = Some(Box::new(next.clone()));
+    steer.send(switched).await.unwrap();
+    let mut same = steer_msg("same again");
+    same.config = None;
+    steer.send(same).await.unwrap();
+    drop(steer);
+    let events = run_to_end(&harness(), launch, controls).await;
+    assert!(
+        events.contains(&AgentEvent::TextDelta {
+            text: "on haiku".into()
+        }),
+        "{events:?}"
+    );
+    assert!(
+        matches!(
+            events.last(),
+            Some(AgentEvent::Done {
+                status: DoneStatus::Completed,
+                ..
+            })
+        ),
+        "{events:?}"
+    );
+}
+
+/// "Marked done the moment I sent it": resuming a session whose background
+/// tasks died with its old process, the CLI settles them with empty results
+/// while the new prompt is still queued. Those are not the prompt's end.
+#[tokio::test]
+async fn results_settling_killed_tasks_on_resume_do_not_end_the_prompt() {
+    let (controls, _steer, _token) = controls("A");
+    let events = run_to_end(
+        &harness(),
+        request("Reply PONG scenario:resume-killed-tasks"),
+        controls,
+    )
+    .await;
+    let dones: Vec<_> = events
+        .iter()
+        .filter(|e| matches!(e, AgentEvent::Done { .. }))
+        .collect();
+    assert_eq!(dones.len(), 1, "{events:?}");
+    assert!(
+        matches!(dones[0], AgentEvent::Done { status: DoneStatus::Completed, result: Some(r), .. } if r == "PONG"),
+        "{events:?}"
+    );
+    let pong = events
+        .iter()
+        .position(|e| matches!(e, AgentEvent::TextDelta { text } if text == "PONG"))
+        .expect("reply");
+    assert!(
+        events
+            .iter()
+            .position(|e| matches!(e, AgentEvent::Done { .. }))
+            .unwrap()
+            > pong
+    );
+}
+
 /// A steer the CLI never replays must not hold the turn end forever.
 #[tokio::test]
 async fn an_unreplayed_steer_releases_the_turn_end() {
@@ -908,6 +1309,8 @@ async fn an_unreplayed_steer_releases_the_turn_end() {
         .send(SteerMessage {
             prompt: "absorbed steer".into(),
             message_id: None,
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .expect("steer queued");
@@ -933,3 +1336,124 @@ async fn an_unreplayed_steer_releases_the_turn_end() {
     assert_eq!(steered, 1);
     assert!(started.elapsed() >= std::time::Duration::from_secs(4));
 }
+
+// ---------------------------------------------------------------------------
+// Stopping a turn in place
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn a_stopped_turn_keeps_the_process_and_its_background_work() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls("A");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    assert!(harness().stops_turn_in_place());
+    let mut stream = harness()
+        .run(request("scenario:stop-in-place"), controls)
+        .await
+        .expect("run starts");
+    async fn next_event(
+        stream: &mut futures::stream::BoxStream<'static, Result<AgentEvent, HarnessError>>,
+    ) -> Option<AgentEvent> {
+        tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .map(|r| r.expect("stream event"))
+    }
+    loop {
+        match next_event(&mut stream).await {
+            Some(AgentEvent::TextDelta { text }) if text == "working" => break,
+            Some(_) => {}
+            None => panic!("stream ended before the turn streamed"),
+        }
+    }
+    assert!(
+        turn.background_live(),
+        "background_tasks_changed must report the live task"
+    );
+
+    turn.stop_turn();
+    let stopped = loop {
+        match next_event(&mut stream).await {
+            Some(done @ AgentEvent::Done { .. }) => break done,
+            Some(_) => {}
+            None => panic!("a stopped turn must not end the process's stream"),
+        }
+    };
+    assert!(
+        matches!(
+            stopped,
+            AgentEvent::Done {
+                status: DoneStatus::Interrupted,
+                error: None,
+                ..
+            }
+        ),
+        "{stopped:?}"
+    );
+    assert!(
+        turn.background_live(),
+        "the stop spared the background task"
+    );
+
+    // The same process takes the next prompt — with its image inlined.
+    let dir = tempfile::tempdir().unwrap();
+    let image = dir.path().join("shot.png");
+    std::fs::write(&image, b"\x89PNG\r\n\x1a\nfake").unwrap();
+    steer
+        .send(SteerMessage {
+            prompt: "carry on".into(),
+            message_id: None,
+            attachments: vec![image.to_string_lossy().into_owned()],
+            config: None,
+        })
+        .await
+        .unwrap();
+    let mut resumed = Vec::new();
+    loop {
+        match next_event(&mut stream).await {
+            Some(done @ AgentEvent::Done { .. }) => {
+                resumed.push(done);
+                break;
+            }
+            Some(event) => resumed.push(event),
+            None => panic!("stream ended before the next turn finished"),
+        }
+    }
+    assert!(
+        resumed.contains(&AgentEvent::TextDelta {
+            text: "resumed:image=yes".into()
+        }),
+        "{resumed:?}"
+    );
+    assert!(
+        resumed
+            .iter()
+            .any(|e| matches!(e, AgentEvent::Steered { .. }))
+    );
+    assert!(matches!(
+        resumed.last(),
+        Some(AgentEvent::Done {
+            status: DoneStatus::Completed,
+            ..
+        })
+    ));
+    assert!(!turn.background_live());
+
+    // A stop that lands between turns still settles: the CLI answers and no
+    // result follows, so the driver reports the (empty) turn stopped.
+    turn.stop_turn();
+    assert!(matches!(
+        next_event(&mut stream).await,
+        Some(AgentEvent::Done {
+            status: DoneStatus::Interrupted,
+            ..
+        })
+    ));
+
+    drop(steer);
+    assert!(
+        next_event(&mut stream).await.is_none(),
+        "closing the mailbox ends the run"
+    );
+}
diff --git a/crates/harness/tests/codex.rs b/crates/harness/tests/codex.rs
index 8fc09a6d3d..afd08c46c4 100644
--- a/crates/harness/tests/codex.rs
+++ b/crates/harness/tests/codex.rs
@@ -131,6 +131,7 @@ fn controls(
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
@@ -361,6 +362,8 @@ async fn steering_uses_turn_steer_with_expected_turn_id() {
         .send(SteerMessage {
             prompt: "redirect please".into(),
             message_id: None,
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .expect("steer queued");
@@ -397,6 +400,148 @@ async fn steering_uses_turn_steer_with_expected_turn_id() {
     );
 }
 
+/// An accepted steer joins the turn when its userMessage item lands, after
+/// the reply streaming ahead of it — `Steered` must split there, not at the
+/// `turn/steer` response (which moved the old reply's tail below the steer).
+#[tokio::test]
+async fn a_steer_splits_the_reply_where_its_message_joins_the_turn() {
+    let (controls, steer, _token) = controls("Yes");
+    steer
+        .send(SteerMessage::text("redirect please"))
+        .await
+        .expect("steer queued");
+    let events = run_to_end(&harness(), request("scenario:steer-item"), controls).await;
+    let at = |pred: &dyn Fn(&AgentEvent) -> bool| {
+        events
+            .iter()
+            .position(pred)
+            .unwrap_or_else(|| panic!("missing event: {events:?}"))
+    };
+    let still_first =
+        at(&|e| matches!(e, AgentEvent::TextDelta { text } if text == "-still-first"));
+    let steered = at(&|e| matches!(e, AgentEvent::Steered { .. }));
+    let reply = at(&|e| matches!(e, AgentEvent::TextDelta { text } if text == "steered"));
+    assert!(still_first < steered && steered < reply, "{events:?}");
+    assert_eq!(
+        events
+            .iter()
+            .filter(|e| matches!(e, AgentEvent::Steered { .. }))
+            .count(),
+        1
+    );
+    assert!(matches!(
+        events.last(),
+        Some(AgentEvent::Done {
+            status: DoneStatus::Completed,
+            ..
+        })
+    ));
+}
+
+/// Only the turn in flight settles: a stale or duplicate `turn/completed`
+/// marked the running turn done mid-way (sound, notification, park).
+#[tokio::test]
+async fn a_stale_turn_completion_never_settles_the_running_turn() {
+    let (controls, _steer, _token) = controls("Yes");
+    let events = run_to_end(&harness(), request("scenario:stale-completion"), controls).await;
+    let dones: Vec<_> = events
+        .iter()
+        .enumerate()
+        .filter(|(_, e)| matches!(e, AgentEvent::Done { .. }))
+        .collect();
+    assert_eq!(dones.len(), 1, "{events:?}");
+    let after = events
+        .iter()
+        .position(|e| matches!(e, AgentEvent::TextDelta { text } if text == "after"))
+        .expect("after");
+    assert!(dones[0].0 > after, "{events:?}");
+}
+
+/// A stop issued before the app-server announces the turn waits for
+/// `turn/started`: an earlier `turn/interrupt` is rejected, the turn runs to
+/// its end, and the host's fallback tore the whole runtime down.
+#[tokio::test]
+async fn a_stop_before_the_turn_is_announced_still_interrupts_it() {
+    use zeron_harness::TurnControl;
+    let (mut controls, _steer, _token) = controls("Yes");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    let mut stream = harness()
+        .run(request("scenario:stop-before-announce"), controls)
+        .await
+        .expect("run starts");
+    let status = tokio::time::timeout(std::time::Duration::from_secs(10), async {
+        while let Some(event) = stream.next().await {
+            match event.expect("event") {
+                AgentEvent::TextDelta { text } if text == "working" => turn.stop_turn(),
+                AgentEvent::Done { status, .. } => return status,
+                _ => {}
+            }
+        }
+        panic!("stream ended without Done");
+    })
+    .await
+    .expect("stopped turn settles");
+    assert_eq!(status, DoneStatus::Interrupted);
+}
+
+/// A command still running after its turn (a dev server) holds the parked
+/// runtime against the idle reaper; an interrupted turn's killed foreground
+/// command — which never gets an `item/completed` — does not.
+#[tokio::test]
+async fn open_commands_report_background_work_and_killed_ones_do_not() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls("Yes");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    let mut stream = harness()
+        .run(request("scenario:background-commands"), controls)
+        .await
+        .expect("run starts");
+    async fn until_done(
+        stream: &mut futures::stream::BoxStream<'static, Result<AgentEvent, HarnessError>>,
+        mut on: impl FnMut(&AgentEvent),
+    ) -> DoneStatus {
+        tokio::time::timeout(Duration::from_secs(10), async {
+            while let Some(event) = stream.next().await {
+                let event = event.expect("event");
+                on(&event);
+                if let AgentEvent::Done { status, .. } = event {
+                    return status;
+                }
+            }
+            panic!("stream ended without Done");
+        })
+        .await
+        .expect("turn ends")
+    }
+    assert_eq!(until_done(&mut stream, |_| {}).await, DoneStatus::Completed);
+    assert!(turn.background_live(), "the dev server outlives its turn");
+
+    steer
+        .send(SteerMessage::text("run the tests"))
+        .await
+        .unwrap();
+    let stop = turn.clone();
+    let status = until_done(&mut stream, |e| {
+        if matches!(e, AgentEvent::TextDelta { text } if text == "running") {
+            stop.stop_turn();
+        }
+    })
+    .await;
+    assert_eq!(status, DoneStatus::Interrupted);
+    // The killed foreground command's process is gone once the grace passes.
+    tokio::time::sleep(Duration::from_millis(3500)).await;
+    assert!(turn.background_live(), "the dev server still runs");
+
+    steer
+        .send(SteerMessage::text("stop the server"))
+        .await
+        .unwrap();
+    assert_eq!(until_done(&mut stream, |_| {}).await, DoneStatus::Completed);
+    assert!(!turn.background_live(), "nothing left running");
+}
+
 #[tokio::test]
 async fn rejected_steer_falls_back_to_a_follow_up_turn() {
     let (controls, steer, _token) = controls("Yes");
@@ -412,6 +557,8 @@ async fn rejected_steer_falls_back_to_a_follow_up_turn() {
                 .link()
             ),
             message_id: None,
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .expect("steer queued");
@@ -478,6 +625,7 @@ async fn approvals_round_trip_as_input_requests() {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     let mut req = request("scenario:approve");
     req.auto_approve = false;
@@ -1053,6 +1201,8 @@ async fn live_subagent_spawn_and_followup_keep_one_transcript() {
             steer.send(SteerMessage {
                 prompt: "Reuse the SAME existing subagent for one more task: reply exactly child-second. Use followup_task if available, otherwise send_input. Do not spawn a new agent. Wait for it to finish, then reply exactly parent-second. Do not inspect or change files.".into(),
                 message_id: None,
+                attachments: Vec::new(),
+                config: None,
             }).await.unwrap();
         }
         if turn == 2 {
@@ -1460,6 +1610,8 @@ async fn native_command_during_a_turn_waits_for_its_boundary() {
                         .send(SteerMessage {
                             prompt: "/review".into(),
                             message_id: None,
+                            attachments: Vec::new(),
+                            config: None,
                         })
                         .await
                         .unwrap();
@@ -1495,6 +1647,8 @@ async fn native_skill_and_file_references_survive_initial_and_steered_turns() {
         .send(SteerMessage {
             prompt: harness_prompt(&format!("Also {}", followup.link()), HarnessId::Codex),
             message_id: Some("skill-steer".into()),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
@@ -1544,6 +1698,8 @@ async fn ordinary_followup_cannot_overtake_a_queued_native_command() {
                             .send(SteerMessage {
                                 prompt: prompt.into(),
                                 message_id: None,
+                                attachments: Vec::new(),
+                                config: None,
                             })
                             .await
                             .unwrap();
@@ -1575,6 +1731,131 @@ async fn ordinary_followup_cannot_overtake_a_queued_native_command() {
     );
 }
 
+#[tokio::test]
+async fn a_model_change_sent_mid_turn_takes_effect_in_its_own_turn() {
+    let (controls, steer, _token) = controls("Yes");
+    let mut stream = harness()
+        .run(request("scenario:reconfigure"), controls)
+        .await
+        .expect("run starts");
+    let mut events = Vec::new();
+    loop {
+        let event = tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .expect("stream open")
+            .expect("stream event");
+        let working = event
+            == AgentEvent::TextDelta {
+                text: "working".into(),
+            };
+        events.push(event);
+        if working {
+            break;
+        }
+    }
+    let mut model_b = request("");
+    model_b.model = Some("model-b".into());
+    model_b.reasoning = Some(ReasoningLevel::Low);
+    for (text, config) in [
+        ("to-b", Some(model_b)),
+        ("back-to-a", Some(request(""))),
+        ("plain", None),
+    ] {
+        steer
+            .send(SteerMessage {
+                config: config.map(Box::new),
+                ..SteerMessage::text(text)
+            })
+            .await
+            .unwrap();
+    }
+    let mut completed = 0;
+    while completed < 4 {
+        let event = tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .expect("stream open")
+            .expect("stream event");
+        if let AgentEvent::Done { status, error, .. } = &event {
+            assert_eq!(*status, DoneStatus::Completed, "{error:?}");
+            completed += 1;
+        }
+        events.push(event);
+    }
+    let texts: Vec<&str> = events
+        .iter()
+        .filter_map(|e| match e {
+            AgentEvent::TextDelta { text } => Some(text.as_str()),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(texts, ["working", "to-b", "back-to-a", "plain"]);
+}
+
+#[tokio::test]
+async fn a_stopped_turn_keeps_the_app_server_for_the_next_prompt() {
+    use zeron_harness::TurnControl;
+    let (mut controls, steer, _token) = controls("Yes");
+    let turn = TurnControl::default();
+    controls.turn = turn.clone();
+    assert!(harness().stops_turn_in_place());
+    let mut stream = harness()
+        .run(request("scenario:stop-in-place"), controls)
+        .await
+        .expect("run starts");
+    async fn next_event(
+        stream: &mut futures::stream::BoxStream<'static, Result<AgentEvent, HarnessError>>,
+    ) -> Option<AgentEvent> {
+        tokio::time::timeout(Duration::from_secs(10), stream.next())
+            .await
+            .expect("event in time")
+            .map(|r| r.expect("stream event"))
+    }
+    loop {
+        match next_event(&mut stream).await {
+            Some(AgentEvent::TextDelta { text }) if text == "working" => break,
+            Some(_) => {}
+            None => panic!("stream ended before the turn streamed"),
+        }
+    }
+    turn.stop_turn();
+    loop {
+        match next_event(&mut stream).await {
+            Some(AgentEvent::Done { status, .. }) => {
+                assert_eq!(status, DoneStatus::Interrupted);
+                break;
+            }
+            Some(_) => {}
+            None => panic!("a stopped turn must not end the app-server's stream"),
+        }
+    }
+    steer.send(SteerMessage::text("carry on")).await.unwrap();
+    let mut resumed = Vec::new();
+    loop {
+        match next_event(&mut stream).await {
+            Some(done @ AgentEvent::Done { .. }) => {
+                resumed.push(done);
+                break;
+            }
+            Some(event) => resumed.push(event),
+            None => panic!("stream ended before the next turn finished"),
+        }
+    }
+    assert!(resumed.contains(&AgentEvent::TextDelta {
+        text: "resumed".into()
+    }));
+    assert!(matches!(
+        resumed.last(),
+        Some(AgentEvent::Done {
+            status: DoneStatus::Completed,
+            ..
+        })
+    ));
+    drop(steer);
+    assert!(next_event(&mut stream).await.is_none());
+}
+
 #[tokio::test]
 async fn idle_voice_runtime_has_no_initial_turn_and_preserves_mcp() {
     let dir = tempfile::tempdir().unwrap();
@@ -1623,10 +1904,7 @@ async fn idle_voice_runtime_has_no_initial_turn_and_preserves_mcp() {
     assert!(!calls.contains("thread/realtime/start"));
     assert!(calls.contains("mcp_servers"));
     steer
-        .send(SteerMessage {
-            prompt: "text remains usable".into(),
-            message_id: None,
-        })
+        .send(SteerMessage::text("text remains usable"))
         .await
         .unwrap();
     tokio::time::timeout(Duration::from_secs(3), async {
diff --git a/crates/harness/tests/cursor.rs b/crates/harness/tests/cursor.rs
index 3f8c115f7c..75a0394f9a 100644
--- a/crates/harness/tests/cursor.rs
+++ b/crates/harness/tests/cursor.rs
@@ -59,6 +59,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
@@ -188,6 +189,8 @@ async fn steer_after_done_becomes_the_next_turn() {
                         .send(SteerMessage {
                             prompt: "follow up".into(),
                             message_id: None,
+                            attachments: Vec::new(),
+                            config: None,
                         })
                         .await
                         .expect("steer sent");
@@ -339,6 +342,8 @@ async fn followup_crash_is_not_hidden_by_a_previous_completed_turn() {
                         .send(SteerMessage {
                             prompt: "follow up".into(),
                             message_id: None,
+                            attachments: Vec::new(),
+                            config: None,
                         })
                         .await
                         .unwrap();
@@ -394,6 +399,8 @@ async fn steering_spam_preserves_every_turn_in_order_and_closes_cleanly() {
                     .send(SteerMessage {
                         prompt: format!("ITEM-{n}"),
                         message_id: None,
+                        attachments: Vec::new(),
+                        config: None,
                     })
                     .await
                     .unwrap();
@@ -461,6 +468,8 @@ async fn cancelling_a_native_steering_burst_stops_without_starting_another_turn(
                 .send(SteerMessage {
                     prompt: format!("LIVE-STEER-{n}"),
                     message_id: None,
+                    attachments: Vec::new(),
+                    config: None,
                 })
                 .await
                 .unwrap();
diff --git a/crates/harness/tests/cursor_shim.rs b/crates/harness/tests/cursor_shim.rs
index 45c4dba36b..e136dfdb60 100644
--- a/crates/harness/tests/cursor_shim.rs
+++ b/crates/harness/tests/cursor_shim.rs
@@ -778,3 +778,63 @@ async fn steer_during_text_preempts_the_run_and_continues_immediately() {
     assert_eq!(prompts.lines().count(), 2, "{prompts}");
     assert!(prompts.lines().last().unwrap().contains("preempt-me"));
 }
+
+/// A model switch runs from its own message's send on the live agent: the
+/// messages sent before it never ride the new model, and those after it do.
+#[tokio::test]
+async fn a_model_switch_names_its_model_from_its_own_send_on() {
+    use tokio::io::AsyncWriteExt;
+    let fixture = SessionFixture::new();
+    let (mut child, mut stdin, mut lines) = fixture.start("first", false).await;
+    while frame(&mut lines).await["ev"] != "turn" {}
+    stdin
+        .write_all(
+            concat!(
+                "{\"op\":\"steer\",\"prompt\":\"plain-before\"}\n",
+                "{\"op\":\"steer\",\"prompt\":\"on-two\",\"reconfigure\":true,\"model\":\"m-2\",\"modelOptions\":{}}\n",
+                "{\"op\":\"steer\",\"prompt\":\"after\"}\n",
+            )
+            .as_bytes(),
+        )
+        .await
+        .unwrap();
+    let mut steered = 0;
+    loop {
+        let frame = frame(&mut lines).await;
+        if frame["ev"] == "steered" {
+            steered += 1;
+        }
+        if frame["ev"] == "turn" && steered == 3 {
+            break;
+        }
+    }
+    finish(&mut child, stdin).await;
+    let store =
+        std::fs::read_to_string(fixture.dir.path().join("state/by-agent/agent-fixture")).unwrap();
+    let dir = std::path::Path::new(store.trim());
+    let prompts = std::fs::read_to_string(dir.join("prompts.ndjson")).unwrap();
+    let models = std::fs::read_to_string(dir.join("models.ndjson")).unwrap_or_default();
+    let named: Vec<serde_json::Value> = models
+        .lines()
+        .map(|line| serde_json::from_str(line).unwrap())
+        .collect();
+    assert!(named.iter().all(|send| send["model"] == "m-2"), "{models}");
+    assert!(
+        named
+            .iter()
+            .any(|send| send["prompt"].as_str().unwrap().contains("on-two")),
+        "the switching message ran on its model: {models}"
+    );
+    assert!(
+        named
+            .iter()
+            .all(|send| !send["prompt"].as_str().unwrap().contains("plain-before")),
+        "an earlier message rode the new model: {models}"
+    );
+    assert!(
+        prompts
+            .lines()
+            .any(|p| p.contains("plain-before") && !p.contains("on-two")),
+        "an earlier message was merged into the switch: {prompts}"
+    );
+}
diff --git a/crates/harness/tests/fixtures/fake-acp.sh b/crates/harness/tests/fixtures/fake-acp.sh
index 7aa10108cb..339a079446 100755
--- a/crates/harness/tests/fixtures/fake-acp.sh
+++ b/crates/harness/tests/fixtures/fake-acp.sh
@@ -200,6 +200,51 @@ case "$promptline" in
   emit "{\"id\":$pid,\"result\":{\"stopReason\":\"end_turn\"}}"
   ;;
 
+*scenario:detached*)
+  # A command the agent starts in its own session (Devin does): not in the
+  # agent's process group, so a group kill alone leaves it running.
+  pidfile=$(printf '%s' "$promptline" | sed 's/.*scenario:detached \([^ "]*\).*/\1/')
+  python3 -c "import os,time; os.setsid(); open('$pidfile','w').write(str(os.getpid())); time.sleep(60)" &
+  while [ ! -s "$pidfile" ]; do sleep 0.05; done
+  update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"started"}}'
+  emit "{\"id\":$pid,\"result\":{\"stopReason\":\"end_turn\"}}"
+  cat >/dev/null
+  ;;
+
+*scenario:reconfigure*)
+  # Model switches: one sent between turns, one sent mid-turn. Each set must
+  # reach the session before the prompt it was sent with.
+  next_turn() { # reads 0..n sets then the prompt; leaves them in SETS / pid
+    SETS=""
+    read -r promptline || exit 1
+    while has "$promptline" '"method":"session/set_config_option"'; do
+      emit "{\"id\":$(rid "$promptline"),\"result\":{}}"
+      SETS="$SETS $promptline"
+      read -r promptline || exit 1
+    done
+    has "$promptline" '"method":"session/prompt"' || exit 1
+    pid=$(rid "$promptline")
+  }
+  update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"turn1"}}'
+  emit "{\"id\":$pid,\"result\":{\"stopReason\":\"end_turn\"}}"
+  next_turn
+  if has "$SETS" '"value":"grok-4-fast"'; then
+    update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"on fast"}}'
+  else
+    update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"switch missing"}}'
+  fi
+  sleep 0.5
+  emit "{\"id\":$pid,\"result\":{\"stopReason\":\"end_turn\"}}"
+  next_turn
+  if has "$SETS" '"value":"grok-4.5"'; then
+    update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"back on 4.5"}}'
+  else
+    update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"switch missing"}}'
+  fi
+  emit "{\"id\":$pid,\"result\":{\"stopReason\":\"end_turn\"}}"
+  cat >/dev/null
+  ;;
+
 *scenario:happy*)
   update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"Hello"}}'
   update '{"sessionUpdate":"agent_thought_chunk","content":{"type":"text","text":"thinking"}}'
@@ -268,6 +313,32 @@ case "$promptline" in
   fi
   ;;
 
+*scenario:stop-steer*)
+  # "Send now" with a steer still in flight: the steering request is
+  # unanswered when the turn stop's session/cancel arrives, and answers
+  # promptRequired before the cancelled prompt settles. The cancelled steer
+  # must never run.
+  update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"working"}}'
+  read -r steerline || exit 1
+  has "$steerline" '"method":"_session/steering"' || exit 1
+  sid=$(rid "$steerline")
+  read -r cancel || exit 1
+  has "$cancel" '"method":"session/cancel"' || exit 1
+  emit "{\"id\":$sid,\"result\":{\"outcome\":\"promptRequired\"}}"
+  sleep 0.2
+  emit "{\"id\":$pid,\"result\":{\"stopReason\":\"cancelled\"}}"
+  read -r next || exit 1
+  has "$next" '"method":"session/prompt"' || exit 1
+  nid=$(rid "$next")
+  if has "$next" 'cancelled steer'; then
+    update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"REPLAYED"}}'
+  else
+    update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"fresh"}}'
+  fi
+  emit "{\"id\":$nid,\"result\":{\"stopReason\":\"end_turn\"}}"
+  cat >/dev/null
+  ;;
+
 *scenario:steer-race*)
   update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"first"}}'
   read -r steerline || exit 1
@@ -410,6 +481,20 @@ case "$promptline" in
   fi
   ;;
 
+*scenario:stop-in-place*)
+  # A turn stop: session/cancel settles the prompt `cancelled`; the agent
+  # and its session take the next session/prompt.
+  update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"working"}}'
+  read -r intline || exit 1
+  has "$intline" '"method":"session/cancel"' || exit 8
+  emit "{\"id\":$pid,\"result\":{\"stopReason\":\"cancelled\"}}"
+  read -r nextline || exit 1
+  has "$nextline" '"method":"session/prompt"' || exit 9
+  update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"resumed"}}'
+  emit "{\"id\":$(rid "$nextline"),\"result\":{\"stopReason\":\"end_turn\"}}"
+  cat >/dev/null
+  ;;
+
 *scenario:wedge*)
   update '{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"working"}}'
   # Ignore session/cancel entirely — forces the SIGTERM escalation path.
diff --git a/crates/harness/tests/fixtures/fake-claude.sh b/crates/harness/tests/fixtures/fake-claude.sh
index 940e013e60..b2655a4b12 100755
--- a/crates/harness/tests/fixtures/fake-claude.sh
+++ b/crates/harness/tests/fixtures/fake-claude.sh
@@ -8,8 +8,23 @@
 # crates/harness/tests/claude.rs.
 
 read -r first || exit 1
+# A run opens with an `initialize` control request (the SDK handshake); the
+# real CLI answers it before the first user line. (Command discovery sends
+# its own initialize as the only line — matched by its scenario below.)
+initialized=false
+while :; do
+  case "$first" in
+    *'"request_id":"zeron_initialize"'*)
+      case "$first" in *'"perTaskStopAffordance":true'*) initialized=true ;; esac
+      printf '%s\n' '{"type":"control_response","response":{"subtype":"success","request_id":"zeron_initialize","response":{}}}'
+      read -r first || exit 1
+      ;;
+    *) break ;;
+  esac
+done
 
 emit() { printf '%s\n' "$1"; }
+uuid_of() { printf '%s\n' "$1" | sed 's/.*"uuid":"\([^"]*\)".*/\1/'; }
 
 case "$first" in
 
@@ -127,6 +142,184 @@ case "$first" in
   emit '{"type":"result","subtype":"success","result":"steered","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-steer"}'
   ;;
 
+*scenario:lifecycle-now-steer*)
+  # CLI 2.1.286, captured live: every uuid-tagged user line gets
+  # `command_lifecycle` frames. A `now` steer aborts the streaming turn
+  # (result, terminal_reason aborted_streaming), the first command is
+  # cancelled and the steer's own turn starts. That turn then runs a tool
+  # for longer than any quiet-time heuristic: no Done may land before the
+  # steered turn's own result.
+  fid=$(uuid_of "$first")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"queued\"}"
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"started\"}"
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":["Bash"],"cwd":"/tmp","session_id":"sess-lc"}'
+  emit "$first"
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"essay"}}}'
+  read -r steer || exit 1
+  case "$steer" in *'"priority":"now"'*) ;; *) exit 9 ;; esac
+  sid=$(uuid_of "$steer")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"queued\"}"
+  emit '{"type":"result","subtype":"success","is_error":false,"terminal_reason":"aborted_streaming","result":"essay","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-lc"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"cancelled\"}"
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"started\"}"
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":["Bash"],"cwd":"/tmp","session_id":"sess-lc"}'
+  emit "$steer"
+  emit '{"type":"assistant","parent_tool_use_id":null,"message":{"content":[{"type":"tool_use","id":"tool-sleep","name":"Bash","input":{"command":"sleep 8"}}]}}'
+  sleep "${FAKE_CLAUDE_TOOL_SECS:-6}"
+  emit '{"type":"user","parent_tool_use_id":null,"message":{"content":[{"type":"tool_result","tool_use_id":"tool-sleep","is_error":false}]}}'
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"DONE"}}}'
+  emit '{"type":"result","subtype":"success","is_error":false,"terminal_reason":"completed","result":"DONE","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-lc"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"completed\"}"
+  ;;
+
+*scenario:lifecycle-queued-behind-end*)
+  # A message that reaches the CLI as its turn is finishing waits for that
+  # turn's result, then starts its own turn: the first result is a
+  # boundary, and the run's only Done is the queued message's.
+  fid=$(uuid_of "$first")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"started\"}"
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-q"}'
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"first answer"}}}'
+  read -r steer || exit 1
+  sid=$(uuid_of "$steer")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"queued\"}"
+  emit '{"type":"result","subtype":"success","is_error":false,"terminal_reason":"completed","result":"first answer","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-q"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"completed\"}"
+  sleep 1
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"started\"}"
+  emit "$steer"
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"second answer"}}}'
+  emit '{"type":"result","subtype":"success","is_error":false,"terminal_reason":"completed","result":"second answer","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-q"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"completed\"}"
+  ;;
+
+*scenario:stop-held*)
+  # "Send now" while a turn's result is held for a queued steer: the CLI is
+  # slow to answer the stop, had already begun the steer's turn, and that
+  # turn's aborted result lands after the stop — before the replacement.
+  fid=$(uuid_of "$first")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"started\"}"
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-sh"}'
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"first answer"}}}'
+  read -r steer || exit 1
+  sid=$(uuid_of "$steer")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"queued\"}"
+  emit '{"type":"result","subtype":"success","is_error":false,"result":"first answer","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-sh"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"completed\"}"
+  read -r stop || exit 1
+  case "$stop" in *'"subtype":"interrupt"'*) ;; *) exit 8 ;; esac
+  rid=$(printf '%s\n' "$stop" | sed 's/.*"request_id":"\([^"]*\)".*/\1/')
+  sleep 0.5
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"started\"}"
+  emit "{\"type\":\"control_response\",\"response\":{\"subtype\":\"success\",\"request_id\":\"$rid\",\"response\":{\"still_queued\":[]}}}"
+  emit '{"type":"result","subtype":"error_during_execution","errors":["[ede_diagnostic] result_type=user last_content_type=n/a stop_reason=tool_use"],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-sh"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"cancelled\"}"
+  read -r next || exit 1
+  nid=$(uuid_of "$next")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$nid\",\"state\":\"started\"}"
+  emit "$next"
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"replacement"}}}'
+  sleep 0.3
+  emit '{"type":"result","subtype":"success","is_error":false,"result":"replacement","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-sh"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$nid\",\"state\":\"completed\"}"
+  cat >/dev/null
+  ;;
+
+*scenario:stop-unconfirmed-replacement*)
+  # A CLI that confirms nothing (no command_lifecycle, no replays): a turn is
+  # stopped, and the replacement answers within the stop's settle window.
+  # Its result is its own end, not the stopped turn reporting late.
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-su"}'
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"working"}}}'
+  read -r stop || exit 1
+  case "$stop" in *'"subtype":"interrupt"'*) ;; *) exit 8 ;; esac
+  rid=$(printf '%s\n' "$stop" | sed 's/.*"request_id":"\([^"]*\)".*/\1/')
+  emit "{\"type\":\"control_response\",\"response\":{\"subtype\":\"success\",\"request_id\":\"$rid\",\"response\":{\"still_queued\":[]}}}"
+  emit '{"type":"result","subtype":"error_during_execution","errors":["[ede_diagnostic] result_type=user last_content_type=n/a stop_reason=tool_use"],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-su"}'
+  read -r next || exit 1
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"new reply"}}}'
+  emit '{"type":"result","subtype":"success","is_error":false,"result":"new reply","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-su"}'
+  cat >/dev/null
+  ;;
+
+*scenario:stop-late-duplicate*)
+  # The stopped turn reports a second, delayed result after its stop has
+  # settled, with no new prompt and no new content.
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-ld"}'
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"working"}}}'
+  read -r stop || exit 1
+  case "$stop" in *'"subtype":"interrupt"'*) ;; *) exit 8 ;; esac
+  rid=$(printf '%s\n' "$stop" | sed 's/.*"request_id":"\([^"]*\)".*/\1/')
+  emit "{\"type\":\"control_response\",\"response\":{\"subtype\":\"success\",\"request_id\":\"$rid\",\"response\":{\"still_queued\":[]}}}"
+  emit '{"type":"result","subtype":"error_during_execution","errors":["[ede_diagnostic] result_type=user last_content_type=n/a stop_reason=tool_use"],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-ld"}'
+  sleep 0.5
+  emit '{"type":"result","subtype":"error_during_execution","errors":["late duplicate"],"usage":{"input_tokens":7,"output_tokens":7},"session_id":"sess-ld"}'
+  cat >/dev/null
+  ;;
+
+*scenario:lifecycle-queued-cancelled*)
+  # A queued message cancelled before any turn takes it up: the result held
+  # for it was the turn's real end, released at once — no quiet timer.
+  fid=$(uuid_of "$first")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"started\"}"
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-qc"}'
+  read -r steer || exit 1
+  sid=$(uuid_of "$steer")
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"queued\"}"
+  emit '{"type":"result","subtype":"success","is_error":false,"result":"only","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-qc"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"completed\"}"
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$sid\",\"state\":\"cancelled\"}"
+  exec sleep 30
+  ;;
+
+*scenario:reconfigure*)
+  # A follow-up sent with another model and effort: the live process
+  # adopts them (`set_model`, then `apply_flag_settings`) before the prompt
+  # — the CLI reads stdin in order. Live-verified on 2.1.286.
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-rc"}'
+  emit '{"type":"result","subtype":"success","result":"first","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-rc"}'
+  read -r model || exit 1
+  case "$model" in *'"subtype":"set_model"'*) ;; *) exit 11 ;; esac
+  case "$model" in *'"model":"claude-haiku-4-5"'*) ;; *) exit 11 ;; esac
+  read -r flags || exit 1
+  case "$flags" in *'"subtype":"apply_flag_settings"'*) ;; *) exit 12 ;; esac
+  case "$flags" in *'"effortLevel":"high"'*) ;; *) exit 13 ;; esac
+  case "$flags" in *'"fastMode":null'*) ;; *) exit 14 ;; esac
+  read -r prompt || exit 1
+  case "$prompt" in *'"type":"user"'*) ;; *) exit 15 ;; esac
+  case "$prompt" in *'switched'*) ;; *) exit 15 ;; esac
+  emit '{"type":"system","subtype":"init","model":"claude-haiku-4-5","tools":[],"cwd":"/tmp","session_id":"sess-rc"}'
+  emit "$prompt"
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"on haiku"}}}'
+  emit '{"type":"result","subtype":"success","result":"on haiku","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-rc"}'
+  # An unchanged configuration sends no control request at all.
+  read -r again || exit 1
+  case "$again" in *'"type":"user"'*) ;; *) exit 16 ;; esac
+  case "$again" in *'same again'*) ;; *) exit 16 ;; esac
+  emit "$again"
+  emit '{"type":"result","subtype":"success","result":"same","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-rc"}'
+  ;;
+
+*scenario:resume-killed-tasks*)
+  # Captured live on 2.1.286: `--resume` of a session whose background tasks
+  # died with its previous process. The CLI settles them with two empty
+  # `result` frames (num_turns 0) while the new prompt is still queued —
+  # they are not that prompt's end.
+  fid=$(uuid_of "$first")
+  emit '{"type":"system","subtype":"task_notification","task_id":"a-1","status":"stopped"}'
+  emit '{"type":"system","subtype":"task_notification","task_id":"b-1","status":"stopped"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"queued\"}"
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-rk"}'
+  emit '{"type":"result","subtype":"success","is_error":false,"num_turns":0,"result":"","errors":[],"usage":{"input_tokens":0,"output_tokens":0},"session_id":"sess-rk"}'
+  emit '{"type":"system","subtype":"init","model":"claude-sonnet-5-5","tools":[],"cwd":"/tmp","session_id":"sess-rk"}'
+  emit '{"type":"result","subtype":"success","is_error":false,"num_turns":0,"result":"","errors":[],"usage":{"input_tokens":0,"output_tokens":0},"session_id":"sess-rk"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"started\"}"
+  emit "$first"
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"PONG"}}}'
+  emit '{"type":"result","subtype":"success","is_error":false,"num_turns":1,"terminal_reason":"completed","result":"PONG","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-rk"}'
+  emit "{\"type\":\"command_lifecycle\",\"command_uuid\":\"$fid\",\"state\":\"completed\"}"
+  ;;
+
 *scenario:superseded-steers*)
   # CLI 2.1.280 with rapid `now` steers: the second interrupts the turn the
   # first started before it is replayed; only the last steer is replayed.
@@ -152,6 +345,37 @@ case "$first" in
   exec sleep 30
   ;;
 
+*scenario:stop-in-place*)
+  # A turn stop is the `interrupt` control request with `cancel_queued`: the
+  # CLI ends the turn (an error_during_execution result carrying only its
+  # diagnostic) and keeps reading stdin. Background tasks survive because the
+  # run declared perTaskStopAffordance (live-verified 2.1.285).
+  [ "$initialized" = true ] || exit 7
+  emit '{"type":"system","subtype":"init","model":"claude-fable-5","tools":["Bash"],"cwd":"/tmp","session_id":"sess-stop"}'
+  emit '{"type":"system","subtype":"background_tasks_changed","tasks":[{"task_id":"bg-1","task_type":"local_agent","description":"scout"}]}'
+  emit '{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"working"}}}'
+  read -r stop || exit 1
+  case "$stop" in *'"subtype":"interrupt"'*) ;; *) exit 8 ;; esac
+  case "$stop" in *'"cancel_queued":true'*) ;; *) exit 8 ;; esac
+  rid=$(printf '%s\n' "$stop" | sed 's/.*"request_id":"\([^"]*\)".*/\1/')
+  emit "{\"type\":\"control_response\",\"response\":{\"subtype\":\"success\",\"request_id\":\"$rid\",\"response\":{\"still_queued\":[]}}}"
+  emit '{"type":"user","message":{"role":"user","content":[{"type":"text","text":"[Request interrupted by user]"}]},"parent_tool_use_id":null}'
+  emit '{"type":"result","subtype":"error_during_execution","errors":["[ede_diagnostic] result_type=user last_content_type=n/a stop_reason=tool_use"],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-stop"}'
+  # Same process, next turn.
+  read -r next || exit 1
+  case "$next" in *'"type":"image"'*) img=yes ;; *) img=no ;; esac
+  emit "$next"
+  emit "{\"type\":\"stream_event\",\"parent_tool_use_id\":null,\"event\":{\"type\":\"content_block_delta\",\"delta\":{\"type\":\"text_delta\",\"text\":\"resumed:image=$img\"}}}"
+  emit '{"type":"system","subtype":"background_tasks_changed","tasks":[]}'
+  emit '{"type":"result","subtype":"success","result":"resumed","errors":[],"usage":{"input_tokens":1,"output_tokens":1},"session_id":"sess-stop"}'
+  # A stop between turns: answered, and no result follows.
+  read -r idle_stop || exit 1
+  case "$idle_stop" in *'"subtype":"interrupt"'*) ;; *) exit 9 ;; esac
+  rid=$(printf '%s\n' "$idle_stop" | sed 's/.*"request_id":"\([^"]*\)".*/\1/')
+  emit "{\"type\":\"control_response\",\"response\":{\"subtype\":\"success\",\"request_id\":\"$rid\",\"response\":{\"still_queued\":[]}}}"
+  cat >/dev/null
+  ;;
+
 *scenario:interrupt*)
   emit '{"type":"system","subtype":"init","model":"claude-fable-5","tools":[],"cwd":"/tmp","session_id":"sess-int"}'
   # Wedge without reading stdin — forces the SIGTERM escalation path.
diff --git a/crates/harness/tests/fixtures/fake-codex.sh b/crates/harness/tests/fixtures/fake-codex.sh
index 212ee253a3..62ea04a48e 100755
--- a/crates/harness/tests/fixtures/fake-codex.sh
+++ b/crates/harness/tests/fixtures/fake-codex.sh
@@ -289,6 +289,81 @@ case "$turnline" in
   ;;
 
 # NOTE: steer-race before steer — `case` takes the first matching glob.
+*scenario:steer-item*)
+  # Live shape (0.159.3): an accepted turn/steer joins the turn only when
+  # the reply streaming ahead of it finishes — its userMessage item carries
+  # the clientUserMessageId it was sent with as `clientId`.
+  emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
+  emit '{"method":"turn/started","params":{"threadId":"th-1","turn":{"id":"t-1"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m1","delta":"first"}}'
+  read -r steerline || exit 1
+  has "$steerline" '"method":"turn/steer"' || exit 8
+  cid=$(printf '%s' "$steerline" | sed 's/.*"clientUserMessageId":"\([^"]*\)".*/\1/')
+  [ -n "$cid" ] && [ "$cid" != "$steerline" ] || exit 8
+  emit "{\"id\":$(rid "$steerline"),\"result\":{\"turnId\":\"t-1\"}}"
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m1","delta":"-still-first"}}'
+  emit '{"method":"item/completed","params":{"threadId":"th-1","item":{"type":"agentMessage","id":"m1","text":"first-still-first"}}}'
+  emit "{\"method\":\"item/started\",\"params\":{\"threadId\":\"th-1\",\"item\":{\"type\":\"userMessage\",\"id\":\"u2\",\"clientId\":\"$cid\",\"content\":[{\"type\":\"text\",\"text\":\"redirect please\"}]}}}"
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m2","delta":"steered"}}'
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-1","status":"completed"}}}'
+  ;;
+
+*scenario:stale-completion*)
+  # A completion for a turn other than the one in flight must not settle it.
+  emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
+  emit '{"method":"turn/started","params":{"threadId":"th-1","turn":{"id":"t-1"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m1","delta":"before"}}'
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-zombie","status":"completed"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m1","delta":"after"}}'
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-1","status":"completed"}}}'
+  # A duplicate of the settled turn's completion is stale too.
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-1","status":"completed"}}}'
+  ;;
+
+*scenario:stop-before-announce*)
+  # The turn/start response lands before the app-server registers the turn:
+  # an interrupt now is rejected ("no active turn to interrupt", live
+  # 0.159.3). The stop must wait for turn/started.
+  emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m1","delta":"working"}}'
+  if read -t 1 early; then
+    has "$early" '"method":"turn/interrupt"' &&
+      emit "{\"id\":$(rid "$early"),\"error\":{\"code\":-32600,\"message\":\"no active turn to interrupt\"}}"
+    exec sleep 30
+  fi
+  emit '{"method":"turn/started","params":{"threadId":"th-1","turn":{"id":"t-1"}}}'
+  read -r intline || exit 1
+  has "$intline" '"method":"turn/interrupt"' && has "$intline" '"turnId":"t-1"' || exit 9
+  emit "{\"id\":$(rid "$intline"),\"result\":{}}"
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-1","status":"interrupted"}}}'
+  cat >/dev/null
+  ;;
+
+*scenario:background-commands*)
+  # A command still running after its turn is background work; an
+  # interrupted turn's foreground command is killed without item/completed
+  # (live, 0.159.3) and must not pin the runtime once its process is gone.
+  emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
+  emit '{"method":"turn/started","params":{"threadId":"th-1","turn":{"id":"t-1"}}}'
+  emit "{\"method\":\"item/started\",\"params\":{\"threadId\":\"th-1\",\"item\":{\"type\":\"commandExecution\",\"id\":\"bg\",\"command\":\"npm run dev\",\"processId\":\"$$\",\"status\":\"inProgress\"}}}"
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-1","status":"completed"}}}'
+  read -r next || exit 1
+  emit "{\"id\":$(rid "$next"),\"result\":{\"turn\":{\"id\":\"t-2\"}}}"
+  emit '{"method":"turn/started","params":{"threadId":"th-1","turn":{"id":"t-2"}}}'
+  emit '{"method":"item/started","params":{"threadId":"th-1","item":{"type":"commandExecution","id":"fg","command":"sleep 60","processId":"999999","status":"inProgress"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"threadId":"th-1","itemId":"m2","delta":"running"}}'
+  read -r intline || exit 1
+  has "$intline" '"method":"turn/interrupt"' || exit 9
+  emit "{\"id\":$(rid "$intline"),\"result\":{}}"
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-2","status":"interrupted"}}}'
+  read -r last || exit 1
+  emit "{\"id\":$(rid "$last"),\"result\":{\"turn\":{\"id\":\"t-3\"}}}"
+  emit '{"method":"turn/started","params":{"threadId":"th-1","turn":{"id":"t-3"}}}'
+  emit '{"method":"item/completed","params":{"threadId":"th-1","item":{"type":"commandExecution","id":"bg","status":"completed"}}}'
+  emit '{"method":"turn/completed","params":{"threadId":"th-1","turn":{"id":"t-3","status":"completed"}}}'
+  cat >/dev/null
+  ;;
+
 *scenario:steer-race*)
   emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
   emit '{"method":"turn/started","params":{"turn":{"id":"t-1"}}}'
@@ -380,6 +455,53 @@ case "$turnline" in
   fi
   ;;
 
+*scenario:stop-in-place*)
+  # A turn stop: turn/interrupt ends the turn, the app-server stays up, and
+  # the next prompt is a turn/start on the same thread.
+  emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
+  emit '{"method":"turn/started","params":{"turn":{"id":"t-1"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"itemId":"m1","delta":"working"}}'
+  read -r intline || exit 1
+  iid=$(rid "$intline")
+  has "$intline" '"method":"turn/interrupt"' && has "$intline" '"turnId":"t-1"' || exit 8
+  emit "{\"id\":$iid,\"result\":{}}"
+  emit '{"method":"turn/completed","params":{"turn":{"id":"t-1","status":"interrupted"}}}'
+  read -r nextline || exit 1
+  has "$nextline" '"method":"turn/start"' && has "$nextline" '"threadId":"th-1"' || exit 9
+  emit "{\"id\":$(rid "$nextline"),\"result\":{\"turn\":{\"id\":\"t-2\"}}}"
+  emit '{"method":"turn/started","params":{"turn":{"id":"t-2"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"itemId":"m2","delta":"resumed"}}'
+  emit '{"method":"turn/completed","params":{"turn":{"id":"t-2","status":"completed"}}}'
+  cat >/dev/null
+  ;;
+
+*scenario:reconfigure*)
+  # Model changes sent mid-turn (A -> B -> A, then a plain follow-up): none
+  # may ride turn/steer, which carries no model. Each starts its own turn
+  # with the configuration it was sent with.
+  emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
+  emit '{"method":"turn/started","params":{"turn":{"id":"t-1"}}}'
+  emit '{"method":"item/agentMessage/delta","params":{"itemId":"m1","delta":"working"}}'
+  sleep 0.5
+  emit '{"method":"turn/completed","params":{"turn":{"id":"t-1","status":"completed"}}}'
+  n=2
+  for want in 'to-b|"model":"model-b"|"effort":"low"' \
+    'back-to-a|"model":"gpt-5.6-sol"|"effort":"ultra"' \
+    'plain|"model":"gpt-5.6-sol"|"effort":"ultra"'; do
+    read -r next || exit 1
+    text=${want%%|*}; rest=${want#*|}; model=${rest%%|*}; effort=${rest#*|}
+    { has "$next" '"method":"turn/start"' && has "$next" "\"text\":\"$text\"" \
+      && has "$next" "$model" && has "$next" "$effort"; } \
+      || { fail_turn "$(rid "$next")" "turn $n: wanted $text with $model $effort"; exit 0; }
+    emit "{\"id\":$(rid "$next"),\"result\":{\"turn\":{\"id\":\"t-$n\"}}}"
+    emit "{\"method\":\"turn/started\",\"params\":{\"turn\":{\"id\":\"t-$n\"}}}"
+    emit "{\"method\":\"item/agentMessage/delta\",\"params\":{\"itemId\":\"m$n\",\"delta\":\"$text\"}}"
+    emit "{\"method\":\"turn/completed\",\"params\":{\"turn\":{\"id\":\"t-$n\",\"status\":\"completed\"}}}"
+    n=$((n + 1))
+  done
+  cat >/dev/null
+  ;;
+
 *scenario:wedge*)
   emit "{\"id\":$tid,\"result\":{\"turn\":{\"id\":\"t-1\"}}}"
   emit '{"method":"turn/started","params":{"turn":{"id":"t-1"}}}'
diff --git a/crates/harness/tests/fixtures/fake-cursor-sdk.mjs b/crates/harness/tests/fixtures/fake-cursor-sdk.mjs
index 77ddb8517c..47be3f16b5 100644
--- a/crates/harness/tests/fixtures/fake-cursor-sdk.mjs
+++ b/crates/harness/tests/fixtures/fake-cursor-sdk.mjs
@@ -18,6 +18,8 @@ export class JsonlLocalAgentStore {
       return fs.existsSync(log)?fs.readFileSync(log,'utf8').trim().split('\n').filter(Boolean).map(JSON.parse).filter(p=>!isUncheckpointed(p)):[];
     };
     this.logPrompt=(prompt)=>fs.appendFileSync(path.join(dir,'prompts.ndjson'),JSON.stringify(prompt)+'\n');
+    // Sends that named a model (a model switch on the live agent).
+    this.logModel=(prompt,model)=>fs.appendFileSync(path.join(dir,'models.ndjson'),JSON.stringify({prompt,model})+'\n');
     this.agents={
       get:async()=>read().agent,
       create:async({agent})=>{const data=read();data.agent=agent;write(data);return agent;},
@@ -35,8 +37,9 @@ const checkpoint={schemaVersion:1,rootBlobId:'retained-conversation-history'};
 function instance(store) {
   return {
     agentId:'agent-fixture',model:{id:'composer-2.5'},close(){},
-    async send(prompt,{onDelta}) {
+    async send(prompt,{onDelta,model}) {
       store.logPrompt(prompt);
+      if(model) store.logModel(prompt,model.id);
       const doc=await store.agents.get({});
       if(doc.activeRunId) throw new Error('Agent already has active run');
       const runId='run-'+Date.now();
diff --git a/crates/harness/tests/fixtures/pi_rpc.rs b/crates/harness/tests/fixtures/pi_rpc.rs
index 1380e946a9..1f7d151cd8 100644
--- a/crates/harness/tests/fixtures/pi_rpc.rs
+++ b/crates/harness/tests/fixtures/pi_rpc.rs
@@ -79,7 +79,7 @@ fn main() {
             ),
             "get_available_models" => response(
                 &v,
-                json!({"models":[{"id":"mock","provider":"mock","name":"Mock","reasoning":true,"contextWindow":128000}]}),
+                json!({"models":[{"id":"mock","provider":"mock","name":"Mock","reasoning":true,"contextWindow":128000},{"id":"mock-2","provider":"mock","name":"Mock 2","reasoning":true,"contextWindow":128000}]}),
             ),
             "get_available_thinking_levels" => {
                 response(&v, json!({"levels":["off","low","medium","high"]}))
@@ -107,6 +107,9 @@ fn main() {
                 if text == "env" {
                     text = format!("env:{}", std::env::var_os("CLAUDECODE").is_some());
                 }
+                if text == "which-model" {
+                    text = format!("{model}/{thinking}");
+                }
                 if text == "reject" {
                     emit(
                         json!({"type":"response","id":v["id"],"command":"prompt","success":false,"error":"preflight rejected"}),
diff --git a/crates/harness/tests/managed_install.rs b/crates/harness/tests/managed_install.rs
index 81f75e3614..93ff178267 100644
--- a/crates/harness/tests/managed_install.rs
+++ b/crates/harness/tests/managed_install.rs
@@ -34,6 +34,7 @@ async fn managed_install_reaches_session_started() {
         request_input: Box::new(|_| tokio::sync::oneshot::channel().1),
         steering,
         interrupt: interrupt.clone(),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
diff --git a/crates/harness/tests/managed_install_failure.rs b/crates/harness/tests/managed_install_failure.rs
index 9bc7fce875..aa2dda590c 100644
--- a/crates/harness/tests/managed_install_failure.rs
+++ b/crates/harness/tests/managed_install_failure.rs
@@ -43,6 +43,7 @@ async fn silent_npm_enoent_death_surfaces_decoded_error() {
         request_input: Box::new(|_| tokio::sync::oneshot::channel().1),
         steering,
         interrupt: CancellationToken::new(),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
diff --git a/crates/harness/tests/opencode.rs b/crates/harness/tests/opencode.rs
index 6631c64758..d4059c2bc3 100644
--- a/crates/harness/tests/opencode.rs
+++ b/crates/harness/tests/opencode.rs
@@ -43,6 +43,8 @@ struct FakeOpencode {
     /// Leading 500s to answer `POST /session` with (the opencode
     /// lazy-migration crash class: first access 500s, retry succeeds).
     fail_session_creates: Arc<Mutex<u32>>,
+    /// Answer `POST …/abort` with a 500 (a wedged server).
+    fail_aborts: Arc<Mutex<bool>>,
 }
 
 impl FakeOpencode {
@@ -62,6 +64,7 @@ impl FakeOpencode {
             )),
             first_prompt_had_subscriber: Arc::new(Mutex::new(None)),
             fail_session_creates: Arc::new(Mutex::new(0)),
+            fail_aborts: Arc::new(Mutex::new(false)),
         };
         let accept = fake.clone();
         tokio::spawn(async move {
@@ -239,6 +242,10 @@ impl FakeOpencode {
             ("GET", "/session/ses_resume") => ("200 OK", json!({ "id": "ses_resume" })),
             ("GET", p) if p.starts_with("/session/") => ("404 Not Found", json!({})),
             ("POST", p) if p.ends_with("/prompt_async") => ("204 No Content", json!({})),
+            ("POST", p) if p.ends_with("/abort") && *self.fail_aborts.lock().unwrap() => (
+                "500 Internal Server Error",
+                json!({ "name": "UnknownError", "data": { "message": "abort failed" } }),
+            ),
             ("POST", p) if p.ends_with("/abort") => ("200 OK", json!(true)),
             ("POST", p) if p.contains("/permission/") || p.contains("/question/") => {
                 ("200 OK", json!(true))
@@ -290,6 +297,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
         }),
         steering,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
@@ -569,6 +577,8 @@ async fn steer_queues_mid_turn_and_delivers_at_idle() {
         .send(SteerMessage {
             prompt: "also do this".into(),
             message_id: None,
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
@@ -623,6 +633,273 @@ async fn interrupt_aborts_and_settles_interrupted() {
     ));
 }
 
+/// Start a run on `driver` with a turn stop wired in, and wait until its
+/// first turn streams.
+async fn stoppable_turn(
+    fake: &FakeOpencode,
+    driver: OpencodeHarness,
+) -> (
+    futures::stream::BoxStream<'static, Result<AgentEvent, HarnessError>>,
+    mpsc::Sender<SteerMessage>,
+    zeron_harness::TurnControl,
+) {
+    let (mut controls, steer, _token) = controls();
+    let turn = zeron_harness::TurnControl::default();
+    controls.turn = turn.clone();
+    assert!(driver.stops_turn_in_place());
+    let mut stream = driver
+        .run(request("hi"), controls)
+        .await
+        .expect("run starts");
+    let _ = next_event(&mut stream).await;
+    let _ = next_event(&mut stream).await;
+    assistant_message(fake, "ses_test", "msg_1");
+    fake.emit(json!({
+        "type": "message.part.updated",
+        "properties": { "part": {
+            "id": "prt_t", "messageID": "msg_1", "sessionID": "ses_test",
+            "type": "text", "text": "working",
+        }},
+    }));
+    assert_eq!(
+        next_event(&mut stream).await,
+        AgentEvent::TextDelta {
+            text: "working".into()
+        }
+    );
+    (stream, steer, turn)
+}
+
+/// A stop the server never acknowledged must not leave the session taking
+/// prompts: the turn may still be running. The runtime goes, its mailbox
+/// closed before the stop reads settled.
+async fn assert_torn_down(
+    stream: &mut futures::stream::BoxStream<'static, Result<AgentEvent, HarnessError>>,
+    steer: &mpsc::Sender<SteerMessage>,
+) {
+    let events = drain_to_done(stream).await;
+    assert!(
+        matches!(
+            events.last(),
+            Some(AgentEvent::Done {
+                status: DoneStatus::Interrupted,
+                error: None,
+                ..
+            })
+        ),
+        "{events:?}"
+    );
+    assert!(
+        steer.is_closed(),
+        "the mailbox closes before the stop settles"
+    );
+    let end = tokio::time::timeout(Duration::from_secs(5), stream.next())
+        .await
+        .expect("stream ends");
+    assert!(end.is_none(), "the runtime is gone: {end:?}");
+}
+
+#[tokio::test]
+async fn a_stop_the_server_rejects_tears_the_runtime_down() {
+    let fake = FakeOpencode::start().await;
+    *fake.fail_aborts.lock().unwrap() = true;
+    let (mut stream, steer, turn) = stoppable_turn(&fake, harness(&fake)).await;
+    turn.stop_turn();
+    wait_posts(&fake, "/session/ses_test/abort", 1).await;
+    assert_torn_down(&mut stream, &steer).await;
+}
+
+#[tokio::test]
+async fn a_stop_the_server_never_settles_tears_the_runtime_down() {
+    let fake = FakeOpencode::start().await;
+    let driver = harness(&fake).with_graces(Duration::from_millis(200), Duration::from_millis(100));
+    let (mut stream, steer, turn) = stoppable_turn(&fake, driver).await;
+    turn.stop_turn();
+    wait_posts(&fake, "/session/ses_test/abort", 1).await;
+    // Accepted, but no idle ever follows.
+    assert_torn_down(&mut stream, &steer).await;
+}
+
+#[tokio::test]
+async fn an_acknowledged_stop_drops_late_output_and_keeps_the_session() {
+    let fake = FakeOpencode::start().await;
+    let (mut stream, steer, turn) = stoppable_turn(&fake, harness(&fake)).await;
+    turn.stop_turn();
+    wait_posts(&fake, "/session/ses_test/abort", 1).await;
+    // The stopped turn's output still in flight when the abort landed.
+    fake.emit(json!({
+        "type": "message.part.updated",
+        "properties": { "part": {
+            "id": "prt_late", "messageID": "msg_1", "sessionID": "ses_test",
+            "type": "text", "text": "late",
+        }},
+    }));
+    idle(&fake, "ses_test");
+    let events = drain_to_done(&mut stream).await;
+    assert_eq!(
+        events,
+        vec![AgentEvent::Done {
+            status: DoneStatus::Interrupted,
+            result: None,
+            error: None,
+            session_id: Some("ses_test".into()),
+        }],
+        "the stopped turn's late output is dropped"
+    );
+
+    // The same session takes the next prompt.
+    steer
+        .send(SteerMessage::text("carry on"))
+        .await
+        .expect("the mailbox stays open");
+    let prompts = wait_posts(&fake, "/session/ses_test/prompt_async", 2).await;
+    assert_eq!(prompts[1]["parts"][0]["text"], "carry on");
+    assistant_message(&fake, "ses_test", "msg_2");
+    idle(&fake, "ses_test");
+    let events = drain_to_done(&mut stream).await;
+    assert!(matches!(
+        events.last(),
+        Some(AgentEvent::Done {
+            status: DoneStatus::Completed,
+            ..
+        })
+    ));
+}
+
+#[tokio::test]
+async fn images_sent_mid_turn_ride_the_queued_prompt() {
+    let fake = FakeOpencode::start().await;
+    let (controls, steer, _token) = controls();
+    let mut stream = harness(&fake)
+        .run(request("hi"), controls)
+        .await
+        .expect("run starts");
+    let _ = next_event(&mut stream).await;
+    let _ = next_event(&mut stream).await;
+    assistant_message(&fake, "ses_test", "msg_1");
+    // A running tool holds the steers for the turn's end (no preempt).
+    fake.emit(json!({
+        "type": "message.part.updated",
+        "properties": { "part": {
+            "id": "prt_tool", "messageID": "msg_1", "sessionID": "ses_test",
+            "type": "tool", "tool": "bash", "callID": "call_1",
+            "state": { "status": "running", "input": { "command": "sleep 1" } },
+        }},
+    }));
+    let _ = next_event(&mut stream).await; // ToolStarted
+    for (text, image) in [("first", "/tmp/one.png"), ("second", "/tmp/two.png")] {
+        steer
+            .send(SteerMessage {
+                prompt: text.into(),
+                message_id: None,
+                attachments: vec![image.into()],
+                config: None,
+            })
+            .await
+            .unwrap();
+    }
+    tokio::time::sleep(Duration::from_millis(100)).await;
+    fake.emit(json!({
+        "type": "message.part.updated",
+        "properties": { "part": {
+            "id": "prt_tool", "messageID": "msg_1", "sessionID": "ses_test",
+            "type": "tool", "tool": "bash", "callID": "call_1",
+            "state": { "status": "completed", "input": { "command": "sleep 1" }, "output": "" },
+        }},
+    }));
+    idle(&fake, "ses_test");
+
+    let prompts = wait_posts(&fake, "/session/ses_test/prompt_async", 2).await;
+    let parts = prompts[1]["parts"].as_array().expect("parts");
+    let text = parts
+        .iter()
+        .find(|p| p["type"] == "text")
+        .and_then(|p| p["text"].as_str())
+        .unwrap();
+    assert!(text.contains("first") && text.contains("second"), "{text}");
+    let images: Vec<&str> = parts
+        .iter()
+        .filter(|p| p["type"] == "file")
+        .filter_map(|p| p["url"].as_str())
+        .collect();
+    assert_eq!(images, ["file:///tmp/one.png", "file:///tmp/two.png"]);
+}
+
+/// A model switch reaches the live server: from the next prompt between
+/// turns, and mid-turn from the prompt of the message it was sent with —
+/// never merged into a prompt sent with the previous model.
+#[tokio::test]
+async fn a_model_switch_rides_the_next_prompt() {
+    let fake = FakeOpencode::start().await;
+    let (controls, steer, _token) = controls();
+    let mut opening = request("hi");
+    opening.model = Some("prov/model-a".into());
+    let driver = harness(&fake);
+    let mut switched = request("");
+    switched.model = Some("prov/model-b".into());
+    assert!(driver.reconfigures_in_place(&opening, &switched));
+    let mut stream = driver
+        .run(opening.clone(), controls)
+        .await
+        .expect("run starts");
+    let _ = next_event(&mut stream).await;
+    let _ = next_event(&mut stream).await;
+    assistant_message(&fake, "ses_test", "msg_1");
+    idle(&fake, "ses_test");
+    drain_to_done(&mut stream).await;
+
+    let send = |text: &str, config: Option<&RunRequest>| SteerMessage {
+        config: config.cloned().map(Box::new),
+        ..SteerMessage::text(text)
+    };
+    steer.send(send("on b", Some(&switched))).await.unwrap();
+    wait_posts(&fake, "/session/ses_test/prompt_async", 2).await;
+    assistant_message(&fake, "ses_test", "msg_2");
+    // A running tool holds what follows for the turn's end.
+    fake.emit(json!({
+        "type": "message.part.updated",
+        "properties": { "part": {
+            "id": "prt_tool", "messageID": "msg_2", "sessionID": "ses_test",
+            "type": "tool", "tool": "bash", "callID": "call_1",
+            "state": { "status": "running", "input": { "command": "sleep 1" } },
+        }},
+    }));
+    steer.send(send("still b", None)).await.unwrap();
+    steer.send(send("back on a", Some(&opening))).await.unwrap();
+    tokio::time::sleep(Duration::from_millis(100)).await;
+    fake.emit(json!({
+        "type": "message.part.updated",
+        "properties": { "part": {
+            "id": "prt_tool", "messageID": "msg_2", "sessionID": "ses_test",
+            "type": "tool", "tool": "bash", "callID": "call_1",
+            "state": { "status": "completed", "input": { "command": "sleep 1" }, "output": "" },
+        }},
+    }));
+    idle(&fake, "ses_test");
+    wait_posts(&fake, "/session/ses_test/prompt_async", 3).await;
+    assistant_message(&fake, "ses_test", "msg_3");
+    idle(&fake, "ses_test");
+    let prompts = wait_posts(&fake, "/session/ses_test/prompt_async", 4).await;
+    let sent: Vec<(String, String)> = prompts
+        .iter()
+        .map(|p| {
+            (
+                p["parts"][0]["text"].as_str().unwrap_or("").to_owned(),
+                p["model"]["modelID"].as_str().unwrap_or("").to_owned(),
+            )
+        })
+        .collect();
+    assert_eq!(
+        sent,
+        [
+            ("hi".to_owned(), "model-a".to_owned()),
+            ("on b".to_owned(), "model-b".to_owned()),
+            ("still b".to_owned(), "model-b".to_owned()),
+            ("back on a".to_owned(), "model-a".to_owned()),
+        ]
+    );
+}
+
 #[tokio::test]
 async fn provider_retries_surface_and_cap_out() {
     let fake = FakeOpencode::start().await;
diff --git a/crates/harness/tests/pi_live.rs b/crates/harness/tests/pi_live.rs
index dc08d0464e..8c8a4866d1 100644
--- a/crates/harness/tests/pi_live.rs
+++ b/crates/harness/tests/pi_live.rs
@@ -81,6 +81,7 @@ async fn real_pi_mock_lifecycle() {
                 .unwrap();
                 rx
             }),
+            turn: Default::default(),
         };
         let request = RunRequest {
             prompt: prompt.into(),
@@ -119,6 +120,8 @@ async fn real_pi_mock_lifecycle() {
                                 .send(SteerMessage {
                                     prompt: "redirect".into(),
                                     message_id: None,
+                                    attachments: Vec::new(),
+                                    config: None,
                                 })
                                 .await
                                 .unwrap();
@@ -179,6 +182,7 @@ async fn real_pi_mock_lifecycle() {
         steering,
         interrupt: CancellationToken::new(),
         request_input: Box::new(|_| oneshot::channel().1),
+        turn: Default::default(),
     };
     let request = RunRequest {
         prompt: "after loss".into(),
@@ -251,6 +255,7 @@ async fn real_pi_steering_bursts_share_the_next_model_call() {
         steering,
         interrupt: CancellationToken::new(),
         request_input: Box::new(|_| oneshot::channel().1),
+        turn: Default::default(),
     };
     let request = RunRequest {
         prompt: "burst hold".into(),
@@ -278,6 +283,8 @@ async fn real_pi_steering_bursts_share_the_next_model_call() {
         tx.send(SteerMessage {
             prompt: prompt.clone(),
             message_id: Some(format!("burst-user-{i}")),
+            attachments: Vec::new(),
+            config: None,
         })
         .await
         .unwrap();
@@ -298,12 +305,7 @@ async fn real_pi_steering_bursts_share_the_next_model_call() {
     // step, rather than being claimed as part of the already-running call.
     let late = vec!["late-1", "late-2", "late-3"];
     for prompt in &late {
-        tx.send(SteerMessage {
-            prompt: (*prompt).into(),
-            message_id: None,
-        })
-        .await
-        .unwrap();
+        tx.send(SteerMessage::text(*prompt)).await.unwrap();
     }
     drop(tx);
     wait_probe_lines(&inputs, burst.len() + late.len()).await;
diff --git a/crates/harness/tests/pi_rpc.rs b/crates/harness/tests/pi_rpc.rs
index edb3f381ca..ab9b5d7ea3 100644
--- a/crates/harness/tests/pi_rpc.rs
+++ b/crates/harness/tests/pi_rpc.rs
@@ -41,6 +41,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
                 let _ = tx.send(vec![]);
                 rx
             }),
+            turn: Default::default(),
         },
         tx,
         token,
@@ -215,6 +216,8 @@ async fn steers_confirm_on_consumption_and_interrupt_is_terminal_once() {
     tx.send(SteerMessage {
         prompt: "redirect".into(),
         message_id: Some("user-id".into()),
+        attachments: Vec::new(),
+        config: None,
     })
     .await
     .unwrap();
@@ -263,6 +266,8 @@ async fn idle_mailbox_starts_another_turn_without_restarting_process() {
                         tx.send(SteerMessage {
                             prompt: "second".into(),
                             message_id: None,
+                            attachments: Vec::new(),
+                            config: None,
                         })
                         .await
                         .unwrap();
@@ -510,6 +515,8 @@ async fn steering_burst_reaches_one_model_step_and_confirms_each_message_on_cons
             tx.send(SteerMessage {
                 prompt: prompt.clone(),
                 message_id: Some(format!("user-{i}")),
+                attachments: Vec::new(),
+                config: None,
             })
             .await
             .unwrap();
@@ -589,6 +596,8 @@ async fn handled_input_between_steers_keeps_its_own_delivery_receipt() {
             tx.send(SteerMessage {
                 prompt: prompt.into(),
                 message_id: None,
+                attachments: Vec::new(),
+                config: None,
             })
             .await
             .unwrap();
@@ -727,6 +736,8 @@ async fn late_extension_notifications_do_not_reopen_completed_turns() {
     tx.send(SteerMessage {
         prompt: "next".into(),
         message_id: None,
+        attachments: Vec::new(),
+        config: None,
     })
     .await
     .unwrap();
@@ -749,3 +760,49 @@ async fn late_extension_notifications_do_not_reopen_completed_turns() {
         1
     );
 }
+
+/// A model or thinking switch reaches the live process before the message
+/// it was sent with: no new process, no lost session.
+#[tokio::test]
+async fn a_model_switch_applies_to_the_live_process() {
+    let dir = tempfile::tempdir().unwrap();
+    let (c, tx, _) = controls();
+    let mut opening = request(dir.path(), "which-model");
+    opening.model = Some("mock/mock".into());
+    let mut switched = opening.clone();
+    switched.model = Some("mock/mock-2".into());
+    switched.reasoning = Some(zeron_proto::ReasoningLevel::High);
+    let driver = harness().with_session_store(dir.path().join("index"));
+    assert!(driver.reconfigures_in_place(&opening, &switched));
+    let mut stream = driver.run(opening, c).await.unwrap();
+    let mut text = String::new();
+    let mut dones = 0;
+    let mut started = 0;
+    while dones < 2 {
+        let event = tokio::time::timeout(Duration::from_secs(5), stream.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        match event {
+            AgentEvent::SessionStarted { .. } => started += 1,
+            AgentEvent::TextDelta { text: delta } => text.push_str(&delta),
+            AgentEvent::Done { .. } => {
+                dones += 1;
+                text.push('|');
+                if dones == 1 {
+                    tx.send(SteerMessage {
+                        config: Some(Box::new(switched.clone())),
+                        ..SteerMessage::text("which-model")
+                    })
+                    .await
+                    .unwrap();
+                }
+            }
+            _ => {}
+        }
+    }
+    assert_eq!(started, 1);
+    assert!(text.contains("reply:mock/medium|"), "{text}");
+    assert!(text.contains("reply:mock-2/high|"), "{text}");
+}
diff --git a/crates/harness/tests/real_acp_lifecycle.rs b/crates/harness/tests/real_acp_lifecycle.rs
index 4704ff410f..8492da3c26 100644
--- a/crates/harness/tests/real_acp_lifecycle.rs
+++ b/crates/harness/tests/real_acp_lifecycle.rs
@@ -23,6 +23,7 @@ async fn live_run(cancel: bool) {
             let _ = tx.send(Vec::new());
             rx
         }),
+        turn: Default::default(),
     };
     let request = RunRequest {
         mcp: None,
@@ -59,7 +60,7 @@ async fn live_run(cancel: bool) {
                     // Both messages must queue until the slow original prompt
                     // responds. The real adapter rejects overlapping prompts.
                     for word in ["SECOND-DONE", "THIRD-DONE"] {
-                        steer.send(SteerMessage { prompt: format!("Do not call tools. Reply exactly {word}."), message_id: None }).await.unwrap();
+                        steer.send(SteerMessage { prompt: format!("Do not call tools. Reply exactly {word}."), message_id: None, attachments: Vec::new(), config: None }).await.unwrap();
                     }
                 }
                 AgentEvent::TextDelta { text: delta } => text.push_str(&delta),
diff --git a/crates/harness/tests/real_quiet_survey.rs b/crates/harness/tests/real_quiet_survey.rs
index 10adea37ce..4bfb909528 100644
--- a/crates/harness/tests/real_quiet_survey.rs
+++ b/crates/harness/tests/real_quiet_survey.rs
@@ -38,6 +38,7 @@ fn controls() -> (RunControls, mpsc::Sender<SteerMessage>, CancellationToken) {
         }),
         steering: steer_rx,
         interrupt: token.clone(),
+        turn: Default::default(),
     };
     (controls, steer_tx, token)
 }
diff --git a/crates/harness/tests/windows_native.rs b/crates/harness/tests/windows_native.rs
index 5299f67f1a..86eed5ff13 100644
--- a/crates/harness/tests/windows_native.rs
+++ b/crates/harness/tests/windows_native.rs
@@ -235,6 +235,7 @@ async fn exercise(prompt: &str, resume: Option<&str>) {
         }),
         steering,
         interrupt: interrupt.clone(),
+        turn: Default::default(),
     };
     let operation = async {
         let mut stream = harness
@@ -329,6 +330,7 @@ async fn exercise_tree(prompt: &str, drop_stream: bool) {
         }),
         steering,
         interrupt: interrupt.clone(),
+        turn: Default::default(),
     };
     let mut stream = harness
         .run(request(dir.path(), prompt, None), controls)
@@ -490,6 +492,7 @@ async fn batch_overrides_launch_through_cmd() {
             }),
             steering,
             interrupt: CancellationToken::new(),
+            turn: Default::default(),
         };
         // Consume the whole stream: the shim cannot speak any agent protocol,
         // so the run must fail loudly — but only AFTER a safe launch.

From 565b49c527fb738704f217b897f9ba3aee575285 Mon Sep 17 00:00:00 2001
From: Wing <contact@winglee.io>
Date: Thu, 8 Oct 2026 09:58:44 -0700
Subject: [PATCH 65/74] Bump version to v0.2.107

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 46 +++++++++++++++++++++++-----------------------
 Cargo.toml |  2 +-
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d9cc4f63ed..9fb91a59b3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12941,7 +12941,7 @@ dependencies = [
 
 [[package]]
 name = "zeron"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "clap",
@@ -12963,7 +12963,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-audio"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "base64 0.22.1",
  "cpal 0.18.2",
@@ -12975,7 +12975,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-client"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "async-trait",
  "chrono",
@@ -13000,7 +13000,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-doc"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "chrono",
  "loro",
@@ -13014,7 +13014,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-engine"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13056,7 +13056,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-harness"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13084,14 +13084,14 @@ dependencies = [
 
 [[package]]
 name = "zeron-markdown"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "pulldown-cmark",
 ]
 
 [[package]]
 name = "zeron-mcp"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13109,7 +13109,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-mobile"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "async-trait",
  "serde",
@@ -13132,11 +13132,11 @@ dependencies = [
 
 [[package]]
 name = "zeron-orb"
-version = "0.2.106"
+version = "0.2.107"
 
 [[package]]
 name = "zeron-preview"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13164,7 +13164,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-proto"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "chrono",
  "pulldown-cmark",
@@ -13175,7 +13175,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-rpc"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13194,7 +13194,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-sync"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "block2 0.6.2",
  "chrono",
@@ -13217,7 +13217,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-syntax"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "thiserror 2.0.20",
  "tree-sitter",
@@ -13251,7 +13251,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-text"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "core-foundation 0.10.1",
  "core-graphics 0.24.0",
@@ -13268,7 +13268,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-theme"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "clap",
@@ -13283,7 +13283,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-ui"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -13359,7 +13359,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-update"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "futures",
@@ -13375,11 +13375,11 @@ dependencies = [
 
 [[package]]
 name = "zeron-veil"
-version = "0.2.106"
+version = "0.2.107"
 
 [[package]]
 name = "zeron-voice"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "anyhow",
  "cpal 0.17.3",
@@ -13396,7 +13396,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice-media"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "async-trait",
  "semver",
@@ -13411,7 +13411,7 @@ dependencies = [
 
 [[package]]
 name = "zeron-voice-session"
-version = "0.2.106"
+version = "0.2.107"
 dependencies = [
  "async-trait",
  "futures",
diff --git a/Cargo.toml b/Cargo.toml
index 9eb9e5b5be..020bd94200 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.106"
+version = "0.2.107"
 edition = "2024"
 license = "MIT"
 publish = false

From e799aecc16c863b987839a626574f7a0339d4275 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <84909978+katulevskiy@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:24:36 -0700
Subject: [PATCH 66/74] Fix remote sends stranded by mobile suspension and lost
 host wakes (#777)

* Fix durable remote send and host wake recovery

* Couple accepted chat rows to durable server host wakes

* Make Linux browser captures wait for mapped and presented frames

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/ios/Zeron/App/AppModel.swift             |  35 +-
 .../ios/Zeron/Session/CoreSessionSource.swift |   3 +
 apps/ios/Zeron/Session/SessionSource.swift    |   1 +
 .../Zeron/Session/SessionViewController.swift |   3 +
 crates/client/src/client.rs                   |  90 +++--
 crates/client/src/live/delivery.rs            | 155 ++++++++
 crates/client/src/live/escort.rs              |   2 +-
 crates/client/src/live/mod.rs                 |  27 +-
 crates/client/src/live/room.rs                |  18 +-
 crates/client/src/session/mod.rs              |  19 +-
 crates/client/src/workspace/view.rs           |  23 +-
 crates/client/tests/demo.rs                   |   8 +-
 crates/client/tests/live.rs                   | 296 ++++++++++++++-
 crates/client/tests/support/mock_edge.rs      | 123 ++++++-
 crates/engine/src/chat2_host.rs               |  16 +-
 crates/engine/src/doc_host.rs                 |  91 ++---
 crates/engine/src/doc_host_delivery.rs        | 341 ++++++++++++++++++
 crates/sync/src/sync_jobs.rs                  |  67 ++++
 crates/ui/Cargo.toml                          |   4 +-
 crates/ui/examples/browser-fixture.rs         |  51 ++-
 crates/ui/examples/browser-fixture/linux.rs   |  49 ++-
 .../browser-fixture/transcript_links.rs       |  13 +-
 docs/remote-send-delivery.md                  | 184 ++++++++++
 edge/src/chat-room.ts                         | 154 +++++++-
 edge/src/chat-route.ts                        |  36 ++
 edge/src/chat-wakes.ts                        |  46 +++
 edge/src/index.ts                             |  36 +-
 edge/test/workerd/chat-wakes.workerd.test.ts  | 215 +++++++++++
 edge/test/workerd/fixture.ts                  |   5 +-
 edge/vitest.workerd.config.ts                 |   1 +
 scripts/test-linux-browser.sh                 |   2 +-
 31 files changed, 1888 insertions(+), 226 deletions(-)
 create mode 100644 crates/client/src/live/delivery.rs
 create mode 100644 crates/engine/src/doc_host_delivery.rs
 create mode 100644 docs/remote-send-delivery.md
 create mode 100644 edge/src/chat-route.ts
 create mode 100644 edge/src/chat-wakes.ts
 create mode 100644 edge/test/workerd/chat-wakes.workerd.test.ts

diff --git a/apps/ios/Zeron/App/AppModel.swift b/apps/ios/Zeron/App/AppModel.swift
index 78156eb861..070b11d2e0 100644
--- a/apps/ios/Zeron/App/AppModel.swift
+++ b/apps/ios/Zeron/App/AppModel.swift
@@ -210,6 +210,8 @@ final class AppModel {
 
     @MainActor func signOutLocally() {
         voice.stop()
+        endDeliveryBackgroundTask()
+        lastDeliveryActivity = .distantPast
         client?.shutdown()
         client = nil
         Credentials.clearStored()
@@ -231,8 +233,38 @@ final class AppModel {
         newSessionImages = []
     }
 
-    func didEnterBackground() { client?.onBackground() }
+    private var lastDeliveryActivity = Date.distantPast
+
+    func noteDeliveryActivity() { lastDeliveryActivity = Date() }
+
+    private var deliveryBackgroundTask: UIBackgroundTaskIdentifier = .invalid
+    private var deliveryBackgroundDeadline: DispatchWorkItem?
+
+    private func endDeliveryBackgroundTask() {
+        deliveryBackgroundDeadline?.cancel()
+        deliveryBackgroundDeadline = nil
+        guard deliveryBackgroundTask != .invalid else { return }
+        UIApplication.shared.endBackgroundTask(deliveryBackgroundTask)
+        deliveryBackgroundTask = .invalid
+    }
+
+    func didEnterBackground() {
+        // Give the already-durable room outbox and host wake time to reach
+        // the edge when the user leaves immediately after tapping Send.
+        endDeliveryBackgroundTask()
+        if client != nil, !isDemo,
+           Date().timeIntervalSince(lastDeliveryActivity) < 120 || rows.values.contains(where: { $0.sendState == .sending || $0.sendState == .queued }) {
+            deliveryBackgroundTask = UIApplication.shared.beginBackgroundTask(withName: "Finish message delivery") { [weak self] in
+                self?.endDeliveryBackgroundTask()
+            }
+            let deadline = DispatchWorkItem { [weak self] in self?.endDeliveryBackgroundTask() }
+            deliveryBackgroundDeadline = deadline
+            DispatchQueue.main.asyncAfter(deadline: .now() + 25, execute: deadline)
+        }
+        client?.onBackground()
+    }
     func willEnterForeground() {
+        endDeliveryBackgroundTask()
         client?.onForeground()
         refreshWorkspace()
     }
@@ -552,6 +584,7 @@ final class AppModel {
             let project = rawProjects.first { $0.id == draft.projectId }
             let worktree = draft.worktree ? project.map { WorktreeSpec(repoPath: $0.path, base: draft.branch ?? "HEAD", spaceId: $0.id) } : nil
             _ = try handle.send(request: SendRequest(text: text, attachments: images.map(\.outgoing), worktree: worktree, busy: .queue))
+            noteDeliveryActivity()
             refreshWorkspace()
             return chatId
         } catch {
diff --git a/apps/ios/Zeron/Session/CoreSessionSource.swift b/apps/ios/Zeron/Session/CoreSessionSource.swift
index 8d5c490702..3e96d3c5c9 100644
--- a/apps/ios/Zeron/Session/CoreSessionSource.swift
+++ b/apps/ios/Zeron/Session/CoreSessionSource.swift
@@ -78,6 +78,8 @@ final class CoreSessionSource: SessionSource {
             next.banner = .notDelivered
         } else if c.sendState == .queued {
             next.banner = .failed("\(c.host.name ?? "Host") is offline — will send when it's back")
+        } else if c.sendState == .sending {
+            next.banner = .sending
         } else if app?.connectivity?.state == .offline {
             next.banner = .offline
         } else if !c.room.connected, let retry = c.room.retryAtMs {
@@ -111,6 +113,7 @@ final class CoreSessionSource: SessionSource {
         do {
             if mode == .interrupt, chrome.running { try handle.interrupt() }
             _ = try handle.send(request: SendRequest(text: text, attachments: images.map(\.outgoing), worktree: nil, busy: mode == .steer ? .steer : .queue))
+            app?.noteDeliveryActivity()
             sendFailure = nil
             return true
         } catch {
diff --git a/apps/ios/Zeron/Session/SessionSource.swift b/apps/ios/Zeron/Session/SessionSource.swift
index d5cfcc9072..99b1077baa 100644
--- a/apps/ios/Zeron/Session/SessionSource.swift
+++ b/apps/ios/Zeron/Session/SessionSource.swift
@@ -6,6 +6,7 @@ struct SessionChrome: Equatable {
     enum Banner: Equatable {
         case none
         case working(since: Date?, word: String)
+        case sending
         case offline
         case reconnecting(in: Int)
         case notDelivered
diff --git a/apps/ios/Zeron/Session/SessionViewController.swift b/apps/ios/Zeron/Session/SessionViewController.swift
index 2935998aaf..2958dd82b6 100644
--- a/apps/ios/Zeron/Session/SessionViewController.swift
+++ b/apps/ios/Zeron/Session/SessionViewController.swift
@@ -634,6 +634,9 @@ final class StatusPill: UIControl {
             }
             render()
             timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in render() }
+        case .sending:
+            grid.kind = .trailer
+            label.text = "Sending to host…"
         case .offline:
             grid.kind = .dot(StatusTone.idle)
             label.text = "Offline — sends are saved"
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 6d5333abe0..f6f5c2f2c2 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -236,46 +236,23 @@ impl ClientInner {
         live.relay.reconcile_watches(self, targets);
     }
 
-    /// Best-effort durable wake for the chat's host (`POST /device/{id}/nudge`).
-    /// Waits (briefly) for our own pending registry writes — e.g. a fresh
-    /// chat's CreateChat row — to reach the edge first, so the host never
-    /// wakes for a chat it can't see yet.
-    pub(crate) fn nudge_host(self: &Arc<Self>, host: &str, chat_id: &str) {
+    /// Durable wake: retry until the edge accepts it, including after relaunch.
+    pub(crate) fn nudge_host(self: &Arc<Self>, chat_id: &str) {
         let Some(live) = self.live() else { return };
-        let url = crate::live::urls::nudge(&live.edge, host);
-        let inner = Arc::downgrade(self);
-        let chat_id = chat_id.to_owned();
-        crate::runtime::shared().spawn(async move {
-            for _ in 0..50 {
-                let Some(inner) = inner.upgrade() else { return };
-                if inner.workspace.mutate(|doc| doc.pending_len()) == 0 {
-                    break;
-                }
-                drop(inner);
-                tokio::time::sleep(Duration::from_millis(100)).await;
-            }
-            let Some(inner) = inner.upgrade() else { return };
-            let Ok(token) = inner.tokens.bearer().await else {
-                return;
-            };
-            drop(inner);
-            for attempt in 0..3u64 {
-                let sent = crate::auth::http()
-                    .post(&url)
-                    .bearer_auth(&token)
-                    .json(&serde_json::json!({ "chatId": chat_id }))
-                    .timeout(Duration::from_secs(10))
-                    .send()
-                    .await;
-                match sent {
-                    // 503 nudge_queue_full is retryable.
-                    Ok(response) if response.status().as_u16() == 503 => {
-                        tokio::time::sleep(Duration::from_millis(500 * (attempt + 1))).await;
-                    }
-                    _ => return,
-                }
-            }
-        });
+        if let Err(err) = live
+            .store
+            .schedule_sync_job(chat_id, crate::live::delivery::JOB)
+        {
+            tracing::warn!(chat = %chat_id, error = %err, "host wake persistence failed");
+        }
+        live.delivery_wake.notify_one();
+    }
+
+    pub(crate) fn resume_delivery(self: &Arc<Self>, chat_id: &str) -> Result<SessionHandle> {
+        Client {
+            inner: self.clone(),
+        }
+        .open_session(chat_id)
     }
 
     pub(crate) fn registry_write<R>(
@@ -467,9 +444,8 @@ impl ClientInner {
                 if has_attachments {
                     live.escorts.respawn_chat(self, &core.chat_id);
                 }
-                if let Some(host) = self.workspace.chat(&core.chat_id).map(|c| c.device_id) {
-                    self.nudge_host(&host, &core.chat_id);
-                }
+                // SessionCore::write already persisted the wake receipt.
+                live.delivery_wake.notify_one();
             }
         }
     }
@@ -1080,6 +1056,18 @@ impl Client {
         core.ensure_room(&self.inner);
         core.touch();
         core.refresh();
+        // Upgrade recovery: older clients could persist an ACKed command
+        // without its wake. Opening that chat must re-arm host discovery.
+        if let Some(live) = self.inner.live()
+            && core.send_state().is_some()
+            && live
+                .store
+                .sync_job_version(chat_id, crate::live::delivery::JOB)
+                .ok()
+                == Some(None)
+        {
+            self.inner.nudge_host(chat_id);
+        }
         if let Some(demo) = self.inner.demo() {
             demo.session_opened(&core);
         }
@@ -1199,7 +1187,9 @@ impl Client {
         environment: &str,
         prefs: PushPrefs,
     ) -> Result<()> {
-        let Some(live) = self.inner.live() else { return Ok(()) };
+        let Some(live) = self.inner.live() else {
+            return Ok(());
+        };
         let url = crate::live::urls::registry_push_target(
             &live.edge,
             self.inner.credentials.org_id(),
@@ -1219,14 +1209,19 @@ impl Client {
             .await
             .map_err(|e| ClientError::Network(e.to_string()))?;
         if !response.status().is_success() {
-            return Err(ClientError::HostError(format!("push registration http {}", response.status())));
+            return Err(ClientError::HostError(format!(
+                "push registration http {}",
+                response.status()
+            )));
         }
         Ok(())
     }
 
     /// Stop notifications to this device (sign-out, turned off).
     pub async fn unregister_push_target(&self) -> Result<()> {
-        let Some(live) = self.inner.live() else { return Ok(()) };
+        let Some(live) = self.inner.live() else {
+            return Ok(());
+        };
         let url = crate::live::urls::registry_push_target(
             &live.edge,
             self.inner.credentials.org_id(),
@@ -1240,7 +1235,10 @@ impl Client {
             .await
             .map_err(|e| ClientError::Network(e.to_string()))?;
         if !response.status().is_success() {
-            return Err(ClientError::HostError(format!("push removal http {}", response.status())));
+            return Err(ClientError::HostError(format!(
+                "push removal http {}",
+                response.status()
+            )));
         }
         Ok(())
     }
diff --git a/crates/client/src/live/delivery.rs b/crates/client/src/live/delivery.rs
new file mode 100644
index 0000000000..1ce3f249c8
--- /dev/null
+++ b/crates/client/src/live/delivery.rs
@@ -0,0 +1,155 @@
+//! The room outbox and host discovery are separate delivery obligations.
+//! Persist the wake until the edge accepts it AND all local rows are ACKed.
+//! Restart recovery opens these rooms without depending on viewport/preloads.
+
+use std::collections::HashSet;
+use std::sync::Arc;
+use std::time::Duration;
+
+use tokio::sync::Notify;
+use tokio_util::sync::CancellationToken;
+
+use crate::client::ClientInner;
+
+pub(crate) const JOB: &str = "viewer-delivery";
+const MAX_ACTIVE: usize = 8;
+
+pub(crate) fn start(inner: &Arc<ClientInner>, wake: Arc<Notify>, cancel: CancellationToken) {
+    let weak = Arc::downgrade(inner);
+    crate::runtime::shared().spawn(async move {
+        let mut tasks = tokio::task::JoinSet::new();
+        let mut active = HashSet::new();
+        let mut after = String::new();
+        loop {
+            let notified = wake.notified();
+            while let Some(result) = tasks.try_join_next() {
+                if let Ok(chat) = result {
+                    active.remove(&chat);
+                }
+            }
+            let Some(inner) = weak.upgrade() else { return };
+            let Some(live) = inner.live() else { return };
+            // Preserve the scan cursor while full: wrapping here would let
+            // the same first page reclaim every released slot.
+            if active.len() < MAX_ACTIVE {
+                match live.store.pending_viewer_deliveries(&after, 64) {
+                    Ok(page) => {
+                        if page.is_empty() {
+                            after.clear();
+                        }
+                        for chat in page {
+                            if active.len() >= MAX_ACTIVE {
+                                break;
+                            }
+                            after = chat.clone();
+                            if inner.workspace.chat(&chat).is_none() || !active.insert(chat.clone()) {
+                                continue;
+                            }
+                            let inner = Arc::downgrade(&inner);
+                            let cancel = cancel.clone();
+                            tasks.spawn(async move {
+                                tokio::select! {
+                                    _ = cancel.cancelled() => {},
+                                    // Yield stalled receipts to later destinations.
+                                    _ = tokio::time::timeout(Duration::from_secs(12), deliver(inner, &chat)) => {},
+                                }
+                                chat
+                            });
+                        }
+                    }
+                    Err(err) => tracing::warn!(%err, "delivery discovery failed"),
+                }
+            }
+            drop(inner);
+            tokio::select! {
+                _ = cancel.cancelled() => return,
+                _ = notified => {},
+                _ = tokio::time::sleep(Duration::from_millis(500)) => {},
+            }
+        }
+    });
+}
+
+async fn deliver(weak: std::sync::Weak<ClientInner>, chat: &str) {
+    // Hold the session (not the account) while delivering: a detached room
+    // must remain alive through its outgoing ACK, including queue-only writes.
+    let _session = {
+        let Some(inner) = weak.upgrade() else { return };
+        let Ok(session) = inner.resume_delivery(chat) else {
+            return;
+        };
+        session
+    };
+    let mut backoff = super::JOIN_RETRY_BASE;
+    loop {
+        let Some(inner) = weak.upgrade() else { return };
+        let Some(live) = inner.live() else { return };
+        let Some(row) = inner.workspace.chat(chat) else {
+            return;
+        };
+        let version = match live.store.sync_job_version(chat, JOB) {
+            Ok(version) => version,
+            Err(err) => {
+                tracing::warn!(%err, %chat, "delivery receipt load failed");
+                None
+            }
+        };
+        let rows_flushed = live.store.has_pending_chat_updates(chat).ok() == Some(false);
+        // No registry wait: hosts durably admit a wake before CreateChat
+        // arrives and default missing rows to chat2 (the born-chat race).
+        let result = async {
+            let token = inner.tokens.bearer().await?;
+            let response = crate::auth::http()
+                .post(super::urls::nudge(&live.edge, &row.device_id))
+                .bearer_auth(token)
+                .json(&serde_json::json!({ "chatId": chat }))
+                .timeout(Duration::from_secs(10))
+                .send()
+                .await
+                .map_err(|err| crate::ClientError::Network(err.to_string()))?;
+            // Another owner's device (403) or a chat id its room refuses
+            // (400): no retry can change that, so the wake is settled. The
+            // receipt still waits for the outgoing rows. Unclaimed (404:
+            // the host has not connected yet) and 5xx retry.
+            if matches!(response.status().as_u16(), 400 | 403) {
+                tracing::warn!(%chat, status = response.status().as_u16(), "host wake refused; not retrying");
+                return Ok(());
+            }
+            if !response.status().is_success() {
+                return Err(crate::ClientError::Network(format!(
+                    "host wake HTTP {}",
+                    response.status()
+                )));
+            }
+            Ok(())
+        }
+        .await;
+        if result.is_ok() && rows_flushed {
+            match live.store.has_pending_chat_updates(chat) {
+                Ok(false) => {
+                    // This wake was posted AFTER the outgoing row ACKs. A
+                    // wake sent before them can catch up to an empty room.
+                    if let Some(version) = version {
+                        if let Err(err) = live.store.complete_sync_job(chat, JOB, version) {
+                            tracing::warn!(%err, %chat, "delivery receipt completion failed");
+                        } else if live.store.sync_job_version(chat, JOB).ok() == Some(None) {
+                            return;
+                        }
+                    } else {
+                        return;
+                    }
+                }
+                Ok(true) => {}
+                Err(err) => tracing::warn!(%err, %chat, "delivery outbox check failed"),
+            }
+        } else if let Err(err) = result {
+            tracing::debug!(%err, %chat, "host wake retrying");
+        }
+        let cancel = inner.cancel.clone();
+        drop(inner);
+        if !super::wait_backoff(&cancel, backoff).await {
+            return;
+        }
+        backoff = (backoff * 2).min(super::JOIN_RETRY_CAP);
+    }
+}
diff --git a/crates/client/src/live/escort.rs b/crates/client/src/live/escort.rs
index 52ddbc4331..3c29aaa72d 100644
--- a/crates/client/src/live/escort.rs
+++ b/crates/client/src/live/escort.rs
@@ -173,7 +173,7 @@ async fn run(
             Ok(path) => {
                 tracing::info!(upload = %upload_id, %path, "attachment escorted");
                 live.escorts.remove(upload_id);
-                inner.nudge_host(&meta.host_device_id, &meta.chat_id);
+                inner.nudge_host(&meta.chat_id);
                 return;
             }
             Err(err) => {
diff --git a/crates/client/src/live/mod.rs b/crates/client/src/live/mod.rs
index 2e0d387ce6..c3becae2dc 100644
--- a/crates/client/src/live/mod.rs
+++ b/crates/client/src/live/mod.rs
@@ -13,6 +13,7 @@
 //! short — the legacy client's one-shot chat join left chats dark until a
 //! relaunch.
 
+pub(crate) mod delivery;
 pub(crate) mod escort;
 pub(crate) mod relay;
 pub(crate) mod room;
@@ -194,10 +195,12 @@ pub(crate) struct LiveBackend {
     registry_retry_at: AtomicI64,
     registry_failure: Mutex<Option<String>>,
     registry_save: Arc<Notify>,
+    registry_save_gate: Mutex<()>,
     registry_dirty: Arc<AtomicBool>,
     last_liveness_probe: AtomicI64,
     pub(crate) relay: relay::Relay,
     pub(crate) escorts: escort::Escorts,
+    pub(crate) delivery_wake: Arc<Notify>,
     cancel: CancellationToken,
 }
 
@@ -226,12 +229,14 @@ impl LiveBackend {
         Self {
             relay: relay::Relay::new(inner, &edge, bearer),
             escorts: escort::Escorts::new(&inner.config.data_dir),
+            delivery_wake: Arc::new(Notify::new()),
             edge,
             store,
             registry: Mutex::new(None),
             registry_retry_at: AtomicI64::new(0),
             registry_failure: Mutex::new(None),
             registry_save: Arc::new(Notify::new()),
+            registry_save_gate: Mutex::new(()),
             registry_dirty: Arc::new(AtomicBool::new(false)),
             last_liveness_probe: AtomicI64::new(0),
             cancel: inner.cancel.child_token(),
@@ -248,6 +253,7 @@ impl LiveBackend {
         self.spawn_registry(inner);
         self.spawn_registry_saver(inner);
         self.escorts.respawn(inner);
+        delivery::start(inner, self.delivery_wake.clone(), self.cancel.clone());
     }
 
     pub(crate) fn stop(&self) {
@@ -357,17 +363,22 @@ impl LiveBackend {
             return;
         }
         let Some(inner) = inner else { return };
-        let bytes = inner.workspace.mutate(|doc| doc.to_bytes());
-        match bytes {
-            Ok(bytes) => {
-                if let Err(err) = self.store.save_snapshot(REGISTRY_DOC_ID, &bytes) {
-                    tracing::warn!(error = %err, "registry snapshot save failed");
-                }
-            }
-            Err(err) => tracing::warn!(error = %err, "registry export failed"),
+        if let Err(err) = self.persist_registry(inner) {
+            self.registry_dirty.store(true, Ordering::Release);
+            tracing::warn!(error = %err, "registry snapshot save failed");
         }
     }
 
+    /// Serialize export and save, so a debounced older export cannot overwrite
+    /// a new chat row persisted before its first command.
+    pub(crate) fn persist_registry(&self, inner: &ClientInner) -> Result<()> {
+        let _gate = lock(&self.registry_save_gate);
+        let bytes = inner.workspace.mutate(|doc| doc.to_bytes())?;
+        self.store
+            .save_snapshot(REGISTRY_DOC_ID, &bytes)
+            .map_err(|err| ClientError::Storage(err.to_string()))
+    }
+
     /// Persist the registry now (backgrounding).
     pub(crate) fn flush_registry(&self, inner: &ClientInner) {
         self.flush_registry_now_with(Some(inner));
diff --git a/crates/client/src/live/room.rs b/crates/client/src/live/room.rs
index f5c1381235..d335d3efb3 100644
--- a/crates/client/src/live/room.rs
+++ b/crates/client/src/live/room.rs
@@ -306,11 +306,13 @@ pub(crate) struct ChatUrl {
     pub(crate) edge: String,
     pub(crate) chat_id: String,
     pub(crate) device_id: String,
+    pub(crate) host_device_id: String,
 }
 
 impl UrlProvider for ChatUrl {
     fn url(&self) -> BoxFuture<'static, Result<String, SyncError>> {
         let bearer = self.bearer.clone();
+        let host = self.host_device_id.clone();
         let (edge, chat, device) = (
             self.edge.clone(),
             self.chat_id.clone(),
@@ -318,7 +320,11 @@ impl UrlProvider for ChatUrl {
         );
         Box::pin(async move {
             let token = bearer.get().await?;
-            Ok(urls::chat_ws(&edge, &chat, &token, &device))
+            Ok(format!(
+                "{}&hostDevice={}",
+                urls::chat_ws(&edge, &chat, &token, &device),
+                urls::encode(&host)
+            ))
         })
     }
 }
@@ -330,6 +336,7 @@ pub(crate) struct ChatHttp {
     pub(crate) edge: String,
     pub(crate) chat_id: String,
     pub(crate) device_id: String,
+    pub(crate) host_device_id: String,
 }
 
 fn http_err(err: reqwest::Error) -> SyncError {
@@ -435,7 +442,11 @@ impl ChatTransport for ChatHttp {
         bytes: Vec<u8>,
     ) -> BoxFuture<'static, Result<String, SyncError>> {
         let bearer = self.bearer.clone();
-        let url = urls::chat_push(&self.edge, &self.chat_id, &batch_id, &self.device_id);
+        let url = format!(
+            "{}&hostDevice={}",
+            urls::chat_push(&self.edge, &self.chat_id, &batch_id, &self.device_id),
+            urls::encode(&self.host_device_id)
+        );
         Box::pin(async move {
             let _permit = zeron_sync::budget::shared()
                 .http(zeron_sync::budget::Priority::Interactive)
@@ -493,6 +504,7 @@ pub(crate) struct RoomDeps {
     pub bearer: Bearer,
     pub edge: String,
     pub device_id: String,
+    pub host_device_id: String,
     pub store: Arc<DocsStore>,
     /// Remote change landed (schedule a coalesced session refresh).
     pub on_applied: Arc<dyn Fn() + Send + Sync>,
@@ -564,12 +576,14 @@ impl Room {
             edge: deps.edge.clone(),
             chat_id: self.chat_id.clone(),
             device_id: deps.device_id.clone(),
+            host_device_id: deps.host_device_id.clone(),
         });
         let http = Arc::new(ChatHttp {
             bearer: deps.bearer.clone(),
             edge: deps.edge.clone(),
             chat_id: self.chat_id.clone(),
             device_id: deps.device_id.clone(),
+            host_device_id: deps.host_device_id.clone(),
         });
         let weak = Arc::downgrade(self);
         let cancel = self.cancel.clone();
diff --git a/crates/client/src/session/mod.rs b/crates/client/src/session/mod.rs
index 0c92ef5fcb..f876a3bc1b 100644
--- a/crates/client/src/session/mod.rs
+++ b/crates/client/src/session/mod.rs
@@ -343,6 +343,7 @@ impl SessionCore {
                 bearer: crate::live::LiveBackend::bearer(client),
                 edge: live.edge.clone(),
                 device_id: client.config.device_id.clone(),
+                host_device_id: chat.device_id.clone(),
                 store: live.store.clone(),
                 on_applied,
                 on_status,
@@ -381,7 +382,20 @@ impl SessionCore {
     ) -> Result<R> {
         let result = {
             let _gate = lock(&self.write_gate);
-            f(&self.doc)?
+            let client = self.client()?;
+            if let Some(live) = client.live() {
+                // A new chat's registry row must survive alongside its outbox:
+                // recovery needs its host and room generation before any UI opens it.
+                live.persist_registry(&client)?;
+            }
+            let result = f(&self.doc)?;
+            if let Some(live) = client.live() {
+                live.store
+                    .schedule_sync_job(&self.chat_id, crate::live::delivery::JOB)
+                    .map_err(|err| ClientError::Storage(err.to_string()))?;
+                live.delivery_wake.notify_one();
+            }
+            result
         };
         self.refresh();
         Ok(result)
@@ -449,9 +463,8 @@ impl SessionCore {
                 .entries()
                 .last()
                 .is_some_and(|e| e.is_streaming());
-            let sending = st.pending.iter().any(|p| p.state == SendState::Sending);
             let live = LiveFlags {
-                working: indicator_working || streaming || sending,
+                working: indicator_working || streaming,
                 working_since_ms,
             };
             let live_changed = previous.working != live.working
diff --git a/crates/client/src/workspace/view.rs b/crates/client/src/workspace/view.rs
index 9838658a76..ccc490b302 100644
--- a/crates/client/src/workspace/view.rs
+++ b/crates/client/src/workspace/view.rs
@@ -32,9 +32,9 @@ pub const PROJECT_COLOR_COUNT: u32 = 8;
 /// monogram tone: 32-bit FNV-1a of the project's path (`"home"` without a
 /// project), so a project has the same color on every device.
 pub fn project_color_index(space_path: &str) -> u32 {
-    let hash = space_path
-        .bytes()
-        .fold(2_166_136_261u32, |h, b| (h ^ u32::from(b)).wrapping_mul(16_777_619));
+    let hash = space_path.bytes().fold(2_166_136_261u32, |h, b| {
+        (h ^ u32::from(b)).wrapping_mul(16_777_619)
+    });
     hash % PROJECT_COLOR_COUNT
 }
 
@@ -80,9 +80,8 @@ pub struct SessionRow {
     pub branch: Option<String>,
     pub cwd: Option<String>,
     pub indicator: ChatIndicator,
-    /// The host-reported status alone (45s staleness-gated) — `indicator`
-    /// minus the "a send of mine is in flight" override. What stop/busy
-    /// logic keys off (a send parked for an offline host is not a turn).
+    /// Host-reported status (45s staleness-gated). Stop/busy logic keys off
+    /// this; an outgoing send is not evidence of a running turn.
     pub host_indicator: ChatIndicator,
     /// Run start of the live turn while Working/AwaitingInput.
     pub working_since_ms: Option<i64>,
@@ -431,21 +430,13 @@ fn build_row(chat: &Chat, rc: &RowContext<'_>, cx: &DeriveContext<'_>) -> Arc<Se
     let session = rc.sessions.get(chat.id.as_str()).copied();
     let send_state = cx.send_states.get(&chat.id).copied();
     let host_indicator = display_status(chat, session, cx.now);
-    let mut indicator = host_indicator;
-    let mut working_since_ms = match indicator {
+    let indicator = host_indicator;
+    let working_since_ms = match indicator {
         ChatIndicator::Working | ChatIndicator::AwaitingInput => session
             .and_then(|s| s.started_at)
             .map(|t| t.timestamp_millis()),
         _ => None,
     };
-    // A send in flight reads as Working (desktop `display_status_for`).
-    if matches!(send_state, Some(SendState::Sending | SendState::Queued))
-        && indicator != ChatIndicator::Working
-        && indicator != ChatIndicator::AwaitingInput
-    {
-        indicator = ChatIndicator::Working;
-        working_since_ms = None;
-    }
     let project = chat
         .space_id
         .as_deref()
diff --git a/crates/client/tests/demo.rs b/crates/client/tests/demo.rs
index 56bbd87a0f..100765a737 100644
--- a/crates/client/tests/demo.rs
+++ b/crates/client/tests/demo.rs
@@ -183,7 +183,10 @@ fn send_streams_a_reply_and_adopts_the_echo() {
     assert_eq!(echo.pending.len(), 1);
     assert_eq!(echo.pending[0].message_id, message_id);
     assert!(echo.entry(&message_id).unwrap().echo.is_some());
-    assert!(echo.working, "a send in flight reads as working");
+    assert!(
+        !echo.working,
+        "a pending send is not confirmed host activity"
+    );
 
     let (tx, rx) = std::sync::mpsc::channel();
     let _watch = session.watch(move |snap| {
@@ -257,8 +260,7 @@ fn questions_answer_through_respond_input() {
     });
     // The host publishes the question, then flips the chat's status.
     wait_for("awaiting input", Duration::from_secs(5), || {
-        client.workspace().session("chat-deploy").unwrap().indicator
-            == ChatIndicator::AwaitingInput
+        client.workspace().session("chat-deploy").unwrap().indicator == ChatIndicator::AwaitingInput
     });
     let input = session.composer().open_input.clone().unwrap();
     session
diff --git a/crates/client/tests/live.rs b/crates/client/tests/live.rs
index 203ae87f6d..9a6cfbfb28 100644
--- a/crates/client/tests/live.rs
+++ b/crates/client/tests/live.rs
@@ -327,7 +327,18 @@ async fn session_send_round_trips_through_the_chat_room() {
         panic!("idle chat starts a turn");
     };
     assert_eq!(session.snapshot().pending.len(), 1);
-    assert!(session.snapshot().working, "in flight to a live host");
+    assert!(
+        !session.snapshot().working,
+        "sending is not confirmed host activity"
+    );
+    assert_eq!(
+        session.composer().send_state,
+        Some(zeron_client::SendState::Sending)
+    );
+    assert_ne!(
+        client.workspace().session(CHAT).unwrap().indicator,
+        ChatIndicator::Working
+    );
 
     // The command row reaches the room; the host answers.
     let host_doc = LoroDoc::new();
@@ -414,6 +425,15 @@ async fn sends_survive_a_room_outage_and_deliver_on_rejoin() {
     tokio::time::sleep(Duration::from_millis(1500)).await;
     assert!(edge.rows(CHAT).is_empty(), "room refused");
     assert_eq!(session.snapshot().pending.len(), 1, "durable echo stays");
+    let store = zeron_sync::DocsStore::open(dir.path()).unwrap();
+    assert!(
+        store
+            .sync_job_version(CHAT, "viewer-delivery")
+            .unwrap()
+            .is_some(),
+        "an early successful wake cannot retire unpushed rows"
+    );
+    assert_eq!(edge.last_nudge_row_count(CHAT), Some(0));
 
     // The room comes back: the join loop retries (never one-shot) and the
     // outbox delivers.
@@ -426,6 +446,19 @@ async fn sends_survive_a_room_outage_and_deliver_on_rejoin() {
         );
         tokio::time::sleep(Duration::from_millis(100)).await;
     }
+    let start = Instant::now();
+    while store
+        .sync_job_version(CHAT, "viewer-delivery")
+        .unwrap()
+        .is_some()
+    {
+        assert!(start.elapsed() < Duration::from_secs(10));
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    assert!(
+        edge.last_nudge_row_count(CHAT).unwrap() > 0,
+        "the final host wake follows command publication"
+    );
     let host_doc = LoroDoc::new();
     let start = Instant::now();
     while host_answers(&edge, &host_doc).is_none() {
@@ -812,5 +845,266 @@ async fn phone_born_sessions_reach_the_host_before_their_first_command() {
         );
         tokio::time::sleep(Duration::from_millis(20)).await;
     }
+    assert_eq!(edge.host_hint(&chat_id).as_deref(), Some(HOST));
+    client.shutdown();
+}
+
+// The wake must survive independently of the chat row ACK: the host may have
+// no room open yet, even though the edge already holds every command byte.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn acked_command_recovers_failed_host_wake_without_opening_the_chat() {
+    let edge = MockEdge::start().await;
+    let _host = HostRegistry::start(&edge).await;
+    edge.nudge_status(500);
+    let dir = tempfile::tempdir().unwrap();
+    let client = phone(&edge, dir.path());
+    await_chat(&client, CHAT).await;
+    let session = client.open_session(CHAT).unwrap();
+    session
+        .send(SendRequest::text("wake the cold host"))
+        .unwrap();
+    let store = zeron_sync::DocsStore::open(dir.path()).unwrap();
+    let start = Instant::now();
+    while edge.rows(CHAT).is_empty() || store.has_pending_chat_updates(CHAT).unwrap() {
+        assert!(start.elapsed() < Duration::from_secs(10));
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    // A 500 used to silently abandon the wake after the first attempt.
+    let start = Instant::now();
+    while edge.nudges(CHAT) < 2 {
+        assert!(
+            start.elapsed() < Duration::from_secs(5),
+            "host wake was not retried"
+        );
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    assert!(
+        store
+            .sync_job_version(CHAT, "viewer-delivery")
+            .unwrap()
+            .is_some()
+    );
+    client.shutdown();
+    drop(session);
+    drop(client);
+    let before = edge.nudges(CHAT);
+    edge.nudge_status(200);
+    let restarted = phone(&edge, dir.path());
+    // No open_session, viewport attach or preload: recovery discovers the job.
+    let start = Instant::now();
+    while edge.nudges(CHAT) <= before
+        || store
+            .sync_job_version(CHAT, "viewer-delivery")
+            .unwrap()
+            .is_some()
+    {
+        assert!(
+            start.elapsed() < Duration::from_secs(10),
+            "ACKed command lost its host wake on restart"
+        );
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    restarted.shutdown();
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn a_refused_host_wake_settles_instead_of_retrying_forever() {
+    let edge = MockEdge::start().await;
+    let _host = HostRegistry::start(&edge).await;
+    // Another owner's device: no retry can change a 403.
+    edge.nudge_status(403);
+    let dir = tempfile::tempdir().unwrap();
+    let client = phone(&edge, dir.path());
+    await_chat(&client, CHAT).await;
+    let session = client.open_session(CHAT).unwrap();
+    session
+        .send(SendRequest::text("to a foreign host"))
+        .unwrap();
+    let store = zeron_sync::DocsStore::open(dir.path()).unwrap();
+    let start = Instant::now();
+    while edge.rows(CHAT).is_empty()
+        || store.has_pending_chat_updates(CHAT).unwrap()
+        || store
+            .sync_job_version(CHAT, "viewer-delivery")
+            .unwrap()
+            .is_some()
+    {
+        assert!(
+            start.elapsed() < Duration::from_secs(10),
+            "a refused wake kept its receipt"
+        );
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    let settled = edge.nudges(CHAT);
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    assert_eq!(edge.nudges(CHAT), settled, "a refused wake was retried");
+    client.shutdown();
+}
+
+async fn await_chat(client: &Client, chat: &str) {
+    let start = Instant::now();
+    while client.workspace().session(chat).is_none() {
+        assert!(start.elapsed() < Duration::from_secs(10));
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn immediate_exit_after_first_send_recovers_new_chat_on_each_host_platform() {
+    for (platform, harness) in [
+        ("windows", HarnessId::Codex),
+        ("macos", HarnessId::Cursor),
+        ("linux", HarnessId::ClaudeCode),
+    ] {
+        let edge = MockEdge::start().await;
+        let host = HostRegistry::start(&edge).await;
+        let (mut device, _, _) = host_rows(Utc::now());
+        device.platform = platform.into();
+        host.doc.lock().unwrap().upsert_device(&device).unwrap();
+        host.client.nudge();
+        edge.refuse_chat_joins(true);
+        edge.nudge_status(500);
+        let dir = tempfile::tempdir().unwrap();
+        let client = phone(&edge, dir.path());
+        await_chat(&client, CHAT).await;
+        let chat = client
+            .create_session(zeron_client::NewSession {
+                target: zeron_client::SessionTarget::Project {
+                    space_id: SPACE.into(),
+                },
+                config: Some(ChatConfig {
+                    harness,
+                    model: None,
+                    reasoning: None,
+                    model_options: Default::default(),
+                    sandbox: SandboxLevel::WorkspaceWrite,
+                }),
+                branch: None,
+                cwd: None,
+                title: None,
+            })
+            .unwrap();
+        let session = client.open_session(&chat).unwrap();
+        let SendOutcome::Started { message_id } = session
+            .send(SendRequest::text("first message before closing"))
+            .unwrap()
+        else {
+            panic!()
+        };
+        // No background flush, debounce sleep, or incoming host acknowledgement.
+        let store = zeron_sync::DocsStore::open(dir.path()).unwrap();
+        let bytes = store
+            .load_snapshot(zeron_doc::REGISTRY_DOC_ID)
+            .unwrap()
+            .unwrap();
+        let saved = RegistryDoc::from_bytes(&bytes, "ios-live").unwrap();
+        assert!(
+            saved.chat(&chat).unwrap().is_some(),
+            "{platform}: first send returned before its registry row was saved"
+        );
+        assert!(!session.snapshot().working);
+        client.shutdown();
+        drop(session);
+        drop(client);
+        edge.refuse_chat_joins(false);
+        edge.nudge_status(200);
+        let restarted = phone(&edge, dir.path());
+        assert!(
+            restarted.workspace().session(&chat).is_some(),
+            "{platform}: new registry row was not durable"
+        );
+        let store = zeron_sync::DocsStore::open(dir.path()).unwrap();
+        let start = Instant::now();
+        while edge.rows(&chat).is_empty()
+            || edge.nudges(&chat) == 0
+            || store.has_pending_chat_updates(&chat).unwrap()
+            || store
+                .sync_job_version(&chat, "viewer-delivery")
+                .unwrap()
+                .is_some()
+        {
+            assert!(
+                start.elapsed() < Duration::from_secs(15),
+                "{platform}: first send was stranded without a UI open"
+            );
+            tokio::time::sleep(Duration::from_millis(20)).await;
+        }
+        let doc = SessionDoc::from_doc(LoroDoc::new());
+        for row in edge.rows(&chat) {
+            doc.doc().import(&row.bytes).unwrap();
+        }
+        let commands = doc.read_commands().unwrap();
+        assert_eq!(
+            commands.len(),
+            1,
+            "{platform}: recovery duplicated the command"
+        );
+        assert!(
+            matches!(&commands[0].payload, SessionCommandPayload::Run { request, message_id: id } if id.as_str() == message_id.as_str() && request.harness == Some(harness))
+        );
+        restarted.shutdown();
+    }
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn stalled_wakes_yield_delivery_capacity_to_later_chats() {
+    let edge = MockEdge::start().await;
+    let host = HostRegistry::start(&edge).await;
+    edge.nudge_status(500);
+    edge.nudge_status_for("z-healthy", 200);
+    for n in 0..9 {
+        let (_, _, mut row) = host_rows(Utc::now());
+        row.id = if n == 8 {
+            "z-healthy".into()
+        } else {
+            format!("a-stalled-{n}")
+        };
+        host.doc.lock().unwrap().upsert_chat(&row).unwrap();
+    }
+    host.client.nudge();
+    let dir = tempfile::tempdir().unwrap();
+    let client = phone(&edge, dir.path());
+    await_chat(&client, "z-healthy").await;
+    for n in 0..8 {
+        client
+            .open_session(&format!("a-stalled-{n}"))
+            .unwrap()
+            .send(SendRequest::text("stalled wake"))
+            .unwrap();
+    }
+    let start = Instant::now();
+    while edge.nudges("a-stalled-7") == 0 {
+        assert!(
+            start.elapsed() < Duration::from_secs(5),
+            "delivery slots did not fill"
+        );
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    client
+        .open_session("z-healthy")
+        .unwrap()
+        .send(SendRequest::text("healthy destination"))
+        .unwrap();
+    let store = zeron_sync::DocsStore::open(dir.path()).unwrap();
+    let start = Instant::now();
+    while edge.nudges("z-healthy") == 0
+        || store
+            .sync_job_version("z-healthy", "viewer-delivery")
+            .unwrap()
+            .is_some()
+    {
+        assert!(
+            start.elapsed() < Duration::from_secs(16),
+            "stalled wakes starved the next delivery"
+        );
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    assert!(
+        store
+            .sync_job_version("a-stalled-0", "viewer-delivery")
+            .unwrap()
+            .is_some(),
+        "yielding must preserve the stalled obligation"
+    );
     client.shutdown();
 }
diff --git a/crates/client/tests/support/mock_edge.rs b/crates/client/tests/support/mock_edge.rs
index 17397d95cc..43c73bae89 100644
--- a/crates/client/tests/support/mock_edge.rs
+++ b/crates/client/tests/support/mock_edge.rs
@@ -19,6 +19,7 @@
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use futures::{SinkExt, StreamExt};
 use serde_json::json;
@@ -52,6 +53,10 @@ struct Shared {
     /// Refuse chat2 joins (outage simulation).
     refuse_chat: Mutex<bool>,
     relays: Mutex<HashMap<String, RelayState>>,
+    nudge_status: Mutex<u16>,
+    nudge_status_by_chat: Mutex<HashMap<String, u16>>,
+    nudges: Mutex<Vec<(String, usize)>>,
+    host_hints: Mutex<HashMap<String, String>>,
 }
 
 enum Out {
@@ -85,16 +90,88 @@ impl MockEdge {
             sockets: Mutex::new(HashMap::new()),
             refuse_chat: Mutex::new(false),
             relays: Mutex::new(HashMap::new()),
+            nudge_status: Mutex::new(200),
+            nudge_status_by_chat: Mutex::new(HashMap::new()),
+            nudges: Mutex::new(Vec::new()),
+            host_hints: Mutex::new(HashMap::new()),
         });
         let accept_shared = shared.clone();
         let task = tokio::spawn(async move {
             loop {
-                let Ok((stream, _)) = listener.accept().await else {
+                let Ok((mut stream, _)) = listener.accept().await else {
                     return;
                 };
                 let shared = accept_shared.clone();
                 let registry_url = registry_url.clone();
                 tokio::spawn(async move {
+                    let mut first = [0u8; 4];
+                    if stream.peek(&mut first).await.is_ok() && first[0] == b'P' {
+                        let mut request = Vec::new();
+                        let mut buf = [0u8; 4096];
+                        loop {
+                            let Ok(n) = stream.read(&mut buf).await else {
+                                return;
+                            };
+                            if n == 0 {
+                                return;
+                            }
+                            request.extend_from_slice(&buf[..n]);
+                            let Some(end) = request.windows(4).position(|b| b == b"\r\n\r\n")
+                            else {
+                                continue;
+                            };
+                            let headers = String::from_utf8_lossy(&request[..end]);
+                            let length = headers
+                                .lines()
+                                .find_map(|line| {
+                                    let (key, value) = line.split_once(':')?;
+                                    key.eq_ignore_ascii_case("content-length")
+                                        .then(|| value.trim().parse::<usize>().ok())
+                                        .flatten()
+                                })
+                                .unwrap_or(0);
+                            if request.len() < end + 4 + length {
+                                continue;
+                            }
+                            if headers
+                                .lines()
+                                .next()
+                                .is_some_and(|l| l.contains("/nudge "))
+                            {
+                                let mut nudge_chat = None;
+                                if let Ok(body) = serde_json::from_slice::<serde_json::Value>(
+                                    &request[end + 4..end + 4 + length],
+                                ) {
+                                    if let Some(chat) = body["chatId"].as_str() {
+                                        nudge_chat = Some(chat.to_owned());
+                                        let rows = shared
+                                            .rooms
+                                            .lock()
+                                            .unwrap()
+                                            .get(chat)
+                                            .map_or(0, |r| r.rows.len());
+                                        shared.nudges.lock().unwrap().push((chat.to_owned(), rows));
+                                    }
+                                }
+                                let status = nudge_chat
+                                    .as_ref()
+                                    .and_then(|chat| {
+                                        shared
+                                            .nudge_status_by_chat
+                                            .lock()
+                                            .unwrap()
+                                            .get(chat)
+                                            .copied()
+                                    })
+                                    .unwrap_or_else(|| *shared.nudge_status.lock().unwrap());
+                                let response = format!(
+                                    "HTTP/1.1 {status} Test\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{{}}"
+                                );
+                                let _ = stream.write_all(response.as_bytes()).await;
+                            }
+                            return;
+                        }
+                    }
                     let path = Arc::new(Mutex::new(String::new()));
                     let seen = path.clone();
                     let callback = move |request: &Request, response: Response| {
@@ -121,6 +198,13 @@ impl MockEdge {
                             if *shared.refuse_chat.lock().unwrap() {
                                 return;
                             }
+                            if let Some(host) = query.get("hostDevice") {
+                                shared
+                                    .host_hints
+                                    .lock()
+                                    .unwrap()
+                                    .insert(chat.to_string(), host.clone());
+                            }
                             serve_chat(ws, chat.to_string(), shared).await
                         }
                         _ => {}
@@ -136,6 +220,43 @@ impl MockEdge {
         }
     }
 
+    pub fn nudge_status(&self, status: u16) {
+        *self.shared.nudge_status.lock().unwrap() = status;
+    }
+
+    pub fn host_hint(&self, chat: &str) -> Option<String> {
+        self.shared.host_hints.lock().unwrap().get(chat).cloned()
+    }
+
+    pub fn nudge_status_for(&self, chat: &str, status: u16) {
+        self.shared
+            .nudge_status_by_chat
+            .lock()
+            .unwrap()
+            .insert(chat.to_owned(), status);
+    }
+
+    pub fn nudges(&self, chat: &str) -> usize {
+        self.shared
+            .nudges
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|(id, _)| id == chat)
+            .count()
+    }
+
+    pub fn last_nudge_row_count(&self, chat: &str) -> Option<usize> {
+        self.shared
+            .nudges
+            .lock()
+            .unwrap()
+            .iter()
+            .rev()
+            .find(|(id, _)| id == chat)
+            .map(|(_, rows)| *rows)
+    }
+
     pub fn edge_url(&self) -> String {
         format!("http://127.0.0.1:{}", self.port)
     }
diff --git a/crates/engine/src/chat2_host.rs b/crates/engine/src/chat2_host.rs
index 246ebbb3da..6974019eef 100644
--- a/crates/engine/src/chat2_host.rs
+++ b/crates/engine/src/chat2_host.rs
@@ -357,9 +357,15 @@ pub struct EdgeChatTransport {
     edge: EdgeConfig,
     chat_id: String,
     device_id: String,
+    host_device: Option<String>,
 }
 
 impl EdgeChatTransport {
+    pub fn with_host_device(mut self, host: Option<String>) -> Self {
+        self.host_device = host;
+        self
+    }
+
     pub fn with_priority(mut self, priority: zeron_sync::budget::Priority) -> Self {
         self.priority = priority;
         self
@@ -377,6 +383,7 @@ impl EdgeChatTransport {
             edge,
             chat_id: chat_id.into(),
             device_id: device_id.into(),
+            host_device: None,
         }
     }
 
@@ -430,14 +437,19 @@ impl zeron_sync::chat_client::ChatTransport for EdgeChatTransport {
         let edge = self.edge.clone();
         let url = self.rows_url();
         let device = self.device_id.clone();
+        let host = self.host_device.clone();
         Box::pin(async move {
             let _permit = zeron_sync::budget::shared().http(priority).await?;
             let bearer = edge.bearer().await.map_err(SyncError::from)?;
-            let res = http
+            let mut request = http
                 .post(&url)
                 .query(&[("batchId", batch_id), ("device", device)])
                 .bearer_auth(&bearer)
-                .body(bytes)
+                .body(bytes);
+            if let Some(host) = host {
+                request = request.query(&[("hostDevice", host)]);
+            }
+            let res = request
                 .send()
                 .await
                 .map_err(|e| SyncError::WebSocket(describe_http_error(e)))?;
diff --git a/crates/engine/src/doc_host.rs b/crates/engine/src/doc_host.rs
index b08e6e19a2..168be0bd9e 100644
--- a/crates/engine/src/doc_host.rs
+++ b/crates/engine/src/doc_host.rs
@@ -186,11 +186,20 @@ impl EdgeConfig {
     /// the bearer is re-fetched before every connect, so reconnects after a
     /// token expiry present a fresh `?token=` instead of the boot-time one.
     pub fn room_url(&self, path: impl Into<String>) -> Arc<dyn zeron_sync::UrlProvider> {
+        self.room_url_with_host(path, None)
+    }
+
+    fn room_url_with_host(
+        &self,
+        path: impl Into<String>,
+        host_device: Option<String>,
+    ) -> Arc<dyn zeron_sync::UrlProvider> {
         let ws_base = self.url.replacen("http", "ws", 1);
         Arc::new(EdgeRoomUrl {
             base: format!("{}{}", ws_base.trim_end_matches('/'), path.into()),
             token: self.token.clone(),
             device_id: self.device_id.clone(),
+            host_device,
         })
     }
 }
@@ -199,6 +208,7 @@ struct EdgeRoomUrl {
     base: String,
     token: Arc<dyn zeron_rpc::TokenSource>,
     device_id: String,
+    host_device: Option<String>,
 }
 
 impl zeron_sync::UrlProvider for EdgeRoomUrl {
@@ -206,12 +216,19 @@ impl zeron_sync::UrlProvider for EdgeRoomUrl {
         let token = self.token.clone();
         let base = self.base.clone();
         let device = self.device_id.clone();
+        let host = self.host_device.clone();
         Box::pin(async move {
             let token = token.token().await.map_err(zeron_sync::SyncError::from)?;
             let mut url = format!("{base}?token={token}");
             if !device.is_empty() {
                 url.push_str(&format!("&device={device}"));
             }
+            if let Some(host) = host {
+                let mut parsed = reqwest::Url::parse(&url)
+                    .map_err(|e| zeron_sync::SyncError::Protocol(e.to_string()))?;
+                parsed.query_pairs_mut().append_pair("hostDevice", &host);
+                url = parsed.into();
+            }
             Ok(url)
         })
     }
@@ -988,6 +1005,7 @@ impl DocHost {
         };
         if tokio::runtime::Handle::try_current().is_ok() {
             host.spawn_sync_scheduler();
+            host.spawn_remote_wake_delivery();
         }
         host
     }
@@ -2208,7 +2226,8 @@ impl DocHost {
                 edge.clone(),
                 chat.clone(),
             ).with_priority(priority));
-            let url = edge.room_url(format!("/chat2/{chat}/ws"));
+            let remote_host = host.remote_host_for(&chat);
+            let url = edge.room_url_with_host(format!("/chat2/{chat}/ws"), remote_host.clone());
             let mut wake = zeron_sync::wake::subscribe();
             // Sibling-dial successes end a backoff wait immediately, exactly
             // like the joined clients' own reconnect loops (chat_client.rs).
@@ -2233,7 +2252,7 @@ impl DocHost {
                     edge.clone(),
                     chat.clone(),
                     device.clone(),
-                ).with_priority(priority));
+                ).with_host_device(remote_host.clone()).with_priority(priority));
                 let dial = tokio::time::timeout(
                     std::time::Duration::from_secs(60),
                     zeron_sync::ChatClient::connect_via_transport(
@@ -3433,10 +3452,8 @@ impl DocHost {
         if is_message {
             self.unarchive_on_send(chat_id);
         }
-        // §7 durable delivery: when another device hosts this chat, nudge its device
-        // room so a cold host opens the doc and drains the queue. Fire-and-forget —
-        // the command is durable in the doc either way (a host that opens the chat
-        // for any other reason still executes it).
+        // The cold host must discover the command even after its room rows
+        // are ACKed. Persist that wake independently and recover it on restart.
         self.nudge_remote_host(chat_id);
         self.spawn_command_delivery(chat_id, entry, transfers);
         Ok(id)
@@ -4318,62 +4335,15 @@ impl DocHost {
         Ok(())
     }
 
-    /// POST `{edge}/device/{host}/nudge {chatId}` when the chat's workspace row names
-    /// another device as host. Best-effort: offline/edge-less engines skip silently.
+    /// Persist remote host discovery separately from the outgoing room rows.
+    /// A row ACK does not prove a cold host has been told to open its room.
     fn nudge_remote_host(&self, chat_id: &str) {
-        let Some(edge) = self.inner.config.edge.clone() else {
-            return;
-        };
-        let Some(workspace) = self.workspace() else {
-            return;
-        };
-        let host_device = match workspace.chat(chat_id) {
-            Ok(Some(chat)) => chat.device_id,
-            // Unclaimed chat: whoever drains first claims it — nobody to nudge.
-            _ => return,
-        };
-        if host_device == self.inner.config.device_id {
+        if self.inner.config.edge.is_none() || self.remote_host_for(chat_id).is_none() {
             return;
         }
-        // Only meaningful inside a runtime (RPC handlers, executors); bare sync
-        // callers (unit tests) skip rather than panic.
-        let Ok(runtime) = tokio::runtime::Handle::try_current() else {
-            return;
-        };
-        let url = format!(
-            "{}/device/{}/nudge",
-            edge.url.trim_end_matches('/'),
-            host_device
-        );
-        let chat = chat_id.to_string();
-        self.spawn_worker_on(&runtime, async move {
-            // Fresh bearer per request — never the boot-time snapshot.
-            let bearer = match edge.bearer().await {
-                Ok(bearer) => bearer,
-                Err(err) => {
-                    tracing::warn!(chat = %chat, error = %err, "nudge skipped: token unavailable");
-                    return;
-                }
-            };
-            let send = reqwest::Client::new()
-                .post(&url)
-                .bearer_auth(&bearer)
-                .json(&serde_json::json!({ "chatId": chat }))
-                .timeout(std::time::Duration::from_secs(10))
-                .send()
-                .await;
-            match send {
-                Ok(res) if res.status().is_success() => {
-                    tracing::info!(chat = %chat, device = %host_device, "host nudged");
-                }
-                Ok(res) => tracing::warn!(chat = %chat, device = %host_device,
-                    status = res.status().as_u16(), "nudge rejected"),
-                Err(err) => {
-                    let err = describe_http_error(err);
-                    tracing::warn!(chat = %chat, error = %err, "nudge failed (best-effort)")
-                }
-            }
-        });
+        if let Err(err) = self.inner.store.schedule_sync_job(chat_id, "remote-wake") {
+            tracing::warn!(chat = %chat_id, %err, "remote host wake persistence failed");
+        }
     }
 
     /// The chat's host device when it is NOT this engine (mirrors
@@ -6726,3 +6696,6 @@ mod publication_eviction_tests {
 #[cfg(test)]
 #[path = "doc_host_sync_tests.rs"]
 mod sync_lifecycle_tests;
+
+#[path = "doc_host_delivery.rs"]
+mod remote_delivery;
diff --git a/crates/engine/src/doc_host_delivery.rs b/crates/engine/src/doc_host_delivery.rs
new file mode 100644
index 0000000000..4ed3f6ee2a
--- /dev/null
+++ b/crates/engine/src/doc_host_delivery.rs
@@ -0,0 +1,341 @@
+//! Durable host discovery for desktop senders. The chat2 outbox already
+//! recovers rows on restart; a separate receipt recovers the host wake even
+//! when those rows have been acknowledged and their room is cold.
+
+use super::*;
+
+impl DocHost {
+    pub(super) fn spawn_remote_wake_delivery(&self) {
+        if self.inner.config.edge.is_none() {
+            return;
+        }
+        let weak = Arc::downgrade(&self.inner);
+        self.spawn_worker(async move {
+            let mut tasks = tokio::task::JoinSet::new();
+            let mut active = HashSet::new();
+            let mut after = String::new();
+            loop {
+                while let Some(result) = tasks.try_join_next() {
+                    if let Ok(chat) = result {
+                        active.remove(&chat);
+                    }
+                }
+                let Some(inner) = weak.upgrade() else { return };
+                let host = DocHost { inner };
+                if host.workspace().is_some()
+                    && host.inner.config.edge.is_some()
+                    && !host.inner.edge_disconnected.load(Ordering::Acquire)
+                    && active.len() < 8
+                {
+                    match host
+                        .inner
+                        .store
+                        .pending_sync_jobs("remote-wake", &after, 32)
+                    {
+                        Ok(page) => {
+                            if page.is_empty() {
+                                after.clear();
+                            }
+                            for chat in page {
+                                if active.len() >= 8 {
+                                    break;
+                                }
+                                after = chat.clone();
+                                if !active.insert(chat.clone()) {
+                                    continue;
+                                }
+                                let weak = weak.clone();
+                                tasks.spawn(async move {
+                                    // Yield stalled obligations so eight dead peers cannot
+                                    // indefinitely block later chats on healthy hosts.
+                                    let _ = tokio::time::timeout(
+                                        std::time::Duration::from_secs(12),
+                                        deliver(weak, &chat),
+                                    )
+                                    .await;
+                                    chat
+                                });
+                            }
+                        }
+                        Err(err) => tracing::warn!(%err, "remote wake discovery failed"),
+                    }
+                }
+                drop(host);
+                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+            }
+        });
+    }
+}
+
+async fn deliver(weak: std::sync::Weak<DocHostInner>, chat: &str) {
+    let mut backoff = std::time::Duration::from_millis(500);
+    loop {
+        let Some(inner) = weak.upgrade() else { return };
+        let host = DocHost { inner };
+        let Ok(Some(version)) = host.inner.store.sync_job_version(chat, "remote-wake") else {
+            return;
+        };
+        let Some(edge) = host.inner.config.edge.clone() else {
+            return;
+        };
+        if host.inner.edge_disconnected.load(Ordering::Acquire) {
+            return;
+        }
+        let Some(target) = host.remote_host_for(chat) else {
+            // Registry loading can precede a restored remote row. Only
+            // retire deleted/local targets after registry catch-up.
+            if host
+                .workspace()
+                .is_some_and(|w| w.sync_status().is_some_and(|s| s.synced))
+            {
+                let _ = host
+                    .inner
+                    .store
+                    .complete_sync_job(chat, "remote-wake", version);
+                return;
+            }
+            drop(host);
+            tokio::time::sleep(backoff).await;
+            continue;
+        };
+        let rows_flushed = host.inner.store.has_pending_chat_updates(chat).ok() == Some(false);
+        let sent = async {
+            let bearer = edge.bearer().await?;
+            let url = format!("{}/device/{target}/nudge", edge.url.trim_end_matches('/'));
+            host.inner
+                .http
+                .post(url)
+                .bearer_auth(bearer)
+                .json(&serde_json::json!({ "chatId": chat }))
+                .timeout(std::time::Duration::from_secs(10))
+                .send()
+                .await
+                .map_err(|err| EngineError::Other(describe_http_error(err)))
+        }
+        .await;
+        let accepted = match sent {
+            Ok(response) if response.status().is_success() => true,
+            // Another owner's device (403) or a chat id its room refuses
+            // (400): no retry can change that, so the wake is settled.
+            // Unclaimed (404: not connected yet) and 5xx retry.
+            Ok(response) if matches!(response.status().as_u16(), 400 | 403) => {
+                tracing::warn!(%chat, device = %target, status = response.status().as_u16(), "remote host wake refused; not retrying");
+                true
+            }
+            Ok(response) => {
+                tracing::debug!(%chat, device = %target, status = response.status().as_u16(), "remote host wake retrying");
+                false
+            }
+            Err(err) => {
+                tracing::debug!(%chat, device = %target, %err, "remote host wake retrying");
+                false
+            }
+        };
+        if rows_flushed
+            && accepted
+            && host.inner.store.has_pending_chat_updates(chat).ok() == Some(false)
+        {
+            match host
+                .inner
+                .store
+                .complete_sync_job(chat, "remote-wake", version)
+            {
+                Ok(())
+                    if host.inner.store.sync_job_version(chat, "remote-wake").ok()
+                        == Some(None) =>
+                {
+                    return;
+                }
+                Ok(()) => {}
+                Err(err) => tracing::warn!(%err, %chat, "remote wake completion failed"),
+            }
+        }
+        drop(host);
+        let mut wake = zeron_sync::wake::subscribe();
+        let mut online = zeron_sync::wake::subscribe_online();
+        tokio::select! {
+            _ = tokio::time::sleep(backoff) => {},
+            _ = wake.recv() => {},
+            _ = online.recv() => {},
+        }
+        backoff = (backoff * 2).min(std::time::Duration::from_secs(16));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[tokio::test]
+    async fn remote_chat_transports_carry_the_host_on_both_paths() {
+        use zeron_sync::chat_client::ChatTransport;
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let edge = EdgeConfig::with_static_token(
+            format!("http://{}", listener.local_addr().unwrap()),
+            "test",
+        )
+        .with_device("sender");
+        let url = edge
+            .room_url_with_host("/chat2/chat/ws", Some("remote-host".into()))
+            .url()
+            .await
+            .unwrap();
+        let url = reqwest::Url::parse(&url).unwrap();
+        assert!(
+            url.query_pairs()
+                .any(|(key, value)| key == "hostDevice" && value == "remote-host")
+        );
+        let server = tokio::spawn(async move {
+            let (mut stream, _) = listener.accept().await.unwrap();
+            let mut request = Vec::new();
+            let mut buf = [0; 4096];
+            loop {
+                let n = stream.read(&mut buf).await.unwrap();
+                assert!(n > 0);
+                request.extend_from_slice(&buf[..n]);
+                if request.windows(4).any(|b| b == b"\r\n\r\n") {
+                    break;
+                }
+            }
+            let request = String::from_utf8_lossy(&request);
+            let line = request.lines().next().unwrap();
+            assert!(line.contains("hostDevice=remote-host"), "{line}");
+            assert!(line.contains("device=sender"), "{line}");
+            stream
+                .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}")
+                .await
+                .unwrap();
+        });
+        crate::chat2_host::EdgeChatTransport::new(reqwest::Client::new(), edge, "chat", "sender")
+            .with_host_device(Some("remote-host".into()))
+            .push("batch".into(), vec![1])
+            .await
+            .unwrap();
+        server.await.unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn failed_remote_wake_survives_row_ack_and_host_restart() {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let edge = format!("http://{}", listener.local_addr().unwrap());
+        let attempts = Arc::new(AtomicUsize::new(0));
+        let status = Arc::new(AtomicUsize::new(500));
+        let count = attempts.clone();
+        let code = status.clone();
+        let server = tokio::spawn(async move {
+            loop {
+                let (mut stream, _) = listener.accept().await.unwrap();
+                let count = count.clone();
+                let code = code.clone();
+                tokio::spawn(async move {
+                    let mut request = Vec::new();
+                    let mut buf = [0; 4096];
+                    loop {
+                        let n = stream.read(&mut buf).await.unwrap();
+                        if n == 0 {
+                            return;
+                        }
+                        request.extend_from_slice(&buf[..n]);
+                        if request.windows(4).any(|s| s == b"\r\n\r\n") {
+                            break;
+                        }
+                    }
+                    assert!(
+                        String::from_utf8_lossy(&request).starts_with("POST /device/remote/nudge ")
+                    );
+                    count.fetch_add(1, Ordering::SeqCst);
+                    let response = format!(
+                        "HTTP/1.1 {} Test\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+                        code.load(Ordering::SeqCst)
+                    );
+                    let _ = stream.write_all(response.as_bytes()).await;
+                });
+            }
+        });
+        let dir = tempfile::tempdir().unwrap();
+        let store = Arc::new(DocsStore::open(dir.path()).unwrap());
+        let workspace = WorkspaceHost::open(
+            store.clone(),
+            crate::workspace_host::WorkspaceHostConfig {
+                device_id: "sender".into(),
+                device_name: "Sender".into(),
+                platform: "linux".into(),
+                org_id: "org".into(),
+                user_id: "user".into(),
+                edge: None,
+                local_only: false,
+            },
+        )
+        .unwrap();
+        workspace
+            .create_chat("outgoing", None, Some("remote"), None, None)
+            .unwrap();
+        let config = DocHostConfig {
+            device_id: "sender".into(),
+            default_harness: HarnessId::Mock,
+            edge: Some(EdgeConfig::with_static_token(&edge, "test")),
+        };
+        let host = DocHost::new(store.clone(), config.clone());
+        host.set_workspace(workspace.clone());
+        store
+            .enqueue_chat_update("outgoing", "acked-row", b"command bytes")
+            .unwrap();
+        host.nudge_remote_host("outgoing");
+        store
+            .acknowledge_chat_update("outgoing", "acked-row")
+            .unwrap();
+        tokio::time::timeout(std::time::Duration::from_secs(5), async {
+            while attempts.load(Ordering::SeqCst) < 2 {
+                tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+            }
+        })
+        .await
+        .expect("failed wake was not retried");
+        assert!(
+            store
+                .sync_job_version("outgoing", "remote-wake")
+                .unwrap()
+                .is_some()
+        );
+        assert!(
+            !store.has_pending_chat_updates("outgoing").unwrap(),
+            "row delivery and wake delivery are independent"
+        );
+        host.shutdown_workers().await;
+        workspace.flush();
+        let attempts_before = attempts.load(Ordering::SeqCst);
+        status.store(200, Ordering::SeqCst);
+        let reopened = Arc::new(DocsStore::open(dir.path()).unwrap());
+        let restarted = DocHost::new(reopened.clone(), config);
+        let restored_workspace = WorkspaceHost::open(
+            reopened.clone(),
+            crate::workspace_host::WorkspaceHostConfig {
+                device_id: "sender".into(),
+                device_name: "Sender".into(),
+                platform: "linux".into(),
+                org_id: "org".into(),
+                user_id: "user".into(),
+                edge: None,
+                local_only: false,
+            },
+        )
+        .unwrap();
+        restarted.set_workspace(restored_workspace);
+        tokio::time::timeout(std::time::Duration::from_secs(5), async {
+            while reopened
+                .sync_job_version("outgoing", "remote-wake")
+                .unwrap()
+                .is_some()
+            {
+                tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+            }
+        })
+        .await
+        .expect("wake was not recovered after restart");
+        assert!(attempts.load(Ordering::SeqCst) > attempts_before);
+        restarted.shutdown_workers().await;
+        server.abort();
+    }
+}
diff --git a/crates/sync/src/sync_jobs.rs b/crates/sync/src/sync_jobs.rs
index 4347a9be6c..dfe09a3ed3 100644
--- a/crates/sync/src/sync_jobs.rs
+++ b/crates/sync/src/sync_jobs.rs
@@ -114,6 +114,27 @@ impl DocsStore {
         })
     }
 
+    /// Thin-client delivery discovery includes an unacknowledged host wake
+    /// even after the room has ACKed every outgoing row.
+    pub fn pending_viewer_deliveries(
+        &self,
+        after: &str,
+        limit: usize,
+    ) -> Result<Vec<String>, StoreError> {
+        store_blocking(|| {
+            let conn = self.conn();
+            let mut q = conn.prepare(
+                "SELECT doc_id FROM (SELECT doc_id FROM chat_outbox
+                  UNION SELECT doc_id FROM chat_sync_jobs WHERE kind='viewer-delivery')
+                 WHERE doc_id>?1 ORDER BY doc_id LIMIT ?2",
+            )?;
+            Ok(
+                q.query_map(params![after, limit.min(64) as i64], |r| r.get(0))?
+                    .collect::<Result<_, _>>()?,
+            )
+        })
+    }
+
     pub fn pending_sync_docs(&self, after: &str, limit: usize) -> Result<Vec<String>, StoreError> {
         store_blocking(|| {
             let conn = self.conn();
@@ -133,6 +154,52 @@ impl DocsStore {
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[test]
+    fn viewer_discovery_retains_acked_wakes_and_pages_without_duplicates() {
+        let dir = tempfile::tempdir().unwrap();
+        let store = DocsStore::open(dir.path()).unwrap();
+        for n in 0..80 {
+            let id = format!("chat-{n:03}");
+            store.schedule_sync_job(&id, "viewer-delivery").unwrap();
+            store
+                .enqueue_chat_update(&id, &format!("batch-{n}"), b"bytes")
+                .unwrap();
+        }
+        store
+            .acknowledge_chat_update("chat-000", "batch-0")
+            .unwrap();
+        drop(store);
+        let store = DocsStore::open(dir.path()).unwrap();
+        let first = store.pending_viewer_deliveries("", 100).unwrap();
+        assert_eq!(first.len(), 64);
+        assert_eq!(first[0], "chat-000", "ACKed rows still owe a wake");
+        let last = store
+            .pending_viewer_deliveries(first.last().unwrap(), 100)
+            .unwrap();
+        assert_eq!(last.len(), 16);
+        let old = store
+            .sync_job_version("chat-000", "viewer-delivery")
+            .unwrap()
+            .unwrap();
+        store
+            .schedule_sync_job("chat-000", "viewer-delivery")
+            .unwrap();
+        store
+            .complete_sync_job("chat-000", "viewer-delivery", old)
+            .unwrap();
+        assert!(
+            store
+                .sync_job_version("chat-000", "viewer-delivery")
+                .unwrap()
+                .is_some()
+        );
+        store.delete_snapshot("chat-000").unwrap();
+        assert_eq!(
+            store.pending_viewer_deliveries("", 1).unwrap(),
+            vec!["chat-001"]
+        );
+    }
+
     #[test]
     fn reconciliation_resumes_and_new_requests_fence_old_completion() {
         let dir = tempfile::tempdir().unwrap();
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 79a6e7c6b1..cf52c0992a 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -10,7 +10,9 @@ voice-experimental = [] # Compatibility flag; native subscription voice uses Cod
 project-palette-fixture = []
 compact-picker-fixture = ["gpui_platform/test-support"]
 
-browser-fixture = []
+# Native captures explicitly present the freshly drawn scene, including when
+# a nested Wayland compositor has stopped requesting idle frames.
+browser-fixture = ["gpui/bench"]
 windows-render-fixture = []
 appshots-fixture = ["gpui_platform/test-support"]
 resource-profile = ["gpui/bench", "gpui_platform/test-support"]
diff --git a/crates/ui/examples/browser-fixture.rs b/crates/ui/examples/browser-fixture.rs
index 94fe48619f..cb2464dc73 100644
--- a/crates/ui/examples/browser-fixture.rs
+++ b/crates/ui/examples/browser-fixture.rs
@@ -64,6 +64,31 @@ fn capture(directory: &std::path::Path, name: &str) -> anyhow::Result<()> {
     Ok(())
 }
 
+// The Linux frame loop can be idle while the fixture's async task changes
+// theme/page state. Present the current scene before reading native pixels.
+async fn capture_frame(
+    window: gpui::WindowHandle<shell::Shell>,
+    directory: &std::path::Path,
+    name: &str,
+    cx: &mut AsyncApp,
+) -> anyhow::Result<()> {
+    #[cfg(target_os = "linux")]
+    {
+        linux::wait_for_visible_window(cx).await?;
+        gpui::AnyWindowHandle::from(window).update(cx, |_, w, cx| {
+            w.refresh();
+            let arena = w.draw(cx);
+            w.present_if_needed();
+            arena.clear();
+        })?;
+        // Let the nested compositor present the submitted native frame.
+        pause(cx, 50).await;
+    }
+    #[cfg(not(target_os = "linux"))]
+    let _ = (window, cx);
+    capture(directory, name)
+}
+
 #[cfg(any(target_os = "macos", target_os = "linux"))]
 fn validate_blur(
     directory: &std::path::Path,
@@ -210,7 +235,7 @@ fn main() -> anyhow::Result<()> {
                 });
                 let (first_id, first) = window.update(cx, |shell, w, cx| shell.fixture_open_browser(None, w, cx))?;
                 pause(cx, 500).await;
-                capture(&output, "browser-empty-dark")?;
+                capture_frame(window, &output, "browser-empty-dark", cx).await?;
                 #[cfg(any(target_os = "macos", target_os = "linux"))]
                 {
                     window.update(cx, |_, w, cx| first.update(cx, |b, cx| b.navigate(&_origin, w, cx)))?;
@@ -220,7 +245,7 @@ fn main() -> anyhow::Result<()> {
                         pause(cx, 50).await;
                     }
                     pause(cx, 500).await;
-                    capture(&output, "browser-preview-dark")?;
+                    capture_frame(window, &output, "browser-preview-dark", cx).await?;
                     // Real DOM click, native navigation and history.
                     first.read_with(cx, |b, _| b.fixture_eval("document.getElementById('details').click()"));
                     let deadline = std::time::Instant::now() + Duration::from_secs(15);
@@ -290,7 +315,7 @@ fn main() -> anyhow::Result<()> {
                     anyhow::ensure!(first.read_with(cx, |b,_| b.fixture_overlay_visible()), "toolbar tooltip did not paint on the overlay plane");
                     anyhow::ensure!(first.read_with(cx, |b,_| b.fixture_focused() && !b.fixture_overlay_at((left+100.) as f64,(top+100.) as f64)), "tooltip stole native focus or page hit testing");
                     anyhow::ensure!(first.read_with(cx, |b,_| b.fixture_visibility_changes() == before), "tooltip hid the page");
-                    capture(&output, "browser-tooltip-dark")?;
+                    capture_frame(window, &output, "browser-tooltip-dark", cx).await?;
                     // Also dwell on the tab itself: its URL tooltip is the
                     // original reported flicker case, distinct from toolbar hover.
                     for _ in 0..2 {
@@ -314,7 +339,7 @@ fn main() -> anyhow::Result<()> {
                     anyhow::ensure!(first.read_with(cx, |b,_| b.fixture_native_visible()), "menu froze or hid the live page");
                     anyhow::ensure!(first.read_with(cx, |b,_| b.fixture_overlay_at((left+100.) as f64,(top+150.) as f64)), "menu failed to intercept outside clicks above the browser");
                     std::fs::write(output.join("backdrop-layers.txt"),first.read_with(cx,|b,_|b.fixture_backdrop_layers()))?;
-                    capture(&output, "browser-menu-dark")?;
+                    capture_frame(window, &output, "browser-menu-dark", cx).await?;
                     first.read_with(cx, |b,_| b.fixture_eval("document.addEventListener('click', () => { document.title = 'Unexpected page click'; })"));
                     pause(cx, 100).await;
                     first.read_with(cx, |b,_| b.fixture_click((left+100.) as f64,(top+150.) as f64));
@@ -331,7 +356,7 @@ fn main() -> anyhow::Result<()> {
                 }
                 #[cfg(not(target_os = "macos"))]
                 {
-                    capture(&output, "browser-menu-dark")?;
+                    capture_frame(window, &output, "browser-menu-dark", cx).await?;
                     window.update(cx, |shell, _, cx| shell.fixture_browser_menu(false, cx))?;
                 }
                 pause(cx, 500).await;
@@ -397,7 +422,7 @@ fn main() -> anyhow::Result<()> {
                         }
                         anyhow::ensure!(std::time::Instant::now()<deadline,"viewport measurement timed out");pause(cx,50).await;
                     }
-                    capture(&output,"browser-resize-dark")?;
+                    capture_frame(window, &output, "browser-resize-dark", cx).await?;
                     eprintln!("Browser fixture: resize drag and CSS viewport passed");
                     // Left sidebar does not occlude the browser at any point.
                     for _ in 0..4 {
@@ -428,24 +453,24 @@ fn main() -> anyhow::Result<()> {
                     pause(cx,350).await;
                     first.read_with(cx,|b,_|b.fixture_eval("document.title='Fieldnotes'"));
                     eprintln!("Browser fixture: right sidebar transitions passed");
-                    capture(&output,"browser-blur-baseline-dark")?;
+                    capture_frame(window, &output, "browser-blur-baseline-dark", cx).await?;
                     window.update(cx,|s,_,cx|s.fixture_browser_menu(true,cx))?;
                     pause(cx,1000).await;
                     let regions=first.read_with(cx,|b,_|b.fixture_backdrops());
                     anyhow::ensure!(!regions.is_empty(),"menu has no native browser backdrop");
                     std::fs::write(output.join("blur-regions.json"),serde_json::to_string(&regions)?)?;
-                    capture(&output,"browser-blur-dark")?;
+                    capture_frame(window, &output, "browser-blur-dark", cx).await?;
                     cx.update(|cx|appearance::set_mode(appearance::AppearanceMode::Light,cx));
                     pause(cx,700).await;
-                    capture(&output,"browser-blur-light")?;
+                    capture_frame(window, &output, "browser-blur-light", cx).await?;
                     first.read_with(cx,|b,_|b.fixture_eval("document.getElementById('browser-blur-grid').style.background='#263d35'"));
                     pause(cx,500).await;
-                    capture(&output,"browser-blur-solid-light")?;
+                    capture_frame(window, &output, "browser-blur-solid-light", cx).await?;
                     let window_width=gpui::AnyWindowHandle::from(window).update(cx,|_,w,_|f32::from(w.viewport_size().width))?;
                     cx.update(|cx|appearance::set_surface(zeron_theme::SurfacePreference::Opaque,cx));
                     pause(cx,500).await;
                     anyhow::ensure!(first.read_with(cx,|b,_|b.fixture_backdrops().is_empty()),"opaque appearance retained native blur");
-                    capture(&output,"browser-menu-opaque")?;
+                    capture_frame(window, &output, "browser-menu-opaque", cx).await?;
                     cx.update(|cx| {appearance::set_mode(appearance::AppearanceMode::Dark,cx);appearance::set_surface(zeron_theme::SurfacePreference::Frosted,cx);});
                     window.update(cx,|s,_,cx|s.fixture_browser_menu(false,cx))?;
                     pause(cx,500).await;
@@ -469,7 +494,7 @@ fn main() -> anyhow::Result<()> {
                 window.update(cx, |shell, _, cx| shell.fixture_expand_browser(cx))?;
                 cx.update(|cx| appearance::set_mode(appearance::AppearanceMode::Light, cx));
                 pause(cx, 600).await;
-                capture(&output, "browser-light")?;
+                capture_frame(window, &output, "browser-light", cx).await?;
                 #[cfg(any(target_os = "macos", target_os = "linux"))]
                 {
                     anyhow::ensure!(first.read_with(cx, |b, _| b.fixture_native_visible()), "page not restored after overlays/takeover");
@@ -484,7 +509,7 @@ fn main() -> anyhow::Result<()> {
                     while !first.read_with(cx, |b, _| b.page.error.is_some()) {
                         anyhow::ensure!(std::time::Instant::now() < deadline, "load failure was not reported: {:?}", first.read_with(cx, |b, _| b.page.clone())); pause(cx, 50).await;
                     }
-                    pause(cx, 300).await; capture(&output, "browser-error-light")?;
+                    pause(cx, 300).await; capture_frame(window, &output, "browser-error-light", cx).await?;
                 }
                 // Reject arbitrary schemes while preserving the existing page.
                 let before = first.read_with(cx, |b, _| b.page.url.clone());
diff --git a/crates/ui/examples/browser-fixture/linux.rs b/crates/ui/examples/browser-fixture/linux.rs
index eebaee31bf..4282bbe16c 100644
--- a/crates/ui/examples/browser-fixture/linux.rs
+++ b/crates/ui/examples/browser-fixture/linux.rs
@@ -4,6 +4,35 @@ use gpui::{
 };
 use zeron_ui::browser::BrowserSurface;
 
+/// The first software-rendered frame can take longer than the fixture's
+/// initial pause on a loaded runner. Yield to GPUI until X11 maps the window;
+/// blocking this thread would prevent the frame we're waiting for.
+pub(super) async fn wait_for_visible_window(cx: &mut AsyncApp) -> anyhow::Result<()> {
+    // Wayland captures the already-mapped nested compositor's X11 window.
+    if std::env::var("ZERON_BROWSER_CAPTURE_WINDOW").is_ok_and(|id| !id.is_empty()) {
+        return Ok(());
+    }
+    let deadline = std::time::Instant::now() + Duration::from_secs(10);
+    loop {
+        let windows = std::process::Command::new("xdotool")
+            .args([
+                "search",
+                "--onlyvisible",
+                "--pid",
+                &std::process::id().to_string(),
+            ])
+            .output()?;
+        if windows.status.success() && !windows.stdout.is_empty() {
+            return Ok(());
+        }
+        anyhow::ensure!(
+            std::time::Instant::now() < deadline,
+            "fixture window did not become visible within 10 seconds"
+        );
+        pause(cx, 50).await;
+    }
+}
+
 async fn eval(
     page: &Entity<BrowserSurface>,
     script: &str,
@@ -229,7 +258,7 @@ pub async fn exercise(
         })
     })?;
     pause(cx, 100).await;
-    capture(output, "linux-ime-dark")?;
+    capture_frame(window, output, "linux-ime-dark", cx).await?;
     window.update(cx, |_, w, cx| {
         page.update(cx, |b, cx| {
             gpui::EntityInputHandler::replace_text_in_range(b, None, "日本語", w, cx)
@@ -257,7 +286,7 @@ pub async fn exercise(
         page.read_with(cx, |b, _| b.fixture_linux_menu_open()),
         "HTML select did not open a GPUI menu"
     );
-    capture(output, "linux-select-dark")?;
+    capture_frame(window, output, "linux-select-dark", cx).await?;
     for key in ["down", "enter"] {
         dispatch(
             window,
@@ -300,7 +329,7 @@ pub async fn exercise(
         page.read_with(cx, |b, _| b.fixture_linux_menu_open()),
         "context menu did not open in GPUI"
     );
-    capture(output, "linux-context-dark")?;
+    capture_frame(window, output, "linux-context-dark", cx).await?;
     dispatch(
         window,
         PlatformInput::KeyDown(gpui::KeyDownEvent {
@@ -345,7 +374,7 @@ pub async fn exercise(
         cx,
     )?;
     pause(cx, 800).await;
-    capture(output, "linux-tooltip-dark")?;
+    capture_frame(window, output, "linux-tooltip-dark", cx).await?;
     let button=eval(&page,"(()=>{let r=document.getElementById('browser-button').getBoundingClientRect();return [r.x+15,r.y+10]})()",cx).await?;
     click(
         window,
@@ -437,7 +466,7 @@ pub async fn exercise(
         (width - layout as f64).abs() < 2.,
         "CSS viewport {width} differs from GPUI {layout}"
     );
-    capture(output, "linux-resize-dark")?;
+    capture_frame(window, output, "linux-resize-dark", cx).await?;
     for _ in 0..4 {
         window.update(cx, |s, _, cx| s.fixture_toggle_sidebar(false, cx))?;
         pause(cx, 400).await;
@@ -469,7 +498,7 @@ pub async fn exercise(
         "reopened sidebar lost browser"
     );
     cx.update(|cx| appearance::set_surface(zeron_theme::SurfacePreference::Frosted, cx));
-    capture(output, "browser-blur-baseline-dark")?;
+    capture_frame(window, output, "browser-blur-baseline-dark", cx).await?;
     window.update(cx, |s, _, cx| s.fixture_browser_menu(true, cx))?;
     pause(cx, 700).await;
     let presses = eval(&page, "window.pagePresses||0", cx).await?;
@@ -500,10 +529,10 @@ pub async fn exercise(
     );
     window.update(cx, |s, _, cx| s.fixture_browser_menu(true, cx))?;
     pause(cx, 500).await;
-    capture(output, "browser-blur-dark")?;
+    capture_frame(window, output, "browser-blur-dark", cx).await?;
     cx.update(|cx| appearance::set_mode(appearance::AppearanceMode::Light, cx));
     pause(cx, 500).await;
-    capture(output, "browser-blur-light")?;
+    capture_frame(window, output, "browser-blur-light", cx).await?;
     eval(
         &page,
         "document.getElementById('browser-blur-grid').style.background='#263d35'",
@@ -511,10 +540,10 @@ pub async fn exercise(
     )
     .await?;
     pause(cx, 300).await;
-    capture(output, "browser-blur-solid-light")?;
+    capture_frame(window, output, "browser-blur-solid-light", cx).await?;
     cx.update(|cx| appearance::set_surface(zeron_theme::SurfacePreference::Opaque, cx));
     pause(cx, 300).await;
-    capture(output, "browser-menu-opaque")?;
+    capture_frame(window, output, "browser-menu-opaque", cx).await?;
     let bounds = page.read_with(cx, |b, _| b.fixture_linux_bounds());
     let viewport =
         AnyWindowHandle::from(window).update(cx, |_, w, _| f32::from(w.viewport_size().width))?;
diff --git a/crates/ui/examples/browser-fixture/transcript_links.rs b/crates/ui/examples/browser-fixture/transcript_links.rs
index f27d612a36..12f7246fdf 100644
--- a/crates/ui/examples/browser-fixture/transcript_links.rs
+++ b/crates/ui/examples/browser-fixture/transcript_links.rs
@@ -54,11 +54,14 @@ async fn screenshot(
     name: &str,
     cx: &mut AsyncApp,
 ) -> anyhow::Result<()> {
-    // Synthetic key/focus dispatch updates hit testing synchronously. Request
-    // a presented frame too, especially when Wayland's frame loop is idle.
-    window.update(cx, |_, w, _| w.on_next_frame(|window, _| window.refresh()))?;
-    pause(cx, 250).await;
-    capture(output, name)
+    #[cfg(target_os = "linux")]
+    return capture_frame(window, output, name, cx).await;
+    #[cfg(not(target_os = "linux"))]
+    {
+        window.update(cx, |_, w, _| w.on_next_frame(|window, _| window.refresh()))?;
+        pause(cx, 250).await;
+        capture(output, name)
+    }
 }
 
 pub(super) async fn exercise(
diff --git a/docs/remote-send-delivery.md b/docs/remote-send-delivery.md
new file mode 100644
index 0000000000..befd979ce1
--- /dev/null
+++ b/docs/remote-send-delivery.md
@@ -0,0 +1,184 @@
+# Remote sends, cold hosts, and mobile suspension
+
+Investigation base: upstream `9e1a1115` (2026-10-03).
+
+## Report and probable cause
+
+The report describes a mobile send that looks active immediately, a new chat
+appearing on the desktop before execution starts, a delay of roughly 5–20+
+seconds, and occasional failures when the iOS app is closed before the first
+output. It was observed mainly with Codex, also with Cursor and Devin; Windows
+was suspected as the host platform.
+
+The inspected code contains a delivery failure mechanism matching these
+symptoms. This is not proof that every reported delay has this cause: no logs
+from the reporting devices were available, and provider startup can contribute
+additional latency.
+
+Before the fix, a remote send had three independently scheduled effects:
+
+1. The workspace registry publishes the new chat and its host/configuration.
+2. The session document publishes the Run/Steer command or queued message.
+3. A POST to the host's device room durably tells the host to discover that
+   document. The edge persists the nudge; the host persists its own discovery
+   receipt before acknowledging it.
+
+Seeing the chat in the registry proves only the first effect. A chat2 row ACK
+proves that the edge stored the bytes, not that a cold host opened the room or
+that a provider began executing.
+
+Before this fix:
+
+- `ClientInner::nudge_host` waited up to 50 × 100 ms for **all** pending registry
+  writes before attempting the wake. Unrelated writes could delay an existing
+  chat too. Hosts already support the wake-before-CreateChat race: missing rows
+  default to chat2, and wake admission is durable.
+- Only HTTP 503 received retries (three total attempts). Network errors, most
+  server errors, and token retrieval failures silently ended the wake task.
+- The phone's wake task had no persistent receipt. Suspension or termination
+  before its request completed could strand a command whose row was already
+  durably stored on the edge.
+- Thin-client relaunch restored the workspace but started chat rooms only when
+  opened or preloaded. An unopened chat outbox did not resume automatically.
+- The session and workspace derived Working from an unadopted Sending command.
+  Thus the UI could imply provider activity before any host acknowledgement.
+- The desktop sender also posted a best-effort wake, without recovery after an
+  error or restart. Its transcript already distinguished Sending from a turn.
+
+There is also a distinct host-owned startup phase. `SessionsEngine::dispatch_inner`
+records a run and publishes Working before `drive_run` waits for a harness
+execution/update lease and calls `harness.run`. That initialization can delay the
+first output, but the task belongs to the host and does not depend on an open
+viewer. Working therefore means the host owns the turn, not that the provider
+has already emitted its first token. The fix does not promise to remove provider
+boot, model discovery, installation, or network latency.
+
+These paths are outside provider-specific harnesses and host-platform branches.
+The failure mechanism can affect iOS/iPadOS and other frontends using
+`zeron-client`, with Linux, macOS, or Windows execution hosts, and desktop-to-
+desktop remote sends using the engine. The tests vary host platform metadata
+and RunRequest harness selection; they are not native Windows/macOS/iOS runs.
+
+## Fix and delivery boundary
+
+Thin-client session writes first persist the registry row needed to recover the
+chat. A versioned `viewer-delivery` job records the outstanding host wake.
+Discovery pages the union of that job set and the existing chat outbox, resumes
+rooms without a UI open, and retries wake requests with fresh credentials and
+bounded backoff. Opening an older persisted unadopted send also re-arms a wake.
+
+Desktop remote sends record an independent `remote-wake` job. The engine resumes
+those jobs after workspace restoration while its existing sync scheduler
+continues to recover outgoing document rows.
+
+Both senders may wake immediately, but retire a receipt only after:
+
+1. outgoing document rows were acknowledged **before** the final wake request;
+2. the edge accepted that wake with a successful HTTP response;
+3. the outbox remains empty and the captured job version still matches.
+
+A wake sent before publication can catch up to an empty room. Requiring a final
+post-ACK wake closes that ordering race. Conditional completion prevents a slow
+old request from erasing a newer send. No command is re-minted: existing command
+IDs, Loro imports, and the host's processed-command ledger retain deduplication.
+Deletion removes delivery receipts with the chat's local snapshot/outbox.
+
+The updated senders also carry the selected host's `hostDevice` routing hint on
+both WebSocket joins and HTTPS pushes. The chat room commits the opaque row,
+a versioned host-wake receipt, and the next alarm **in one SQLite storage
+transaction before ACKing the row** (the [SQLite storage transaction API](https://developers.cloudflare.com/durable-objects/api/sqlite-storage-api/#transaction) includes SQL and alarm operations).
+It immediately forwards the wake to the existing device-room queue. Failed forwards (including unclaimed/offline
+hosts, queue saturation, server errors, and timeouts) retain the receipt and
+retry from durable alarms with backoff capped at one minute. A newer row fences
+completion of an older forward. Host-authored rows do not create wake loops.
+
+Consequently, once all command bytes have reached the updated edge, host
+discovery no longer requires the phone to stay alive, send a separate wake,
+or reopen. The chat room owns the handoff until the device room durably accepts
+it; the device room then owns delivery to the host. The original local receipts
+remain as recovery and compatibility paths for older edge deployments.
+
+The Worker supplies the canonical chat ID from the authenticated route, and
+forwards the verified owner identity. A caller's query cannot redirect a wake
+to another chat; another user's device still rejects it. Rooms keep their opaque
+log discipline: no Loro parsing or provider execution moves to the server.
+Wake retries and nightly backups share the existing durable alarm without
+moving backups onto the wake cadence. No new deployment binding is needed.
+
+Discovery and concurrent delivery are bounded. Stalled jobs yield after a
+12-second service window, so eight dead destinations cannot permanently block
+later healthy destinations. Jobs remain durable when that window ends.
+
+On iOS, recent or pending sends request a [UIApplication background task](https://developer.apple.com/documentation/uikit/uiapplication/beginbackgroundtask%28withname%3Aexpirationhandler%3A%29) for at most 25 seconds
+(or until iOS expires it), ending on foreground or sign-out. This gives normal
+app switching time to finish delivery. Force-quitting or losing connectivity
+before the edge accepts all command bytes still requires reopening the app; a
+stopped process cannot transmit. Local receipts survive for that recovery.
+Chat visibility on the desktop remains registry visibility, not proof that all
+command bytes arrived. The UI keeps unadopted sends in Sending/Queued until the
+host takes ownership.
+
+Deploy the updated edge together with the updated senders (edge first is safe).
+The server-owned handoff is not available on an older edge, where the local
+wake/relaunch recovery remains the fallback. This PR does not deploy production.
+
+The shared thin-client transcript and session list now reserve Working for host
+status or actual streamed output. The iOS composer explicitly says “Sending to
+host…” during unadopted delivery; the existing echo retains Sending/Queued/Failed.
+This does not treat a pending first Run as permission to start duplicate turns.
+
+## Regression coverage
+
+- Real workerd/SQLite chat-room tests accept a prompt via HTTPS or WebSocket,
+  keep the phone offline (no restart and no separate nudge), and deliver its
+  wake when the desktop joins. The desktop can then retrieve the stored bytes.
+- Real workerd tests cover device-room queue saturation with both devices
+  offline, stale-forward fencing, transaction rollback of rows/receipts/alarms,
+  batch replay deduplication, host-output loop prevention, legacy senders,
+  invalid/unauthorized routes, and wake/backup alarm coexistence.
+- The actual thin-client socket carries its selected host hint; desktop
+  transport tests verify both WebSocket URLs and HTTPS push requests.
+- A server error after row ACK must retry the host wake and recover it after
+  relaunch, with no viewport open or preload.
+- Immediate exit after a new chat's first send must preserve the registry row,
+  resume publication and host discovery, and keep exactly one original command.
+  The test covers Windows/Codex, macOS/Cursor, and Linux/Claude host metadata.
+- A successful wake to an empty room must retain the receipt until a final wake
+  after row publication.
+- Desktop wake failure survives row ACK and a reopened DocsStore/WorkspaceHost.
+- Eight failed wakes yield capacity to a later healthy chat without deleting
+  the failed obligations.
+- Metadata discovery pages over 64 jobs, does not duplicate jobs with outbox
+  rows, retains wakes after ACK, fences stale completion, and respects deletion.
+- Existing live client, demo, born-chat2, relay delivery, and sync admission tests
+  exercise surrounding behavior.
+
+The two central new live-client regressions were also run against the unmodified
+upstream client (with new implementation-specific UI assertions excluded):
+`acked_command_recovers_failed_host_wake_without_opening_the_chat` failed with
+“host wake was not retried”; the immediate-exit regression failed with
+“windows: first send was stranded without a UI open”. Both pass with the fix.
+
+The new accepted-prompt/no-relaunch regression was also run with the previous
+PR's unchanged chat-room server. With implementation-specific receipt assertions
+excluded, the prompt was accepted but the desktop never received its wake
+(`expected [] to include <chatId>`). It passes with the server-owned handoff.
+
+All 166 executed tests passed on Linux:
+
+| Check | Result |
+| --- | --- |
+| `cargo test -p zeron-client -- --test-threads=1` | 45 passed |
+| `cargo test -p zeron-sync --lib sync_jobs::tests -- --test-threads=1` | 3 passed |
+| `cargo test -p zeron-engine --lib remote_delivery -- --test-threads=1` | 2 passed |
+| `cargo test -p zeron-engine --lib sync_lifecycle_tests -- --test-threads=1` | 19 passed |
+| Engine `born_chat2_race`, `relay_delivery`, `rich_composer_delivery` suites | 7 passed |
+| Edge unit + real workerd suites (`npm test`) | 58 + 32 passed |
+| Edge TypeScript check and Worker bundle dry run | Passed |
+| `cargo check -p zeron-mobile` | Passed on Linux |
+| Changed Rust code's rustfmt checks and `git diff --check` | Passed |
+
+The new server tests establish stored-byte and durable host-wake delivery, not
+native provider execution. Native iOS background scheduling and visual rendering
+require Xcode/device validation. Native Windows and macOS provider launches were not exercised on the
+Linux validation host.
diff --git a/edge/src/chat-room.ts b/edge/src/chat-room.ts
index 04dedf2670..8be4fc4d91 100644
--- a/edge/src/chat-room.ts
+++ b/edge/src/chat-room.ts
@@ -14,7 +14,7 @@
  * never materializes anything.
  *
  * Hibernation discipline: ZERO wall-clock timers; ping/pong rides the
- * auto-response pair; the daily alarm does the nightly R2 backup only.
+ * auto-response pair; alarms retry accepted rows' host wakes and back up to R2.
  */
 import { createBlobStore, type BlobStore } from "./blobs";
 import {
@@ -32,6 +32,10 @@ import {
 } from "./chat-log";
 import { decodeFrame, encodeFrame, FRAME } from "./chat-frames";
 import { AUTH_USER_HEADER, type Env } from "./env";
+import {
+  ensureChatWakes, finishChatWake, MAX_WAKE_ATTEMPTS, PERMANENT_WAKE_REJECTIONS,
+  pendingChatWake, queueChatWake, retryChatWake, validWakeRoute
+} from "./chat-wakes";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 /** Inbound frame budget: one pushed row (+ header slack). */
@@ -54,6 +58,8 @@ interface SocketState {
   device: string;
   /** Set once a valid hello established the session. */
   ready?: boolean;
+  chatId?: string;
+  hostDevice?: string;
 }
 
 interface PushOutcome {
@@ -76,11 +82,13 @@ export class ChatRoom implements DurableObject {
   private readonly presence = new Map<string, number>();
   /** device → rolling push quota window. Memory-only. */
   private readonly quotas = new Map<string, QuotaWindow>();
+  private wakeFlight?: Promise<void>;
 
   constructor(ctx: DurableObjectState, env: Env) {
     this.ctx = ctx;
     this.env = env;
     ensureChatLog(ctx.storage.sql);
+    ensureChatWakes(ctx.storage.sql);
     this.blobs = createBlobStore(ctx.storage.sql);
     // Runtime-answered keepalive; proves nothing about this DO's health.
     // Clients judge liveness by probe frames (same caveat as RegistryRoom).
@@ -104,9 +112,14 @@ export class ChatRoom implements DurableObject {
       if (!owner) setMeta(sql, "owner", userId);
       else if (owner !== userId) return json({ error: "forbidden" }, 403);
       const device = url.searchParams.get("device") ?? "";
+      const chatId = url.searchParams.get("chatId") ?? "";
+      // An unroutable wake hint never refuses the push: the rows are the
+      // user's message; only host discovery is skipped.
+      const hint = url.searchParams.get("hostDevice") ?? "";
+      const hostDevice = hint && validWakeRoute(chatId, hint) ? hint : "";
       const pair = new WebSocketPair();
       this.ctx.acceptWebSocket(pair[1]);
-      const state: SocketState = { userId, device };
+      const state: SocketState = { userId, device, chatId, hostDevice };
       pair[1].serializeAttachment(state);
       return new Response(null, { status: 101, webSocket: pair[0] });
     }
@@ -132,7 +145,7 @@ export class ChatRoom implements DurableObject {
       if (body.byteLength > MAX_CHECKPOINT_BYTES) return json({ error: "too_large" }, 413);
       const outcome = commitCheckpoint(sql, this.blobs, seqCovered, frontier, body, Date.now());
       if (!outcome.ok) return json({ error: outcome.error }, 409);
-      this.markBackupDirty();
+      await this.markBackupDirty();
       return json({ ok: true, seqFloor: outcome.seqFloor, pruned: outcome.pruned });
     }
 
@@ -243,6 +256,9 @@ export class ChatRoom implements DurableObject {
       // makes at-least-once delivery exact-once in effect.
       const device = url.searchParams.get("device") ?? "";
       const batchId = url.searchParams.get("batchId") ?? "";
+      const chatId = url.searchParams.get("chatId") ?? "";
+      const hint = url.searchParams.get("hostDevice") ?? "";
+      const hostDevice = hint && validWakeRoute(chatId, hint) ? hint : "";
       if (batchId === "" || batchId.length > 128) {
         this.recordPush(device, false);
         return json({ error: "bad_push" }, 400);
@@ -259,14 +275,13 @@ export class ChatRoom implements DurableObject {
         this.recordPush(device, false);
         return json({ error: "quota" }, 429);
       }
-      const outcome = appendRow(sql, device, batchId, payload, Date.now());
+      const outcome = await this.acceptRow(device, batchId, payload, userId, chatId, hostDevice);
       if (!outcome.ok) {
         this.recordPush(device, false);
         return json({ error: outcome.error }, outcome.error === "too_large" ? 413 : 400);
       }
       this.recordPush(device, true);
       if (!outcome.dup) {
-        this.markBackupDirty();
         // Live relay to every ready socket — a same-device socket would
         // re-import its own bytes as a Loro no-op, so no exclusion needed.
         for (const socket of this.ctx.getWebSockets()) {
@@ -322,6 +337,7 @@ export class ChatRoom implements DurableObject {
       sql.exec("DELETE FROM rows");
       sql.exec("DELETE FROM meta");
       sql.exec("DELETE FROM blobs");
+      sql.exec("DELETE FROM chat_wake");
       for (const ws of this.ctx.getWebSockets()) {
         try {
           ws.close(4410, "chat room reset");
@@ -360,7 +376,7 @@ export class ChatRoom implements DurableObject {
         this.handleRowsReq(ws, state, frame.header);
         return;
       case FRAME.push:
-        this.handlePush(ws, state, frame.header, frame.payload);
+        await this.handlePush(ws, state, frame.header, frame.payload);
         return;
       case FRAME.presence:
         this.handlePresence(ws, state, frame.header, frame.payload);
@@ -422,12 +438,12 @@ export class ChatRoom implements DurableObject {
     send(ws, FRAME.rowsDone, { headSeq: headSeq(sql) });
   }
 
-  private handlePush(
+  private async handlePush(
     ws: WebSocket,
     state: SocketState,
     header: Record<string, unknown>,
     payload: Uint8Array
-  ): void {
+  ): Promise<void> {
     const batchId = typeof header.batchId === "string" ? header.batchId : "";
     // Push errors carry the batchId so clients can RETIRE permanently
     // rejected batches from their replay queues (an unretireable batch
@@ -442,8 +458,7 @@ export class ChatRoom implements DurableObject {
       send(ws, FRAME.error, { code: "quota", message: "per-device push quota exceeded", batchId });
       return;
     }
-    const sql = this.ctx.storage.sql;
-    const outcome = appendRow(sql, state.device, batchId, payload, Date.now());
+    const outcome = await this.acceptRow(state.device, batchId, payload, state.userId, state.chatId ?? "", state.hostDevice ?? "");
     if (!outcome.ok) {
       this.recordPush(state.device, false);
       send(ws, FRAME.error, {
@@ -455,7 +470,6 @@ export class ChatRoom implements DurableObject {
     }
     this.recordPush(state.device, true);
     if (!outcome.dup) {
-      this.markBackupDirty();
       // Live relay to every OTHER ready socket — the sender has its own
       // bytes; it gets the ack (contrast RegistryRoom, whose LWW merge means
       // the sender must see the merged truth — here bytes are opaque and
@@ -534,16 +548,112 @@ export class ChatRoom implements DurableObject {
     setMeta(sql, "pushOutcomes", JSON.stringify(outcomes));
   }
 
-  private markBackupDirty(): void {
-    setMeta(this.ctx.storage.sql, "backupDirty", "1");
-    void this.ctx.storage.getAlarm().then((existing) => {
-      if (existing === null) void this.ctx.storage.setAlarm(Date.now() + DAY_MS);
+  /** SQL rows, wake receipt, and alarm are one SQLite storage transaction.
+   * ACKs therefore cannot outrun the durable host-discovery obligation. */
+  private async acceptRow(device: string, batch: string, payload: Uint8Array, user: string, chat: string, host: string) {
+    const sql = this.ctx.storage.sql;
+    const outcome = await this.ctx.storage.transaction(async () => {
+      const result = appendRow(sql, device, batch, payload, Date.now());
+      if (!result.ok) return result;
+      if (!result.dup) this.backupDirty();
+      // Host output must not feed a wake loop. Legacy senders without a
+      // hint keep their separate nudge path; hints are authenticated routing,
+      // never permission to execute (the host still validates its document).
+      if (host && host !== device) queueChatWake(sql, chat, host, user);
+      await this.scheduleAlarm();
+      return result;
+    });
+    if (outcome.ok && host && host !== device) this.ctx.waitUntil(this.flushWake());
+    return outcome;
+  }
+
+  private backupDirty(): void {
+    const sql = this.ctx.storage.sql;
+    setMeta(sql, "backupDirty", "1");
+    if (!getMeta(sql, "backupDue")) setMeta(sql, "backupDue", String(Date.now() + DAY_MS));
+  }
+
+  private async markBackupDirty(): Promise<void> {
+    await this.ctx.storage.transaction(async () => {
+      this.backupDirty();
+      await this.scheduleAlarm();
+    });
+  }
+
+  /** Always called inside a storage transaction: a backup can't overwrite
+   * an earlier wake alarm, including when requests interleave with retries. */
+  private async scheduleAlarm(): Promise<void> {
+    const sql = this.ctx.storage.sql;
+    const wake = pendingChatWake(sql);
+    const backup = getMeta(sql, "backupDirty") === "1"
+      ? Number(getMeta(sql, "backupDue") ?? Date.now() + DAY_MS) : Infinity;
+    const next = Math.min(wake?.next_at ?? Infinity, backup);
+    if (!Number.isFinite(next)) return;
+    const existing = await this.ctx.storage.getAlarm();
+    if (existing === null || next < existing) await this.ctx.storage.setAlarm(next);
+  }
+
+  private flushWake(): Promise<void> {
+    if (this.wakeFlight) return this.wakeFlight;
+    this.wakeFlight = this.deliverWake().finally(() => { this.wakeFlight = undefined; });
+    return this.wakeFlight;
+  }
+
+  private async deliverWake(): Promise<void> {
+    const sql = this.ctx.storage.sql;
+    const wake = pendingChatWake(sql);
+    if (!wake) return;
+    let accepted = false;
+    let rejected = false;
+    try {
+      const room = this.env.DEVICE_ROOMS.get(this.env.DEVICE_ROOMS.idFromName(`d2/${wake.host_device}`));
+      const response = await room.fetch("https://device/nudge", {
+        method: "POST", headers: { [AUTH_USER_HEADER]: wake.user_id },
+        body: JSON.stringify({ chatId: wake.chat_id }), signal: AbortSignal.timeout(5000)
+      });
+      accepted = response.ok;
+      // Another owner's device (403) or a chat id it refuses (400): no retry
+      // can succeed. Unclaimed (404) and queue-full (503) retry.
+      rejected = PERMANENT_WAKE_REJECTIONS.has(response.status);
+      await response.arrayBuffer();
+    } catch {
+      // A failed forward remains owned by this room, even with no viewer.
+    }
+    const exhausted = !accepted && wake.attempts + 1 >= MAX_WAKE_ATTEMPTS;
+    if (rejected || exhausted) {
+      console.warn("chat2 host wake dropped", {
+        chat: wake.chat_id, host: wake.host_device, rejected, attempts: wake.attempts + 1
+      });
+    }
+    await this.ctx.storage.transaction(async () => {
+      if (accepted || rejected || exhausted) finishChatWake(sql, wake.token);
+      else retryChatWake(sql, wake);
+      await this.scheduleAlarm();
     });
   }
 
-  /** Daily alarm: nightly R2 backup, seq-monotonic so a reset-and-reseeding
-   * room can never replace the last good copy with a hollow one. */
+  /** Wake retry + nightly backup share the DO's single durable alarm. */
   async alarm(): Promise<void> {
+    try {
+      const wake = pendingChatWake(this.ctx.storage.sql);
+      if (wake && wake.next_at <= Date.now()) await this.flushWake();
+      const due = Number(getMeta(this.ctx.storage.sql, "backupDue") ?? "0");
+      if (due <= Date.now()) {
+        try { await this.backup(); }
+        catch (error) {
+          // Do not exhaust the runtime's finite automatic retries or spin
+          // on an expired deadline during an R2 outage.
+          setMeta(this.ctx.storage.sql, "backupDue", String(Date.now() + 60_000));
+          console.warn("chat2 backup retrying", error);
+        }
+      }
+    } finally {
+      await this.ctx.storage.transaction(async () => { await this.scheduleAlarm(); });
+    }
+  }
+
+  /** Seq-monotonic backup; concurrent new rows retain their dirty flag. */
+  private async backup(): Promise<void> {
     const sql = this.ctx.storage.sql;
     if (getMeta(sql, "backupDirty") !== "1") return; // idle: stop the chain
     const head = headSeq(sql);
@@ -568,7 +678,15 @@ export class ChatRoom implements DurableObject {
       );
       setMeta(sql, "backupSeq", String(head));
     }
-    setMeta(sql, "backupDirty", "0");
+    if (headSeq(sql) === head) {
+      setMeta(sql, "backupDirty", "0");
+      sql.exec("DELETE FROM meta WHERE key='backupDue'");
+    } else {
+      // Rows landed during the upload: they stay dirty for the NEXT nightly
+      // backup. Leaving the passed deadline re-armed the alarm at once and
+      // re-uploaded the whole log back to back while the chat streamed.
+      setMeta(sql, "backupDue", String(Date.now() + DAY_MS));
+    }
   }
 }
 
diff --git a/edge/src/chat-route.ts b/edge/src/chat-route.ts
new file mode 100644
index 0000000000..1c78c6b02f
--- /dev/null
+++ b/edge/src/chat-route.ts
@@ -0,0 +1,36 @@
+import { AUTH_USER_HEADER, ROOM_KIND_HEADER, type Env } from "./env";
+
+/** Canonical chat identity comes from the authenticated route, never a
+ * sender-supplied query. Also used by the workerd routing fixture. */
+export function chatRoute(request: Request, env: Pick<Env, "CHAT_ROOMS">, userId: string): Promise<Response> | Response | undefined {
+  const url = new URL(request.url);
+  const parts = url.pathname.split("/").filter(Boolean);
+  const id = /^[A-Za-z0-9_-]{1,128}$/;
+  if (parts[0] !== "chat2" || !parts[1] || !id.test(parts[1]) || !parts[2]) return;
+  const chat = parts[1];
+  const route = parts[2];
+  if (parts.length !== 3) return new Response("not found", { status: 404 });
+  if (route === "ws") {
+    if (request.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+      return new Response("expected websocket", { status: 426 });
+    }
+    const device = url.searchParams.get("device") ?? "";
+    const host = url.searchParams.get("hostDevice");
+    url.search = "";
+    if (id.test(device)) url.searchParams.set("device", device);
+    if (host !== null) url.searchParams.set("hostDevice", host);
+  } else {
+    const routes: Record<string, string[]> = {
+      checkpoint: ["GET", "POST"], rows: ["GET", "POST"],
+      tail: ["GET", "PUT"], diff: ["GET", "PUT"], stats: ["GET"], reset: ["POST"]
+    };
+    if (!routes[route]?.includes(request.method)) return new Response("not found", { status: 404 });
+  }
+  url.searchParams.set("chatId", chat);
+  url.pathname = `/${route}`;
+  const headers = new Headers(request.headers);
+  headers.delete(ROOM_KIND_HEADER);
+  headers.set(AUTH_USER_HEADER, userId);
+  const room = env.CHAT_ROOMS.get(env.CHAT_ROOMS.idFromName(`chat2/${chat}`));
+  return room.fetch(new Request(url, { method: request.method, body: request.body, headers }));
+}
diff --git a/edge/src/chat-wakes.ts b/edge/src/chat-wakes.ts
new file mode 100644
index 0000000000..116fa14844
--- /dev/null
+++ b/edge/src/chat-wakes.ts
@@ -0,0 +1,46 @@
+/** Opaque chat rows and their host-discovery obligation commit together.
+ * One coalesced receipt per chat; newer rows fence an in-flight completion. */
+export interface ChatWake extends Record<string, SqlStorageValue> {
+  chat_id: string;
+  host_device: string;
+  user_id: string;
+  token: string;
+  attempts: number;
+  next_at: number;
+}
+
+/** Chat ids the device room's nudge accepts (1-64): longer ones still push
+ * their rows, they just carry no wake. */
+export const validWakeRoute = (chat: string, host: string): boolean =>
+  /^[A-Za-z0-9_-]{1,64}$/.test(chat) && /^[A-Za-z0-9_-]{1,128}$/.test(host);
+
+/** Device-room answers no retry can change (see device-room.ts /nudge): a
+ * chat id it refuses (400) or another owner's device (403). An unclaimed
+ * room (404) is a host that has not connected yet — that one waits. */
+export const PERMANENT_WAKE_REJECTIONS = new Set([400, 403]);
+
+/** About a day of capped (60s) retries; past it the host's own sync owns it. */
+export const MAX_WAKE_ATTEMPTS = 1440;
+
+export function ensureChatWakes(sql: SqlStorage): void {
+  sql.exec("CREATE TABLE IF NOT EXISTS chat_wake (id INTEGER PRIMARY KEY CHECK(id=1), chat_id TEXT NOT NULL, host_device TEXT NOT NULL, user_id TEXT NOT NULL, token TEXT NOT NULL, attempts INTEGER NOT NULL, next_at INTEGER NOT NULL)");
+}
+
+export function queueChatWake(sql: SqlStorage, chat: string, host: string, user: string): void {
+  sql.exec("INSERT INTO chat_wake VALUES (1,?,?,?,?,0,?) ON CONFLICT(id) DO UPDATE SET chat_id=excluded.chat_id,host_device=excluded.host_device,user_id=excluded.user_id,token=excluded.token,attempts=0,next_at=excluded.next_at",
+    chat, host, user, crypto.randomUUID(), Date.now() + 1000);
+}
+
+export function pendingChatWake(sql: SqlStorage): ChatWake | undefined {
+  return [...sql.exec("SELECT * FROM chat_wake WHERE id=1")][0] as ChatWake | undefined;
+}
+
+export function finishChatWake(sql: SqlStorage, token: string): void {
+  sql.exec("DELETE FROM chat_wake WHERE id=1 AND token=?", token);
+}
+
+export function retryChatWake(sql: SqlStorage, wake: ChatWake): void {
+  const delay = Math.min(60_000, 1000 * 2 ** Math.min(wake.attempts, 6));
+  sql.exec("UPDATE chat_wake SET attempts=attempts+1,next_at=? WHERE id=1 AND token=?",
+    Date.now() + delay, wake.token);
+}
diff --git a/edge/src/index.ts b/edge/src/index.ts
index 6fdda2476c..a04018da3f 100644
--- a/edge/src/index.ts
+++ b/edge/src/index.ts
@@ -37,6 +37,7 @@
  *   POST /chat2/:chatId/reset
  */
 import { authenticate } from "./auth";
+import { chatRoute } from "./chat-route";
 import { handleAuthRoute } from "./auth-routes";
 import { AUTH_USER_HEADER, ROOM_KIND_HEADER, type Env } from "./env";
 import { SessionRoom } from "./session-room";
@@ -204,39 +205,8 @@ export default {
     //    client-minted). The DO handles /ws, /checkpoint (GET Range-resumable
     //    + POST floor-guarded), host-published /tail + /diff sidecars,
     //    /stats, /reset. ──────────────────────────────────────────────────────
-    if (parts[0] === "chat2" && parts[1] && ID_RE.test(parts[1]) && parts[2]) {
-      const room = `chat2/${parts[1]}`;
-      if (parts[2] === "ws" && parts.length === 3) {
-        if (request.headers.get("upgrade")?.toLowerCase() !== "websocket") {
-          return json({ error: "expected websocket" }, 426);
-        }
-        return forward(
-          env.CHAT_ROOMS,
-          room,
-          request,
-          auth.userId,
-          "/ws",
-          `?chatId=${parts[1]}${deviceParam(url)}`
-        );
-      }
-      const routes: Record<string, string[]> = {
-        checkpoint: ["GET", "POST"],
-        // Pull/push over plain HTTPS (the airplane-wifi transport): GET
-        // /rows?after= collapses connect→hello→state→rowsReq→backfill into
-        // one round trip; POST /rows is the batchId-deduped push twin.
-        rows: ["GET", "POST"],
-        tail: ["GET", "PUT"],
-        diff: ["GET", "PUT"],
-        stats: ["GET"],
-        reset: ["POST"]
-      };
-      if (parts.length === 3 && routes[parts[2]]?.includes(request.method)) {
-        // Query carries through (`seqCovered` on POST /checkpoint), as do
-        // headers (`x-chat2-frontier`, `range`).
-        return forward(env.CHAT_ROOMS, room, request, auth.userId, `/${parts[2]}`, url.search);
-      }
-      return json({ error: "not found" }, 404);
-    }
+    const chatResponse = chatRoute(request, env, auth.userId);
+    if (chatResponse) return chatResponse;
 
     // ── workspace rooms (ARCHITECTURE §2.2/§6.1): same SessionRoom DO class;
     //    the caller's WorkOS org claim (`org_id`) must equal the URL's orgId,
diff --git a/edge/test/workerd/chat-wakes.workerd.test.ts b/edge/test/workerd/chat-wakes.workerd.test.ts
new file mode 100644
index 0000000000..d8175ce1d3
--- /dev/null
+++ b/edge/test/workerd/chat-wakes.workerd.test.ts
@@ -0,0 +1,215 @@
+import { env, SELF, runInDurableObject, runDurableObjectAlarm } from "cloudflare:test";
+import { expect, it } from "vitest";
+import { decodeFrame, encodeFrame, FRAME } from "../../src/chat-frames";
+import { decodeDeviceFrame } from "../../src/device-room";
+import { enqueueNudge, NUDGE_CAP, pendingNudges } from "../../src/device-nudges";
+import { finishChatWake, pendingChatWake, queueChatWake, retryChatWake } from "../../src/chat-wakes";
+import { appendRow, getMeta, logStats, rowsAfter, setMeta } from "../../src/chat-log";
+
+const owner = "sender-owner";
+const auth = { authorization: `Bearer ${owner}@org` };
+const chatRoom = (chat: string) => env.CHAT_ROOMS.get(env.CHAT_ROOMS.idFromName(`chat2/${chat}`));
+const deviceRoom = (host: string) => env.DEVICE_ROOMS.get(env.DEVICE_ROOMS.idFromName(`d2/${host}`));
+const post = (chat: string, host: string, batch = "prompt") => SELF.fetch(
+  `https://edge/chat2/${chat}/rows?device=phone&hostDevice=${host}&batchId=${batch}&chatId=spoofed-chat`,
+  { method: "POST", headers: auth, body: new Uint8Array([1, 2, 3]) }
+);
+async function hostSocket(host: string, user = owner) {
+  const response = await deviceRoom(host).fetch("https://device/ws?role=host&nudgeAck=1", {
+    headers: { "x-zeron-auth-user": user, upgrade: "websocket" }
+  });
+  expect(response.status).toBe(101);
+  const socket = response.webSocket!;
+  socket.accept(); socket.binaryType = "arraybuffer";
+  const wakes: Array<{ chatId: string; token: string }> = [];
+  socket.addEventListener("message", event => {
+    const frame = decodeDeviceFrame(new Uint8Array(event.data as ArrayBuffer));
+    wakes.push(JSON.parse(new TextDecoder().decode(frame.payload)));
+  });
+  return { socket, wakes };
+}
+async function retryNow(chat: string) {
+  const room = chatRoom(chat);
+  await runInDurableObject(room, (_instance, state) => { state.storage.sql.exec("UPDATE chat_wake SET next_at=0"); });
+  await runDurableObjectAlarm(room);
+}
+const waitForRetry = (chat: string) => expect.poll(() => runInDurableObject(chatRoom(chat), (_i, state) => pendingChatWake(state.storage.sql)?.attempts)).toBeGreaterThan(0);
+
+it("delivers an HTTPS-accepted prompt with the phone offline and no relaunch or separate nudge", async () => {
+  const chat = crypto.randomUUID(), host = crypto.randomUUID();
+  const response = await post(chat, host);
+  expect(response.status, await response.text()).toBe(200);
+  await waitForRetry(chat);
+  await runInDurableObject(chatRoom(chat), async (_i, state) => {
+    const wake = pendingChatWake(state.storage.sql)!;
+    expect(wake.chat_id).toBe(chat); // route defeats spoofed query
+    expect(wake.host_device).toBe(host);
+    expect(logStats(state.storage.sql).rowCount).toBe(1);
+    expect(await state.storage.getAlarm()).not.toBeNull();
+    expect(await state.storage.getAlarm()).toBeLessThanOrEqual(Date.now() + 2000);
+    expect(Number([...state.storage.sql.exec("SELECT value FROM meta WHERE key='backupDue'")][0].value)).toBeGreaterThan(Date.now() + 60_000);
+  });
+  // No more phone requests. Only the server alarm transfers the obligation.
+  const desktop = await hostSocket(host);
+  await retryNow(chat);
+  await expect.poll(() => desktop.wakes.map(w => w.chatId)).toContain(chat);
+  await runInDurableObject(chatRoom(chat), (_i, state) => { expect(pendingChatWake(state.storage.sql)).toBeUndefined(); });
+  const pull = await SELF.fetch(`https://edge/chat2/${chat}/rows?device=${host}`, { headers: auth });
+  expect(pull.status).toBe(200);
+  const bytes = new Uint8Array(await pull.arrayBuffer());
+  const frames = [];
+  for (let offset = 0; offset < bytes.length;) {
+    const length = new DataView(bytes.buffer).getUint32(offset, true); offset += 4;
+    frames.push(decodeFrame(bytes.subarray(offset, offset + length))); offset += length;
+  }
+  expect(frames.find(f => f?.type === FRAME.row)?.payload).toEqual(new Uint8Array([1, 2, 3]));
+  desktop.socket.close();
+});
+
+it("keeps a websocket-accepted prompt's wake after the phone socket closes", async () => {
+  const chat = crypto.randomUUID(), host = crypto.randomUUID();
+  const response = await SELF.fetch(`https://edge/chat2/${chat}/ws?device=phone&hostDevice=${host}`, { headers: { ...auth, upgrade: "websocket" } });
+  expect(response.status).toBe(101);
+  const phone = response.webSocket!; phone.accept(); phone.binaryType = "arraybuffer";
+  const kinds: number[] = [];
+  phone.addEventListener("message", event => { kinds.push(decodeFrame(new Uint8Array(event.data as ArrayBuffer))!.type); });
+  phone.send(encodeFrame(FRAME.hello, { device: "phone", cursor: 0 }));
+  await expect.poll(() => kinds).toContain(FRAME.state);
+  phone.send(encodeFrame(FRAME.push, { batchId: "phone-prompt" }, new Uint8Array([4, 5])));
+  await expect.poll(() => kinds).toContain(FRAME.ack);
+  phone.close();
+  await waitForRetry(chat);
+  const desktop = await hostSocket(host);
+  await retryNow(chat);
+  await expect.poll(() => desktop.wakes.map(w => w.chatId)).toContain(chat);
+  await runInDurableObject(chatRoom(chat), (_i, state) => {
+    expect([...rowsAfter(state.storage.sql, 0)][0].bytes).toEqual(new Uint8Array([4, 5]));
+    expect(pendingChatWake(state.storage.sql)).toBeUndefined();
+  });
+  desktop.socket.close();
+});
+
+it("retains accepted bytes through device queue saturation and hands off with both devices offline", async () => {
+  const chat = crypto.randomUUID(), host = crypto.randomUUID();
+  const desktop = await hostSocket(host); desktop.socket.close();
+  await runInDurableObject(deviceRoom(host), (_i, state) => {
+    for (let i = 0; i < NUDGE_CAP; i++) enqueueNudge(state.storage.sql, `queued-${i}`);
+  });
+  const response = await post(chat, host); expect(response.status, await response.text()).toBe(200);
+  await waitForRetry(chat);
+  await runInDurableObject(deviceRoom(host), (_i, state) => { state.storage.sql.exec("DELETE FROM pending_nudges WHERE chat_id='queued-0'"); });
+  await retryNow(chat);
+  await runInDurableObject(chatRoom(chat), (_i, state) => { expect(pendingChatWake(state.storage.sql)).toBeUndefined(); });
+  await runInDurableObject(deviceRoom(host), (_i, state) => {
+    expect([...state.storage.sql.exec("SELECT chat_id FROM pending_nudges WHERE chat_id=?", chat)][0].chat_id).toBe(chat);
+  });
+});
+
+it("coalesces wakes, fences stale forwards, and rolls back the receipt and alarm together", async () => {
+  await runInDurableObject(chatRoom(crypto.randomUUID()), async (_i, state) => {
+    const sql = state.storage.sql;
+    queueChatWake(sql, "chat", "host", owner); const older = pendingChatWake(sql)!;
+    queueChatWake(sql, "chat", "host", owner); const newer = pendingChatWake(sql)!;
+    finishChatWake(sql, older.token); retryChatWake(sql, older);
+    expect(pendingChatWake(sql)).toEqual(newer);
+    await expect(state.storage.transaction(async () => {
+      appendRow(sql, "phone", "uncommitted", new Uint8Array([1]), Date.now());
+      queueChatWake(sql, "rollback", "host", owner);
+      await state.storage.setAlarm(Date.now() + 1000);
+      throw new Error("crash before commit");
+    })).rejects.toThrow("crash before commit");
+    expect(pendingChatWake(sql)).toEqual(newer);
+    expect(logStats(sql).rowCount).toBe(0);
+    expect(await state.storage.getAlarm()).toBeNull();
+  });
+});
+
+it("keeps nightly backups scheduled after wake delivery without backing up on every wake alarm", async () => {
+  const chat = crypto.randomUUID(), host = crypto.randomUUID();
+  const desktop = await hostSocket(host);
+  const response = await post(chat, host); expect(response.status).toBe(200); await response.text();
+  await expect.poll(() => runInDurableObject(chatRoom(chat), (_i, state) => pendingChatWake(state.storage.sql))).toBeUndefined();
+  await runDurableObjectAlarm(chatRoom(chat));
+  await runInDurableObject(chatRoom(chat), async (_i, state) => {
+    expect(getMeta(state.storage.sql, "backupSeq")).toBeUndefined();
+    expect(await state.storage.getAlarm()).toBe(Number(getMeta(state.storage.sql, "backupDue")));
+    setMeta(state.storage.sql, "backupDue", "0");
+  });
+  await runDurableObjectAlarm(chatRoom(chat));
+  await runInDurableObject(chatRoom(chat), async (_i, state) => {
+    expect(getMeta(state.storage.sql, "backupSeq")).toBe("1");
+    expect(getMeta(state.storage.sql, "backupDirty")).toBe("0");
+    expect(await state.storage.getAlarm()).toBeNull();
+  });
+  desktop.socket.close();
+});
+
+it("deduplicates replays, avoids host-output wake loops, and preserves legacy pushes", async () => {
+  const chat = crypto.randomUUID(), host = crypto.randomUUID();
+  for (let i = 0; i < 2; i++) { const response = await post(chat, host); expect(response.status).toBe(200); await response.text(); }
+  await runInDurableObject(chatRoom(chat), (_i, state) => { expect(logStats(state.storage.sql).rowCount).toBe(1); });
+  for (const own of [true, false]) {
+    const ownChat = crypto.randomUUID();
+    const response = await SELF.fetch(`https://edge/chat2/${ownChat}/rows?device=${host}&batchId=output${own ? `&hostDevice=${host}` : ""}`, {
+      method: "POST", headers: auth, body: new Uint8Array([1])
+    });
+    expect(response.status).toBe(200); await response.text();
+    await runInDurableObject(chatRoom(ownChat), (_i, state) => { expect(pendingChatWake(state.storage.sql)).toBeUndefined(); });
+  }
+});
+
+it("accepts rows with an unroutable wake, rejects unauthorized pushes, and drops a wake another owner's device refuses", async () => {
+  const chat = crypto.randomUUID();
+  // A malformed wake hint never refuses the user's message: the row lands,
+  // only host discovery is skipped.
+  const bad = await SELF.fetch(`https://edge/chat2/${chat}/rows?device=phone&hostDevice=invalid/host&batchId=bad`, {
+    method: "POST", headers: auth, body: new Uint8Array([1])
+  });
+  expect(bad.status, await bad.text()).toBe(200);
+  await runInDurableObject(chatRoom(chat), (_i, state) => {
+    expect(logStats(state.storage.sql).rowCount).toBe(1); expect(pendingChatWake(state.storage.sql)).toBeUndefined();
+  });
+  const forbidden = await SELF.fetch(`https://edge/chat2/${chat}/rows?batchId=bad&hostDevice=host`, {
+    method: "POST", headers: { authorization: "Bearer stranger@org" }
+  });
+  expect(forbidden.status).toBe(403); await forbidden.text();
+  // Another owner's device room refuses the forward (403): no retry can
+  // succeed, so the receipt is dropped rather than retried forever.
+  const host = crypto.randomUUID(); const other = await hostSocket(host, "stranger");
+  const accepted = await post(chat, host, "foreign"); expect(accepted.status).toBe(200); await accepted.text();
+  await retryNow(chat);
+  await expect.poll(() => runInDurableObject(chatRoom(chat), (_i, state) => pendingChatWake(state.storage.sql))).toBeUndefined();
+  await runInDurableObject(deviceRoom(host), (_i, state) => { expect(pendingNudges(state.storage.sql)).toEqual([]); });
+  other.socket.close();
+});
+
+it("moves the backup deadline a day on when rows land during the upload", async () => {
+  const chat = crypto.randomUUID();
+  const room = chatRoom(chat);
+  const response = await post(chat, crypto.randomUUID(), "first"); expect(response.status).toBe(200); await response.text();
+  await runInDurableObject(room, async (instance, state) => {
+    const sql = state.storage.sql;
+    sql.exec("DELETE FROM chat_wake");
+    setMeta(sql, "backupDue", "0");
+    await state.storage.setAlarm(Date.now());
+    // The chat keeps streaming while the R2 put is in flight.
+    const target = instance as unknown as { env: { BLOBS: { put: (...args: unknown[]) => Promise<unknown> } } };
+    const real = target.env.BLOBS;
+    target.env = { ...target.env, BLOBS: { ...real, put: async (...args: unknown[]) => {
+      appendRow(sql, "host", `during-${crypto.randomUUID()}`, new Uint8Array([9]), Date.now());
+      return real.put.apply(real, args);
+    } } };
+  });
+  // Fire it if the runtime has not already.
+  await runDurableObjectAlarm(room);
+  await expect.poll(() => runInDurableObject(room, (_i, state) => getMeta(state.storage.sql, "backupSeq"))).toBe("1");
+  await runInDurableObject(room, async (_instance, state) => {
+    const sql = state.storage.sql;
+    expect(getMeta(sql, "backupSeq")).toBe("1");
+    // The new row waits for the NEXT nightly backup, not an immediate re-run.
+    expect(getMeta(sql, "backupDirty")).toBe("1");
+    const due = Number(getMeta(sql, "backupDue"));
+    expect(due).toBeGreaterThan(Date.now() + 23 * 60 * 60 * 1000);
+    expect(await state.storage.getAlarm()).toBe(due);
+  });
+});
diff --git a/edge/test/workerd/fixture.ts b/edge/test/workerd/fixture.ts
index 10fbec317a..2f425acdeb 100644
--- a/edge/test/workerd/fixture.ts
+++ b/edge/test/workerd/fixture.ts
@@ -1,3 +1,4 @@
+import { chatRoute } from "../../src/chat-route";
 import { previewRoute } from "../../src/preview-route";
 export { DeviceRoom } from "../../src/device-room";
 export { ChatRoom } from "../../src/chat-room";
@@ -10,12 +11,12 @@ import { DurableObject } from "cloudflare:workers";
 export class TestLogRoom extends DurableObject {}
 
 export default {
-  fetch(request: Request, env: { PREVIEW_ROOMS: DurableObjectNamespace }): Response | Promise<Response> {
+  fetch(request: Request, env: { PREVIEW_ROOMS: DurableObjectNamespace; CHAT_ROOMS: DurableObjectNamespace }): Response | Promise<Response> {
     // Test credentials exercise the production routing seam without loading
     // the unrelated session-room WASM inside the Workers test runner.
     const bearer = request.headers.get("authorization");
     if (!bearer?.startsWith("Bearer ")) return new Response("Unauthorized", { status: 401 });
     const [userId, orgId] = bearer.slice(7).split("@");
-    return previewRoute(request, env, { userId, orgId }) ?? new Response("test fixture", { status: 404 });
+    return chatRoute(request, env, userId) ?? previewRoute(request, env, { userId, orgId }) ?? new Response("test fixture", { status: 404 });
   }
 };
diff --git a/edge/vitest.workerd.config.ts b/edge/vitest.workerd.config.ts
index 70b4994e1b..83eb707d92 100644
--- a/edge/vitest.workerd.config.ts
+++ b/edge/vitest.workerd.config.ts
@@ -18,6 +18,7 @@ export default defineConfig({
       main: "./test/workerd/fixture.ts",
       miniflare: {
         compatibilityDate: "2026-07-01",
+        r2Buckets: ["BLOBS"],
         durableObjects: {
           DEVICE_ROOMS: { className: "DeviceRoom", useSQLite: true },
           TEST_LOG: { className: "TestLogRoom", useSQLite: true },
diff --git a/scripts/test-linux-browser.sh b/scripts/test-linux-browser.sh
index fb31e1d87e..71f7507e8c 100755
--- a/scripts/test-linux-browser.sh
+++ b/scripts/test-linux-browser.sh
@@ -44,7 +44,7 @@ record_fixture() {
   fixture_pid=$!
   processes+=("$fixture_pid")
   if [ -z "$capture_window" ]; then
-    for _ in $(seq 1 100); do
+    for _ in $(seq 1 150); do
       capture_window="$(xdotool search --onlyvisible --pid "$fixture_pid" 2>/dev/null | head -1 || true)"
       [ -n "$capture_window" ] && break
       kill -0 "$fixture_pid" 2>/dev/null || { cat "$output/$mode/fixture.log"; return 1; }

From 0ab65ffeba403a23838adee0d9d4faac61c1b634 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 11:09:05 -0700
Subject: [PATCH 67/74] Explorer: group finished subagents, show running counts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Subagents section lists running subagents as plain rows, then folds
everything finished into a Finished dropdown (closed by default) with
Completed and Failed lists inside it. Each list collapses on its own and
pages at ten rows.

A "● N" pill shows how many subagents are running: on sidebar chat rows
(in place of the working spinner), under the titlebar's explorer button,
and beside the Subagents title. To badge chats that are not open, the
session row now carries `running_subagents`, published by the engine as
subagents open and settle. It is optional on the wire and stale rows
count as zero, like the working indicator.
---
 crates/client/src/demo/fixtures.rs           |   1 +
 crates/client/src/demo/mod.rs                |   1 +
 crates/doc/src/registry.rs                   |   2 +
 crates/doc/src/registry/tests.rs             |   1 +
 crates/doc/src/workspace.rs                  |  13 +
 crates/engine/src/sessions.rs                |  37 ++
 crates/engine/tests/e2e.rs                   |  74 ++++
 crates/engine/tests/workspace_sync.rs        |   1 +
 crates/mcp/src/tools.rs                      |   1 +
 crates/proto/src/entities.rs                 |   5 +
 crates/proto/src/view.rs                     |  35 ++
 crates/sync/tests/registry_client.rs         |   2 +
 crates/sync/tests/registry_edge.rs           |   2 +
 crates/ui/examples/macos-resource-profile.rs |   1 +
 crates/ui/src/files/mod.rs                   |   1 +
 crates/ui/src/files/sections.rs              | 345 +++++++++++++++----
 crates/ui/src/files/subagents.rs             | 249 +++++++++++++
 crates/ui/src/lib.rs                         |   1 +
 crates/ui/src/loaders.rs                     |  71 ++++
 crates/ui/src/running_pill.rs                |  64 ++++
 crates/ui/src/shell.rs                       |  33 +-
 crates/ui/src/shell/tabs.rs                  |  26 ++
 crates/ui/src/state.rs                       |  30 +-
 crates/ui/src/transcript.rs                  |   1 +
 24 files changed, 913 insertions(+), 84 deletions(-)
 create mode 100644 crates/ui/src/files/subagents.rs
 create mode 100644 crates/ui/src/running_pill.rs

diff --git a/crates/client/src/demo/fixtures.rs b/crates/client/src/demo/fixtures.rs
index f718b4512b..db0cb86cf1 100644
--- a/crates/client/src/demo/fixtures.rs
+++ b/crates/client/src/demo/fixtures.rs
@@ -435,6 +435,7 @@ pub(crate) fn seed(
         if let Some(status) = demo.status {
             doc.upsert_session(&Session {
                 last_completed_turn: None,
+                running_subagents: 0,
                 chat_id: demo.id.into(),
                 device_id: demo.device.into(),
                 status,
diff --git a/crates/client/src/demo/mod.rs b/crates/client/src/demo/mod.rs
index e969dd431c..528fb66ad2 100644
--- a/crates/client/src/demo/mod.rs
+++ b/crates/client/src/demo/mod.rs
@@ -447,6 +447,7 @@ impl DemoHost {
         let _ = client.registry_write(|doc| {
             doc.upsert_session(&Session {
                 last_completed_turn: completed.map(str::to_owned),
+                running_subagents: 0,
                 chat_id: chat_id.to_owned(),
                 device_id: host,
                 status,
diff --git a/crates/doc/src/registry.rs b/crates/doc/src/registry.rs
index eb28b36bcf..90f48b8755 100644
--- a/crates/doc/src/registry.rs
+++ b/crates/doc/src/registry.rs
@@ -1508,6 +1508,7 @@ impl RegistryDoc {
             ("lastCompletedTurn", json!(session.last_completed_turn)),
             ("startedAt", opt_ms(session.started_at)),
             ("updatedAt", json!(session.updated_at.timestamp_millis())),
+            ("runningSubagents", json!(session.running_subagents)),
         ]);
         self.write(KIND_SESSIONS, &session.chat_id.clone(), OpKind::Upsert, set);
         Ok(())
@@ -1685,6 +1686,7 @@ impl RegistryDoc {
                     ("lastCompletedTurn", json!(session.last_completed_turn)),
                     ("startedAt", opt_ms(session.started_at)),
                     ("updatedAt", json!(session.updated_at.timestamp_millis())),
+                    ("runningSubagents", json!(session.running_subagents)),
                 ]),
             );
         }
diff --git a/crates/doc/src/registry/tests.rs b/crates/doc/src/registry/tests.rs
index dec98ed2fd..632a72140a 100644
--- a/crates/doc/src/registry/tests.rs
+++ b/crates/doc/src/registry/tests.rs
@@ -296,6 +296,7 @@ fn space(id: &str, device_id: &str, path: &str) -> Space {
 fn session(chat_id: &str, device_id: &str, status: SessionStatus) -> Session {
     Session {
         last_completed_turn: None,
+        running_subagents: 0,
         chat_id: chat_id.into(),
         device_id: device_id.into(),
         status,
diff --git a/crates/doc/src/workspace.rs b/crates/doc/src/workspace.rs
index 7a8732cc99..eaf33f3504 100644
--- a/crates/doc/src/workspace.rs
+++ b/crates/doc/src/workspace.rs
@@ -487,6 +487,7 @@ impl WorkspaceDoc {
         )?;
         set_opt_ms(&row, "startedAt", session.started_at)?;
         row.insert("updatedAt", session.updated_at.timestamp_millis())?;
+        row.insert("runningSubagents", i64::from(session.running_subagents))?;
         self.doc.commit();
         Ok(())
     }
@@ -779,6 +780,8 @@ pub(crate) struct RawSession {
     started_at: Option<i64>,
     #[serde(default)]
     updated_at: i64,
+    #[serde(default)]
+    running_subagents: u32,
 }
 
 impl From<RawSession> for Session {
@@ -790,6 +793,7 @@ impl From<RawSession> for Session {
             status: raw.status,
             started_at: raw.started_at.map(dt),
             updated_at: dt(raw.updated_at),
+            running_subagents: raw.running_subagents,
         }
     }
 }
@@ -897,6 +901,7 @@ mod tests {
             status,
             started_at: Some(ts(3_000)),
             updated_at: ts(3_500),
+            running_subagents: 0,
         }
     }
 
@@ -991,6 +996,14 @@ mod tests {
             vec![session("chat-1", "dev-a", SessionStatus::Working)]
         );
 
+        // The running-subagent count rides the row and survives the round trip.
+        let mut busy = session("chat-1", "dev-a", SessionStatus::Working);
+        busy.running_subagents = 4;
+        ws.upsert_session(&busy).unwrap();
+        assert_eq!(ws.read_sessions().unwrap(), vec![busy]);
+        ws.upsert_session(&session("chat-1", "dev-a", SessionStatus::Working))
+            .unwrap();
+
         // Upsert refreshes in place — no duplicate rows, cleared options removed.
         let mut updated = chat("chat-1", "dev-a");
         updated.title = None;
diff --git a/crates/engine/src/sessions.rs b/crates/engine/src/sessions.rs
index 48efa8360a..cc8a13a9d9 100644
--- a/crates/engine/src/sessions.rs
+++ b/crates/engine/src/sessions.rs
@@ -1429,6 +1429,33 @@ impl Inner {
         self.set_status_with_completion(chat_id, status, fresh_start, None);
     }
 
+    /// Publish how many subagents of `chat_id` are streaming. A change is
+    /// mirrored like any status transition (it doubles as a heartbeat); an
+    /// unchanged count is a no-op, and a chat without a status row has
+    /// nothing to badge yet.
+    fn set_running_subagents(&self, chat_id: &str, running: usize) {
+        let running = u32::try_from(running).unwrap_or(u32::MAX);
+        let session = {
+            let mut statuses = lock(&self.statuses);
+            let Some(entry) = statuses.get_mut(chat_id) else {
+                return;
+            };
+            if entry.running_subagents == running {
+                return;
+            }
+            entry.running_subagents = running;
+            entry.updated_at = Utc::now();
+            let session = entry.clone();
+            let mut list: Vec<Session> = statuses.values().cloned().collect();
+            list.sort_by(|a, b| a.chat_id.cmp(&b.chat_id));
+            self.sessions_tx.send_replace(list);
+            session
+        };
+        if let Some(ws) = self.workspace() {
+            ws.record_session(&session);
+        }
+    }
+
     fn has_pending_steers(&self, chat_id: &str, run_id: &str) -> bool {
         lock(&self.runs)
             .get(chat_id)
@@ -1457,6 +1484,7 @@ impl Inner {
                     status,
                     started_at: None,
                     updated_at: now,
+                    running_subagents: 0,
                 });
             // `started_at` is the elapsed-timer base and must only ever mean
             // "this turn". Entering Working from a settled state always
@@ -2701,6 +2729,12 @@ async fn drive_run(
         {
             inner.publish(&chat_id, &event);
             last_subagent_activity = Some(tokio::time::Instant::now());
+            // Background subagents can outlive the turn and be the only
+            // traffic for minutes: keep the row (and its count) inside the
+            // UI's staleness window while any is live.
+            if !subagents.is_empty() {
+                inner.touch_session(&chat_id);
+            }
             let is_steer = matches!(
                 sub_event.as_ref(),
                 AgentEvent::UserMessage { .. } | AgentEvent::Steered { .. }
@@ -2775,6 +2809,7 @@ async fn drive_run(
                             dirty: false,
                         },
                     );
+                    inner.set_running_subagents(&chat_id, subagents.len());
                     if !chip_streaming {
                         let _ = doc_ref.update_subagent_chip(
                             parent_tool_use_id,
@@ -2832,6 +2867,7 @@ async fn drive_run(
                         _ => MessageStatus::Complete,
                     };
                     let sink = subagents.remove(parent_tool_use_id).expect("checked");
+                    inner.set_running_subagents(&chat_id, subagents.len());
                     let doc_id = sink.doc_id.clone();
                     // FREEZE: the finished transcript uploads as a static R2
                     // blob (`blob/{chatId}/{subDocId}`) so viewers of
@@ -3307,6 +3343,7 @@ async fn drive_run(
             );
         }
     }
+    inner.set_running_subagents(&chat_id, 0);
 
     // Claim any accepted-but-unconfirmed steers BEFORE the handle goes away:
     // a routed send that raced this exit either finds its entry gone (we own
diff --git a/crates/engine/tests/e2e.rs b/crates/engine/tests/e2e.rs
index 30b2232eb9..f1ee433898 100644
--- a/crates/engine/tests/e2e.rs
+++ b/crates/engine/tests/e2e.rs
@@ -3289,3 +3289,77 @@ async fn start_failure_lands_in_the_transcript() {
     ));
     core.sessions.shutdown().await;
 }
+
+/// The session row carries how many subagents are streaming, so sidebars on
+/// every device can badge a chat they have not opened.
+#[tokio::test(flavor = "multi_thread")]
+async fn session_row_counts_running_subagents_until_the_run_ends() {
+    fn spawn(id: &str) -> AgentEvent {
+        AgentEvent::ToolCall {
+            id: id.into(),
+            call: ToolCall::Unknown {
+                name: "Agent: probe".into(),
+                input: None,
+            },
+        }
+    }
+    fn chatter(parent: &str) -> AgentEvent {
+        AgentEvent::Subagent {
+            parent_tool_use_id: parent.into(),
+            event: Box::new(AgentEvent::TextDelta {
+                text: "working".into(),
+            }),
+        }
+    }
+    let dir = tempfile::tempdir().unwrap();
+    let core = assemble(
+        dir.path(),
+        Arc::new(ScriptedHarness {
+            script: vec![
+                spawn("sub-1"),
+                spawn("sub-2"),
+                chatter("sub-1"),
+                chatter("sub-2"),
+                AgentEvent::Subagent {
+                    parent_tool_use_id: "sub-1".into(),
+                    event: Box::new(done(DoneStatus::Completed)),
+                },
+            ],
+            step_delay: Duration::from_millis(400),
+            hang_until_interrupt: true,
+        }),
+    );
+    let running = || {
+        core.sessions
+            .session_status(CHAT)
+            .map(|s| s.running_subagents)
+    };
+    let handle = core.doc_host.open(CHAT).unwrap();
+    queue_as_viewer(
+        handle.doc(),
+        "subagents-run",
+        SessionCommandPayload::Run {
+            request: run_request("fan out"),
+            message_id: "subagents-user".into(),
+        },
+    );
+
+    wait_for(|| running() == Some(2), "both subagents counted").await;
+    wait_for(|| running() == Some(1), "one subagent settled").await;
+
+    queue_as_viewer(
+        handle.doc(),
+        "subagents-interrupt",
+        SessionCommandPayload::Interrupt {},
+    );
+    wait_for(
+        || core.sessions.session_status(CHAT).map(|s| s.status) == Some(SessionStatus::Idle),
+        "run to end",
+    )
+    .await;
+    assert_eq!(
+        running(),
+        Some(0),
+        "an ended run leaves no subagents counted"
+    );
+}
diff --git a/crates/engine/tests/workspace_sync.rs b/crates/engine/tests/workspace_sync.rs
index c992735801..54946ce006 100644
--- a/crates/engine/tests/workspace_sync.rs
+++ b/crates/engine/tests/workspace_sync.rs
@@ -722,6 +722,7 @@ async fn legacy_workspace_doc_migrates_instantly_on_first_boot() {
         legacy
             .upsert_session(&Session {
                 last_completed_turn: None,
+                running_subagents: 0,
                 chat_id: "chat-legacy".into(),
                 device_id: "dev-a".into(),
                 status: SessionStatus::Idle,
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index 0551261d29..5262d854e7 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -1527,6 +1527,7 @@ mod tests {
             started_at: None,
             updated_at: chrono::Utc::now() - chrono::Duration::minutes(10),
             last_completed_turn: None,
+            running_subagents: 0,
         };
         // No mid-turn capability is required for a live mailbox delivery.
         let sent = tools
diff --git a/crates/proto/src/entities.rs b/crates/proto/src/entities.rs
index 7b93cf08d4..3947465ea6 100644
--- a/crates/proto/src/entities.rs
+++ b/crates/proto/src/entities.rs
@@ -316,6 +316,11 @@ pub struct Session {
     pub status: SessionStatus,
     pub started_at: Option<DateTime<Utc>>,
     pub updated_at: DateTime<Utc>,
+    /// Subagents of this chat streaming right now. Rides the session row (and
+    /// its staleness window) so every device's sidebar can badge a chat it
+    /// has not opened; read it through `view::running_subagents`.
+    #[serde(default)]
+    pub running_subagents: u32,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
diff --git a/crates/proto/src/view.rs b/crates/proto/src/view.rs
index 32f7c6ace4..d244311844 100644
--- a/crates/proto/src/view.rs
+++ b/crates/proto/src/view.rs
@@ -63,6 +63,15 @@ pub fn effective_indicator(session: Option<&Session>, now: DateTime<Utc>) -> Ind
     }
 }
 
+/// Subagents running under a chat, staleness-checked like
+/// [`effective_indicator`]: a session row nobody has refreshed inside
+/// [`SESSION_STALE_MS`] belongs to a dead engine and counts nothing. Pure.
+pub fn running_subagents(session: Option<&Session>, now: DateTime<Utc>) -> u32 {
+    session
+        .filter(|s| now.signed_duration_since(s.updated_at).num_milliseconds() <= SESSION_STALE_MS)
+        .map_or(0, |s| s.running_subagents)
+}
+
 /// The full display status for a chat row / tab dot: live states win, then the
 /// synced seen marker decides completed-vs-idle. Staleness gating rides on
 /// [`effective_indicator`]; the derivation itself is [`crate::chat_indicator`].
@@ -247,6 +256,32 @@ mod gate_tests {
         }
     }
 
+    fn running_session(running: u32, updated_at: DateTime<Utc>) -> Session {
+        Session {
+            last_completed_turn: None,
+            chat_id: "chat".into(),
+            device_id: "dev".into(),
+            status: SessionStatus::Working,
+            started_at: None,
+            updated_at,
+            running_subagents: running,
+        }
+    }
+
+    #[test]
+    fn running_subagents_count_only_while_the_session_row_is_fresh() {
+        let now = Utc::now();
+        let fresh = running_session(3, now - chrono::Duration::seconds(10));
+        assert_eq!(running_subagents(Some(&fresh), now), 3);
+        // A crashed engine's row must not badge a chat forever.
+        let stale = running_session(
+            3,
+            now - chrono::Duration::milliseconds(SESSION_STALE_MS + 1),
+        );
+        assert_eq!(running_subagents(Some(&stale), now), 0);
+        assert_eq!(running_subagents(None, now), 0);
+    }
+
     #[test]
     fn workspace_scope_controls_the_auth_gate() {
         assert_eq!(
diff --git a/crates/sync/tests/registry_client.rs b/crates/sync/tests/registry_client.rs
index 5c66d37df4..dff1eeef8d 100644
--- a/crates/sync/tests/registry_client.rs
+++ b/crates/sync/tests/registry_client.rs
@@ -117,6 +117,7 @@ async fn two_clients_converge_and_stream_live_updates() {
         let mut doc = doc_a.lock().unwrap();
         doc.upsert_session(&Session {
             last_completed_turn: None,
+            running_subagents: 0,
             chat_id: "chat-1".into(),
             device_id: "dev-a".into(),
             status: SessionStatus::Working,
@@ -426,6 +427,7 @@ async fn churn_stays_bounded_no_history_growth() {
             let mut d = doc.lock().unwrap();
             d.upsert_session(&Session {
                 last_completed_turn: None,
+                running_subagents: 0,
                 chat_id: "chat-1".into(),
                 device_id: "dev-a".into(),
                 status: if i % 2 == 0 {
diff --git a/crates/sync/tests/registry_edge.rs b/crates/sync/tests/registry_edge.rs
index a46953fa31..419d4e970f 100644
--- a/crates/sync/tests/registry_edge.rs
+++ b/crates/sync/tests/registry_edge.rs
@@ -80,6 +80,7 @@ async fn two_rust_clients_converge_through_a_real_registry_do() {
         doc.upsert_chat(&chat("chat-live", "dev-live-a")).unwrap();
         doc.upsert_session(&Session {
             last_completed_turn: None,
+            running_subagents: 0,
             chat_id: "chat-live".into(),
             device_id: "dev-live-a".into(),
             status: SessionStatus::Working,
@@ -197,6 +198,7 @@ async fn cursor_delta_and_churn_stay_bounded_on_a_real_do() {
             let mut d = doc.lock().unwrap();
             d.upsert_session(&Session {
                 last_completed_turn: None,
+                running_subagents: 0,
                 chat_id: "chat-churn".into(),
                 device_id: "dev-churn".into(),
                 status: if i % 2 == 0 {
diff --git a/crates/ui/examples/macos-resource-profile.rs b/crates/ui/examples/macos-resource-profile.rs
index 7ff3673c95..77f0361174 100644
--- a/crates/ui/examples/macos-resource-profile.rs
+++ b/crates/ui/examples/macos-resource-profile.rs
@@ -148,6 +148,7 @@ fn main() -> anyhow::Result<()> {
                             .any(|entry| entry.status == Some(zeron_doc::MessageStatus::Streaming));
                         state.apply_sessions(vec![zeron_proto::Session {
                             last_completed_turn: None,
+                            running_subagents: 0,
                             chat_id: "profile".into(),
                             device_id: "local".into(),
                             status: if streaming {
diff --git a/crates/ui/src/files/mod.rs b/crates/ui/src/files/mod.rs
index cb25f4b684..0a69668a12 100644
--- a/crates/ui/src/files/mod.rs
+++ b/crates/ui/src/files/mod.rs
@@ -33,6 +33,7 @@ pub mod preview;
 mod rename;
 pub mod search;
 mod sections;
+mod subagents;
 #[cfg(test)]
 pub(crate) mod test_support;
 pub mod tree;
diff --git a/crates/ui/src/files/sections.rs b/crates/ui/src/files/sections.rs
index abc9398f41..33b3e94db0 100644
--- a/crates/ui/src/files/sections.rs
+++ b/crates/ui/src/files/sections.rs
@@ -30,6 +30,7 @@ use crate::state::AppState;
 use crate::theme::Theme;
 use crate::{loaders, motion};
 
+use super::subagents::{Group, GroupState, SubagentPlan};
 use super::{FilesEvent, FilesSurface};
 
 const SECTION_HEADER_HEIGHT: f32 = 28.0;
@@ -47,10 +48,12 @@ const EMPTY_PAD: f32 = 10.0;
 const LIST_FADE_BAND: f32 = 16.0;
 /// Hover group of a section header (reveals its actions).
 const HEADER_GROUP: &str = "files-section-header";
+/// How far each level of the Finished dropdown steps in.
+const GROUP_INDENT: f32 = 10.0;
 /// Rows a section shows before "Show more" pages it, and the page size —
 /// the sidebar's Archived shelf numbers.
-const INITIAL_ROWS: usize = 10;
-const PAGE_ROWS: usize = 10;
+pub(super) const INITIAL_ROWS: usize = 10;
+pub(super) const PAGE_ROWS: usize = 10;
 /// An open section never shrinks below this, so one or two rows still
 /// leave the section room to breathe.
 const MIN_BODY_HEIGHT: f32 = 120.0;
@@ -120,6 +123,8 @@ pub(super) struct ExplorerSections {
     /// One scroll handle per section list, so the edge fades can read
     /// overflow at paint time.
     scroll: HashMap<Section, ScrollHandle>,
+    /// Open/closed and paging state of the Finished dropdown.
+    groups: GroupState,
     /// Hash of what the footer would draw, so the state observer only
     /// re-renders the explorer when a section's contents actually changed —
     /// not on every streamed transcript delta.
@@ -146,6 +151,7 @@ impl Default for ExplorerSections {
             ]
             .into_iter()
             .collect(),
+            groups: GroupState::default(),
             fingerprint: 0,
             chat_rename: None,
             reveal: None,
@@ -394,10 +400,24 @@ fn content_height_unfloored(section: Section, count: usize, shown: usize) -> f32
     }
     let visible = count.min(shown);
     let more = if count > shown { 1 } else { 0 };
-    let slots = visible + more;
+    rows_height(visible + more)
+}
+
+/// The height of a list of `slots` row-sized items: the inset, the rows and
+/// the gaps between them.
+fn rows_height(slots: usize) -> f32 {
     SECTION_BODY_INSET + slots as f32 * ROW_HEIGHT + slots.saturating_sub(1) as f32 * ROW_GAP
 }
 
+/// The Subagents body's wanted height: its rows and group headers, or the
+/// empty-state copy when nothing is left to list.
+fn subagents_height(plan: &SubagentPlan, groups: &GroupState) -> f32 {
+    match plan.slots(groups) {
+        0 => content_height(Section::Subagents, 0, INITIAL_ROWS),
+        slots => rows_height(slots).max(MIN_BODY_HEIGHT),
+    }
+}
+
 /// Split the footer's body budget between two open sections: each may take
 /// what it wants, and a short one hands its slack to the other. Closed
 /// sections get 0. Pure.
@@ -480,12 +500,9 @@ impl FilesSurface {
             )
         };
         self.sections.fingerprint = fingerprint(self.state.read(cx), &self.chat_id, now);
+        let plan = SubagentPlan::new(subagents);
         let wants = [
-            content_height(
-                Section::Subagents,
-                subagents.len(),
-                self.sections.shown(Section::Subagents),
-            ),
+            subagents_height(&plan, &self.sections.groups),
             content_height(
                 Section::Chats,
                 chats.len(),
@@ -499,7 +516,14 @@ impl FilesSurface {
         let budget = FOOTER_HEIGHT - chrome_height();
         let heights = body_budget(budget, wants, open);
         let view = cx.entity_id();
-        let subagent_body = self.render_subagent_rows(&subagents, view, theme, cx);
+        let subagent_body = self.render_subagent_rows(&plan, view, theme, cx);
+        let subagent_badge = (plan.running() > 0).then(|| {
+            crate::running_pill::running_pill(
+                "files-subagents-header",
+                plan.running() as u32,
+                theme,
+            )
+        });
         let chat_body = self.render_chat_rows(&chats, theme, cx);
         let chats_actions = self.render_chats_header_actions(theme, cx);
         div()
@@ -514,10 +538,11 @@ impl FilesSurface {
             .pb(px(FOOTER_PAD_BOTTOM))
             .child(self.render_section(
                 Section::Subagents,
-                subagents.len(),
+                plan.total(),
                 wants[0],
                 heights[0],
                 None,
+                subagent_badge,
                 subagent_body,
                 theme,
                 cx,
@@ -528,6 +553,7 @@ impl FilesSurface {
                 wants[1],
                 heights[1],
                 Some(chats_actions),
+                None,
                 chat_body,
                 theme,
                 cx,
@@ -583,6 +609,7 @@ impl FilesSurface {
         wanted: f32,
         height: f32,
         actions: Option<AnyElement>,
+        badge: Option<AnyElement>,
         body: AnyElement,
         theme: &Theme,
         cx: &mut Context<Self>,
@@ -634,14 +661,25 @@ impl FilesSurface {
                 cx.notify();
             }))
             .child(
+                // The badge trails the title, not the caret: the title
+                // truncates first, the badge never does.
                 div()
                     .flex_1()
                     .min_w_0()
-                    .truncate()
-                    .text_size(crate::typography::ui_rems(12.0))
-                    .font_weight(gpui::FontWeight::MEDIUM)
-                    .text_color(theme.text_muted.opacity(0.5))
-                    .child(label),
+                    .flex()
+                    .flex_row()
+                    .items_center()
+                    .gap(px(6.0))
+                    .child(
+                        div()
+                            .min_w_0()
+                            .truncate()
+                            .text_size(crate::typography::ui_rems(12.0))
+                            .font_weight(gpui::FontWeight::MEDIUM)
+                            .text_color(theme.text_muted.opacity(0.5))
+                            .child(label),
+                    )
+                    .children(badge),
             )
             .children(actions)
             .child(self.render_chevron(section, open, theme));
@@ -736,40 +774,29 @@ impl FilesSurface {
         theme: &Theme,
         cx: &mut Context<Self>,
     ) -> AnyElement {
-        div()
-            .id(SharedString::from(format!(
-                "files-section-{}-more",
-                section.key()
-            )))
-            .role(gpui::Role::Button)
-            .flex_none()
-            .h(px(ROW_HEIGHT))
-            .flex()
-            .items_center()
-            .px(px(Theme::SPACE_SM))
-            .rounded(px(8.0))
-            .cursor_pointer()
-            .text_size(crate::typography::ui_rems(12.0))
-            .text_color(theme.text_muted.opacity(0.7))
-            .hover(|s| s.bg(theme.glass_hover()).text_color(theme.text_muted))
-            .child(format!("Show {} more", remaining.min(PAGE_ROWS)))
-            .on_click(cx.listener(move |this, _, _, cx| {
-                cx.stop_propagation();
-                let shown = this.sections.shown(section) + PAGE_ROWS;
-                this.sections.shown.insert(section, shown);
-                cx.notify();
-            }))
-            .into_any_element()
+        show_more_row(
+            format!("files-section-{}-more", section.key()),
+            remaining,
+            0.0,
+            theme,
+        )
+        .on_click(cx.listener(move |this, _, _, cx| {
+            cx.stop_propagation();
+            let shown = this.sections.shown(section) + PAGE_ROWS;
+            this.sections.shown.insert(section, shown);
+            cx.notify();
+        }))
+        .into_any_element()
     }
 
     fn render_subagent_rows(
         &self,
-        rows: &[SubagentRow],
+        plan: &SubagentPlan,
         view: EntityId,
         theme: &Theme,
         cx: &mut Context<Self>,
     ) -> AnyElement {
-        if rows.is_empty() {
+        if plan.total() == 0 {
             return empty_state(
                 "Subagents will appear here when they are created",
                 None,
@@ -777,51 +804,192 @@ impl FilesSurface {
             );
         }
         let now = Utc::now();
-        let shown = self.sections.shown(Section::Subagents);
         let scroll = self.sections.scroll(Section::Subagents);
         let mut list = row_list("files-subagent-rows", &scroll);
-        for row in rows.iter().take(shown) {
-            let glyph = status_glyph(
-                format!("files-subagent-{}", row.doc_id),
-                row.indicator(),
-                view,
-                theme,
-                cx,
-            );
-            let open = row.clone();
-            list = list.child(
-                compact_row(format!("files-subagent-{}", row.doc_id), theme)
-                    .aria_label(SharedString::from(format!("Open subagent {}", row.title)))
-                    .on_click(cx.listener(move |_, _, _, cx| {
-                        cx.stop_propagation();
-                        cx.emit(FilesEvent::OpenSubagent {
-                            doc_id: open.doc_id.clone(),
-                            title: open.title.to_string(),
-                            frozen: open.frozen(),
-                        });
-                    }))
-                    .child(glyph)
-                    .child(row_title(
-                        format!("files-subagent-title-{}", row.doc_id),
-                        row.title.clone(),
-                    ))
-                    .child(time_ago_label(
-                        zeron_proto::view::format_time_ago(row.spawned_at, now).into(),
-                        theme,
-                    )),
-            );
+        for row in &plan.active {
+            list = list.child(self.render_subagent_row(row, 0.0, now, view, theme, cx));
         }
-        if rows.len() > shown {
-            list = list.child(self.render_show_more(
-                Section::Subagents,
-                rows.len() - shown,
+        if plan.finished() > 0 {
+            list = list.child(self.render_group_header(
+                Group::Finished,
+                plan.finished(),
+                0.0,
                 theme,
                 cx,
             ));
+            if self.sections.groups.is_open(Group::Finished) {
+                for group in [Group::Completed, Group::Failed] {
+                    let rows = plan.rows(group);
+                    if rows.is_empty() {
+                        continue;
+                    }
+                    list = list.child(self.render_group_header(
+                        group,
+                        rows.len(),
+                        GROUP_INDENT,
+                        theme,
+                        cx,
+                    ));
+                    if !self.sections.groups.is_open(group) {
+                        continue;
+                    }
+                    let shown = self.sections.groups.shown(group);
+                    for row in rows.iter().take(shown) {
+                        list = list.child(self.render_subagent_row(
+                            row,
+                            2.0 * GROUP_INDENT,
+                            now,
+                            view,
+                            theme,
+                            cx,
+                        ));
+                    }
+                    if rows.len() > shown {
+                        list = list.child(self.render_group_show_more(
+                            group,
+                            rows.len() - shown,
+                            2.0 * GROUP_INDENT,
+                            theme,
+                            cx,
+                        ));
+                    }
+                }
+            }
         }
         faded_list(list, &scroll)
     }
 
+    /// One subagent: status glyph, title, and the time it was last updated.
+    fn render_subagent_row(
+        &self,
+        row: &SubagentRow,
+        indent: f32,
+        now: DateTime<Utc>,
+        view: EntityId,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let glyph = status_glyph(
+            format!("files-subagent-{}", row.doc_id),
+            row.indicator(),
+            view,
+            theme,
+            cx,
+        );
+        let open = row.clone();
+        compact_row(format!("files-subagent-{}", row.doc_id), theme)
+            .pl(px(Theme::SPACE_SM + indent))
+            .aria_label(SharedString::from(format!("Open subagent {}", row.title)))
+            .on_click(cx.listener(move |_, _, _, cx| {
+                cx.stop_propagation();
+                cx.emit(FilesEvent::OpenSubagent {
+                    doc_id: open.doc_id.clone(),
+                    title: open.title.to_string(),
+                    frozen: open.frozen(),
+                });
+            }))
+            .child(glyph)
+            .child(row_title(
+                format!("files-subagent-title-{}", row.doc_id),
+                row.title.clone(),
+            ))
+            .child(time_ago_label(
+                zeron_proto::view::format_time_ago(row.spawned_at, now).into(),
+                theme,
+            ))
+            .into_any_element()
+    }
+
+    /// A dropdown header inside the Subagents body: caret and
+    /// "Label (count)". Clicking toggles the group.
+    fn render_group_header(
+        &self,
+        group: Group,
+        count: usize,
+        indent: f32,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let open = self.sections.groups.is_open(group);
+        let chevron = icon(icons::ALT_ARROW_RIGHT)
+            .size(px(12.0))
+            .text_color(theme.text_muted.opacity(0.5))
+            .with_transformation(gpui::Transformation::rotate(gpui::percentage(if open {
+                0.25
+            } else {
+                0.0
+            })));
+        div()
+            .id(SharedString::from(format!(
+                "files-subagent-group-{}",
+                group.key()
+            )))
+            .role(gpui::Role::Button)
+            .aria_label(SharedString::from(format!(
+                "{} {} subagents",
+                if open { "Collapse" } else { "Expand" },
+                group.label()
+            )))
+            .flex_none()
+            .h(px(ROW_HEIGHT))
+            .flex()
+            .flex_row()
+            .items_center()
+            .gap(px(2.0))
+            .rounded(px(8.0))
+            .pl(px(Theme::SPACE_SM + indent - 4.0))
+            .pr(px(4.0))
+            .cursor_pointer()
+            .hover(|s| s.bg(theme.glass_hover()))
+            .on_click(cx.listener(move |this, _, _, cx| {
+                this.sections.groups.toggle(group);
+                cx.notify();
+            }))
+            .child(
+                div()
+                    .flex_none()
+                    .size(px(16.0))
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .child(chevron),
+            )
+            .child(
+                div()
+                    .flex_1()
+                    .min_w_0()
+                    .truncate()
+                    .text_size(crate::typography::ui_rems(12.0))
+                    .font_weight(gpui::FontWeight::MEDIUM)
+                    .text_color(theme.text_muted.opacity(0.7))
+                    .child(SharedString::from(format!("{} ({count})", group.label()))),
+            )
+            .into_any_element()
+    }
+
+    /// "Show N more" under one finished category, indented with its rows.
+    fn render_group_show_more(
+        &self,
+        group: Group,
+        remaining: usize,
+        indent: f32,
+        theme: &Theme,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        show_more_row(
+            format!("files-subagent-group-{}-more", group.key()),
+            remaining,
+            indent,
+            theme,
+        )
+        .on_click(cx.listener(move |this, _, _, cx| {
+            cx.stop_propagation();
+            this.sections.groups.page_up(group);
+            cx.notify();
+        }))
+        .into_any_element()
+    }
+
     fn render_chat_rows(
         &self,
         rows: &[ChildChatRow],
@@ -974,6 +1142,31 @@ fn header_action(
         )
 }
 
+/// A section's "Show N more" row (a page is [`PAGE_ROWS`]), indented to line
+/// up with the rows it pages.
+fn show_more_row(
+    id: String,
+    remaining: usize,
+    indent: f32,
+    theme: &Theme,
+) -> gpui::Stateful<gpui::Div> {
+    div()
+        .id(SharedString::from(id))
+        .role(gpui::Role::Button)
+        .flex_none()
+        .h(px(ROW_HEIGHT))
+        .flex()
+        .items_center()
+        .pl(px(Theme::SPACE_SM + indent))
+        .pr(px(Theme::SPACE_SM))
+        .rounded(px(8.0))
+        .cursor_pointer()
+        .text_size(crate::typography::ui_rems(12.0))
+        .text_color(theme.text_muted.opacity(0.7))
+        .hover(|s| s.bg(theme.glass_hover()).text_color(theme.text_muted))
+        .child(format!("Show {} more", remaining.min(PAGE_ROWS)))
+}
+
 /// The empty state's pill buttons — the explorer's Retry button shape.
 fn pill_button(
     id: &'static str,
diff --git a/crates/ui/src/files/subagents.rs b/crates/ui/src/files/subagents.rs
new file mode 100644
index 0000000000..a7beec720b
--- /dev/null
+++ b/crates/ui/src/files/subagents.rs
@@ -0,0 +1,249 @@
+//! The Subagents section's model, kept pure so its shape and height are
+//! testable without a window.
+//!
+//! Running subagents lead the body as plain rows. Everything that has
+//! settled folds into one **Finished** dropdown, closed until opened, that
+//! splits into **Completed** and **Failed** lists. Rows are read from the
+//! transcript's spawn chips, so nothing here removes or hides one.
+
+use std::collections::{HashMap, HashSet};
+
+use zeron_doc::SubagentStatus;
+
+use super::sections::{INITIAL_ROWS, PAGE_ROWS, SubagentRow};
+
+/// A collapsible group of finished subagents.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(super) enum Group {
+    /// Parent of the two categories below.
+    Finished,
+    Completed,
+    Failed,
+}
+
+impl Group {
+    pub fn label(self) -> &'static str {
+        match self {
+            Group::Finished => "Finished",
+            Group::Completed => "Completed",
+            Group::Failed => "Failed",
+        }
+    }
+
+    pub fn key(self) -> &'static str {
+        match self {
+            Group::Finished => "finished",
+            Group::Completed => "completed",
+            Group::Failed => "failed",
+        }
+    }
+}
+
+/// Open/closed and paging state of the groups. The Finished dropdown starts
+/// closed, so the body opens on what is running; the two lists inside it start
+/// open, so one click shows every finished subagent.
+#[derive(Debug, Default)]
+pub(super) struct GroupState {
+    /// Groups flipped away from their default.
+    flipped: HashSet<Group>,
+    /// Rows revealed per category ("Show more" pages this up).
+    shown: HashMap<Group, usize>,
+}
+
+impl GroupState {
+    pub fn is_open(&self, group: Group) -> bool {
+        let default_open = group != Group::Finished;
+        default_open != self.flipped.contains(&group)
+    }
+
+    pub fn toggle(&mut self, group: Group) {
+        if !self.flipped.remove(&group) {
+            self.flipped.insert(group);
+        }
+    }
+
+    pub fn shown(&self, group: Group) -> usize {
+        self.shown
+            .get(&group)
+            .copied()
+            .unwrap_or(INITIAL_ROWS)
+            .max(INITIAL_ROWS)
+    }
+
+    pub fn page_up(&mut self, group: Group) {
+        let shown = self.shown(group) + PAGE_ROWS;
+        self.shown.insert(group, shown);
+    }
+}
+
+/// The rows the Subagents body draws, in the order it draws them.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(super) struct SubagentPlan {
+    /// Not settled: running first (longest-running leading), then any row
+    /// whose status has not been stamped yet.
+    pub active: Vec<SubagentRow>,
+    pub completed: Vec<SubagentRow>,
+    pub failed: Vec<SubagentRow>,
+}
+
+impl SubagentPlan {
+    /// Sort `rows` (already in display order) into the three lists.
+    pub fn new(rows: Vec<SubagentRow>) -> Self {
+        let mut plan = Self::default();
+        for row in rows {
+            match row.status {
+                Some(SubagentStatus::Done) => plan.completed.push(row),
+                Some(SubagentStatus::Failed) => plan.failed.push(row),
+                _ => plan.active.push(row),
+            }
+        }
+        plan
+    }
+
+    /// Subagents streaming right now.
+    pub fn running(&self) -> usize {
+        self.active
+            .iter()
+            .filter(|row| row.status == Some(SubagentStatus::Running))
+            .count()
+    }
+
+    pub fn finished(&self) -> usize {
+        self.completed.len() + self.failed.len()
+    }
+
+    /// Everything the list would show with all groups open.
+    pub fn total(&self) -> usize {
+        self.active.len() + self.finished()
+    }
+
+    /// The rows behind a group; `Finished` is both categories, completed first.
+    pub fn rows(&self, group: Group) -> Vec<&SubagentRow> {
+        match group {
+            Group::Finished => self.completed.iter().chain(&self.failed).collect(),
+            Group::Completed => self.completed.iter().collect(),
+            Group::Failed => self.failed.iter().collect(),
+        }
+    }
+
+    /// Row-sized slots the body occupies: each visible row, each group
+    /// header, and a "Show more" row wherever a category is paged.
+    pub fn slots(&self, groups: &GroupState) -> usize {
+        let mut slots = self.active.len();
+        if self.finished() == 0 {
+            return slots;
+        }
+        slots += 1;
+        if !groups.is_open(Group::Finished) {
+            return slots;
+        }
+        for group in [Group::Completed, Group::Failed] {
+            let count = self.rows(group).len();
+            if count == 0 {
+                continue;
+            }
+            slots += 1;
+            if groups.is_open(group) {
+                let shown = groups.shown(group);
+                slots += count.min(shown) + usize::from(count > shown);
+            }
+        }
+        slots
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use chrono::Utc;
+
+    use super::*;
+
+    fn row(id: &str, status: Option<SubagentStatus>) -> SubagentRow {
+        SubagentRow {
+            doc_id: id.into(),
+            title: id.to_owned().into(),
+            status,
+            spawned_at: Utc::now(),
+        }
+    }
+
+    fn mixed() -> Vec<SubagentRow> {
+        vec![
+            row("run", Some(SubagentStatus::Running)),
+            row("new", None),
+            row("ok-1", Some(SubagentStatus::Done)),
+            row("bad", Some(SubagentStatus::Failed)),
+            row("ok-2", Some(SubagentStatus::Done)),
+        ]
+    }
+
+    fn ids(rows: &[SubagentRow]) -> Vec<&str> {
+        rows.iter().map(|r| r.doc_id.as_str()).collect()
+    }
+
+    /// Groups as the section first draws them, with Finished opened.
+    fn opened() -> GroupState {
+        let mut groups = GroupState::default();
+        groups.toggle(Group::Finished);
+        groups
+    }
+
+    #[test]
+    fn settled_rows_fold_into_lists_and_the_rest_stay_on_top() {
+        let plan = SubagentPlan::new(mixed());
+        assert_eq!(ids(&plan.active), ["run", "new"]);
+        assert_eq!(ids(&plan.completed), ["ok-1", "ok-2"]);
+        assert_eq!(ids(&plan.failed), ["bad"]);
+        assert_eq!((plan.running(), plan.finished(), plan.total()), (1, 3, 5));
+    }
+
+    #[test]
+    fn finished_starts_closed_and_its_lists_start_open() {
+        let groups = GroupState::default();
+        assert!(!groups.is_open(Group::Finished));
+        assert!(groups.is_open(Group::Completed));
+        assert!(groups.is_open(Group::Failed));
+    }
+
+    #[test]
+    fn slots_follow_what_is_open() {
+        let plan = SubagentPlan::new(mixed());
+        let mut groups = GroupState::default();
+        // Closed: 2 active + the Finished header.
+        assert_eq!(plan.slots(&groups), 2 + 1);
+        groups.toggle(Group::Finished);
+        // + (Completed header + 2) + (Failed header + 1)
+        assert_eq!(plan.slots(&groups), 2 + 1 + 3 + 2);
+        groups.toggle(Group::Failed);
+        assert_eq!(plan.slots(&groups), 2 + 1 + 3 + 1);
+        // Closing the parent keeps each list's own state for the next open.
+        groups.toggle(Group::Finished);
+        assert_eq!(plan.slots(&groups), 2 + 1);
+        groups.toggle(Group::Finished);
+        assert_eq!(plan.slots(&groups), 2 + 1 + 3 + 1);
+    }
+
+    #[test]
+    fn nothing_finished_means_no_group_chrome() {
+        let rows = vec![row("run", Some(SubagentStatus::Running))];
+        let plan = SubagentPlan::new(rows);
+        assert_eq!(plan.slots(&opened()), 1);
+        assert_eq!(SubagentPlan::default().slots(&opened()), 0);
+    }
+
+    #[test]
+    fn a_long_list_pages_and_counts_its_show_more_row() {
+        let rows: Vec<_> = (0..25)
+            .map(|i| row(&format!("ok-{i}"), Some(SubagentStatus::Done)))
+            .collect();
+        let plan = SubagentPlan::new(rows);
+        let mut groups = opened();
+        // Finished header + Completed header + 10 rows + "Show more".
+        assert_eq!(plan.slots(&groups), 1 + 1 + INITIAL_ROWS + 1);
+        groups.page_up(Group::Completed);
+        assert_eq!(plan.slots(&groups), 1 + 1 + INITIAL_ROWS + PAGE_ROWS + 1);
+        groups.page_up(Group::Completed);
+        // All 25 shown: no "Show more" left.
+        assert_eq!(plan.slots(&groups), 1 + 1 + 25);
+    }
+}
diff --git a/crates/ui/src/lib.rs b/crates/ui/src/lib.rs
index ad81f2eaf7..101b3ea204 100644
--- a/crates/ui/src/lib.rs
+++ b/crates/ui/src/lib.rs
@@ -55,6 +55,7 @@ pub mod project_actions;
 pub mod queue;
 pub mod rail;
 mod roll_text;
+pub mod running_pill;
 pub mod settings;
 pub mod shell;
 pub mod sound;
diff --git a/crates/ui/src/loaders.rs b/crates/ui/src/loaders.rs
index 882da4ad71..bebe3795d8 100644
--- a/crates/ui/src/loaders.rs
+++ b/crates/ui/src/loaders.rs
@@ -270,6 +270,77 @@ fn mini_spinner_cells(
         }))
 }
 
+/// A dot that breathes on the zeron pulse clock (opacity only, so it never
+/// moves layout). Like the mini spinners it repaints from its own cached
+/// view, so a row of them costs the surrounding list nothing.
+pub fn pulse_dot(
+    key: impl Into<SharedString>,
+    diameter: f32,
+    tint: gpui::Hsla,
+) -> impl IntoElement {
+    PulseDot {
+        key: key.into(),
+        diameter,
+        tint,
+    }
+}
+
+/// Rest opacity of [`pulse_dot`]'s trough: dimmer than full, never gone, so
+/// the dot still reads as a status between beats.
+const PULSE_DOT_FLOOR: f32 = 0.4;
+
+#[derive(IntoElement)]
+struct PulseDot {
+    key: SharedString,
+    diameter: f32,
+    tint: gpui::Hsla,
+}
+
+impl RenderOnce for PulseDot {
+    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let view = window.with_global_id(self.key.into(), |id, window| {
+            window.with_element_state(id, |previous: Option<Entity<PulseDotView>>, _| {
+                let view = previous.unwrap_or_else(|| {
+                    cx.new(|_| PulseDotView {
+                        diameter: self.diameter,
+                        tint: self.tint,
+                    })
+                });
+                view.update(cx, |view, cx| {
+                    if view.diameter != self.diameter || view.tint != self.tint {
+                        view.diameter = self.diameter;
+                        view.tint = self.tint;
+                        cx.notify();
+                    }
+                });
+                (view.clone(), view)
+            })
+        });
+        view.cached(
+            gpui::StyleRefinement::default()
+                .w(px(self.diameter))
+                .h(px(self.diameter)),
+        )
+    }
+}
+
+struct PulseDotView {
+    diameter: f32,
+    tint: gpui::Hsla,
+}
+
+impl Render for PulseDotView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let delta = motion::pulse_delta_slow(&ZERON_PULSE, cx.entity_id(), cx);
+        let wave = motion::lerp(PULSE_DOT_FLOOR, 1.0, motion::pulse_opacity(delta));
+        div()
+            .size(px(self.diameter))
+            .rounded_full()
+            .bg(self.tint)
+            .opacity(wave)
+    }
+}
+
 /// Stroke width of [`upload_progress_ring`].
 const RING_STROKE: f32 = 2.5;
 /// Polyline segments for a full circle — plenty for a ≤40px ring.
diff --git a/crates/ui/src/running_pill.rs b/crates/ui/src/running_pill.rs
new file mode 100644
index 0000000000..8d39f6f31e
--- /dev/null
+++ b/crates/ui/src/running_pill.rs
@@ -0,0 +1,64 @@
+//! The "● 3" pill: how many subagents are running. One shape shared by the
+//! sidebar's chat rows (in place of the working spinner), the titlebar's
+//! explorer button, and the explorer's Subagents header, so the number reads
+//! the same wherever it turns up.
+
+use gpui::{AnyElement, SharedString, div, prelude::*, px};
+
+use crate::loaders;
+use crate::theme::Theme;
+
+/// Pill height. The sidebar's status slot is 13px and its rows 29px; 16px
+/// matches the sidebar's pull-request badge so the two never disagree.
+const HEIGHT: f32 = 16.0;
+const DOT: f32 = 5.0;
+/// Past this the count would outgrow the pill; it reads "99+".
+const COUNT_CAP: u32 = 99;
+
+/// The count as drawn: exact up to [`COUNT_CAP`], then "99+".
+pub fn count_label(count: u32) -> SharedString {
+    if count > COUNT_CAP {
+        format!("{COUNT_CAP}+").into()
+    } else {
+        count.to_string().into()
+    }
+}
+
+/// The pill for `count` running subagents; callers draw nothing at zero.
+/// `key` scopes the dot's animation state — one per placement.
+pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) -> AnyElement {
+    let tone = theme.busy;
+    div()
+        .h(px(HEIGHT))
+        .flex_none()
+        .flex()
+        .flex_row()
+        .items_center()
+        .gap(px(4.0))
+        .px(px(6.0))
+        .rounded(px(HEIGHT / 2.0))
+        .bg(tone.opacity(0.16))
+        .child(loaders::pulse_dot(key, DOT, tone))
+        .child(
+            div()
+                .text_size(crate::typography::ui_rems(10.0))
+                .line_height(px(HEIGHT))
+                .font_weight(gpui::FontWeight::MEDIUM)
+                .font_family(theme.font_mono.clone())
+                .text_color(tone)
+                .child(count_label(count)),
+        )
+        .into_any_element()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn count_label_caps_at_ninety_nine() {
+        assert_eq!(count_label(1).as_ref(), "1");
+        assert_eq!(count_label(99).as_ref(), "99");
+        assert_eq!(count_label(100).as_ref(), "99+");
+    }
+}
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index d8d1a83def..c578ee9f00 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -7387,8 +7387,25 @@ impl Shell {
         let shows_metadata = branch.is_some() || change_request.is_some();
         let queued = queued && !undelivered;
         let working = status == zeron_proto::ChatIndicator::Working && !queued && !undelivered;
+        // Subagents running under this chat trade the working spinner for the
+        // "● N" pill: the count is the more useful thing to know, and it keeps
+        // showing after the parent's own turn has settled.
+        let running_subagents = self.state.read(cx).running_subagents_for(&id, Utc::now());
+        let subagent_pill = |suffix: &str| {
+            (running_subagents > 0).then(|| {
+                crate::running_pill::running_pill(
+                    format!("{row_id}-subagents-{suffix}"),
+                    running_subagents,
+                    theme,
+                )
+            })
+        };
         let compact_status = compact.then(|| {
-            let glyph = if working {
+            let pill = subagent_pill("compact");
+            let has_pill = pill.is_some();
+            let glyph = if let Some(pill) = pill {
+                pill
+            } else if working {
                 loaders::mini_glyph_spinner(
                     format!("{row_id}-working"),
                     2.0,
@@ -7415,7 +7432,10 @@ impl Shell {
                     let id = id.clone();
                     move || format!("chat-status-{id}")
                 })
-                .size(px(13.0))
+                // The pill is wider than the 13px glyph slot: the slot keeps its
+                // height and lets the width follow.
+                .h(px(13.0))
+                .when(!has_pill, |slot| slot.w(px(13.0)))
                 .flex_none()
                 .flex()
                 .items_center()
@@ -7507,7 +7527,9 @@ impl Shell {
                     // Glyph slot: Working wears the preset's animated pixel
                     // glyph beside its label, Done wears the check, and the
                     // remaining statuses use a compact dot.
-                    let glyph: AnyElement = if status == zeron_proto::ChatIndicator::Completed {
+                    let glyph: AnyElement = if let Some(pill) = subagent_pill("label") {
+                        pill
+                    } else if status == zeron_proto::ChatIndicator::Completed {
                         icon(icons::CHECK)
                             .size(px(11.0))
                             .flex_none()
@@ -7546,8 +7568,13 @@ impl Shell {
                         .into_any_element()
                 }
                 None => div()
+                    .flex()
+                    .flex_row()
+                    .items_center()
+                    .gap(px(6.0))
                     .text_size(crate::typography::ui_rems(10.0))
                     .font_weight(gpui::FontWeight::MEDIUM)
+                    .children(subagent_pill("idle"))
                     .child(time_ago.clone())
                     .into_any_element(),
             }
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index 4b788a3376..8d3211500b 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -405,6 +405,13 @@ impl Shell {
         let available_titlebar_width =
             (self.viewport_width - row_left - right_pad - trailing_width - row_gap * 3.0).max(0.0);
 
+        let running_subagents = {
+            let state = self.state.read(cx);
+            state
+                .selected_chat
+                .as_deref()
+                .map_or(0, |chat| state.running_subagents_for(chat, Utc::now()))
+        };
         let trailing: Option<gpui::AnyElement> = if on_canvas {
             None
         } else {
@@ -505,6 +512,25 @@ impl Shell {
                                 .aria_label(files_panel_label)
                                 .when(self.files_panel_open(cx), |button| {
                                     button.bg(crate::theme::wash(0.09))
+                                })
+                                // Running subagents live in this panel: badge
+                                // the button so they are findable while it is
+                                // closed.
+                                .when(running_subagents > 0, |button| {
+                                    button.relative().child(
+                                        div()
+                                            .absolute()
+                                            .left_0()
+                                            .right_0()
+                                            .bottom(px(-8.0))
+                                            .flex()
+                                            .justify_center()
+                                            .child(crate::running_pill::running_pill(
+                                                "toggle-files-panel-subagents",
+                                                running_subagents,
+                                                &theme,
+                                            )),
+                                    )
                                 }),
                             )
                             .child(header_icon_button_with(
diff --git a/crates/ui/src/state.rs b/crates/ui/src/state.rs
index 916a6d2357..7d1234679a 100644
--- a/crates/ui/src/state.rs
+++ b/crates/ui/src/state.rs
@@ -598,9 +598,19 @@ async fn query_engine_info(client: &RpcClient) -> Result<EngineInfo, RpcError> {
 pub use zeron_proto::view::{
     ChatGroup, ConnectionStatus, GatePhase, Indicator, SESSION_STALE_MS, attention_rank,
     chat_location, display_status, effective_indicator, format_time_ago, gate_phase, group_chats,
-    parse_auth_state, project_label, sort_active, sort_chats, sort_spaces, sort_tabs,
+    parse_auth_state, project_label, running_subagents, sort_active, sort_chats, sort_spaces, sort_tabs,
 };
 
+/// What a session row shows that ticks with the clock rather than with its
+/// content: the staleness-checked indicator and running-subagent count. A
+/// change in either must repaint even when the row itself is untouched.
+fn session_presence(session: &Session, now: DateTime<Utc>) -> (Indicator, u32) {
+    (
+        effective_indicator(Some(session), now),
+        running_subagents(Some(session), now),
+    )
+}
+
 // ---------------------------------------------------------------------------
 // Org gate (pure)
 // ---------------------------------------------------------------------------
@@ -751,7 +761,7 @@ pub struct AppState {
     device_presentation: Option<Vec<(Device, bool, String)>>,
     // Presence ticks also retire stale remote session indicators. Remember
     // their last published appearance even when the device rows stay online.
-    session_presence_presentation: Vec<Indicator>,
+    session_presence_presentation: Vec<(Indicator, u32)>,
     /// Live edge posture (WatchConnectivity): drives the connection pill,
     /// composer honesty ("will queue"), and the Queued send badges.
     pub connectivity: zeron_proto::Connectivity,
@@ -882,11 +892,11 @@ fn is_text_append(frame: &TranscriptFrame) -> bool {
         if upsert.is_empty() && remove.is_empty() && !append.is_empty())
 }
 
-/// Each session's indicator at `now` (the lease-dependent part of a frame).
-fn session_presence_at(sessions: &[Session], now: DateTime<Utc>) -> Vec<Indicator> {
+/// Each session's presence at `now` (the lease-dependent part of a frame).
+fn session_presence_at(sessions: &[Session], now: DateTime<Utc>) -> Vec<(Indicator, u32)> {
     sessions
         .iter()
-        .map(|session| effective_indicator(Some(session), now))
+        .map(|session| session_presence(session, now))
         .collect()
 }
 
@@ -2216,6 +2226,13 @@ impl AppState {
         self.sessions.iter().find(|s| s.chat_id == chat_id)
     }
 
+    /// Subagents running under `chat_id` right now (the engine's count on its
+    /// session row; 0 once that row goes stale). Every device can ask, opened
+    /// chat or not.
+    pub fn running_subagents_for(&self, chat_id: &str, now: DateTime<Utc>) -> u32 {
+        running_subagents(self.session_for(chat_id), now)
+    }
+
     /// Staleness-checked status dot for a chat row. A send in flight reads as
     /// Working (see [`Self::display_status_for`]).
     pub fn indicator_for(&self, chat_id: &str, now: DateTime<Utc>) -> Indicator {
@@ -4071,6 +4088,7 @@ mod tests {
     ) -> Session {
         Session {
             last_completed_turn: None,
+            running_subagents: 0,
             chat_id: chat_id.into(),
             device_id: "dev".into(),
             status,
@@ -4315,6 +4333,7 @@ mod tests {
         let now = Utc::now();
         let mut row = Session {
             last_completed_turn: None,
+            running_subagents: 0,
             chat_id: "chat".into(),
             device_id: "host".into(),
             status: SessionStatus::Working,
@@ -4346,6 +4365,7 @@ mod tests {
         let now = Utc::now();
         state.sessions = vec![Session {
             last_completed_turn: None,
+            running_subagents: 0,
             chat_id: "chat".into(),
             device_id: "host".into(),
             status: SessionStatus::Working,
diff --git a/crates/ui/src/transcript.rs b/crates/ui/src/transcript.rs
index 15f46a3fd4..ad5fd30166 100644
--- a/crates/ui/src/transcript.rs
+++ b/crates/ui/src/transcript.rs
@@ -13490,6 +13490,7 @@ mod tests {
                     this.state.update(cx, |state, _| {
                         state.sessions.push(zeron_proto::Session {
                             last_completed_turn: None,
+                            running_subagents: 0,
                             chat_id: "chat".into(),
                             device_id: "test".into(),
                             status: zeron_proto::SessionStatus::Working,

From 09d07f0a8cc5be46441be6949d69788980289da9 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 11:23:20 -0700
Subject: [PATCH 68/74] Explorer button: pulse and count badge for running
 subagents

The pill hung under the button and crossed the titlebar hairline. Mark the
button itself instead: its face breathes in the activity tone and a small
count badge sits on its corner, both drawn over the button so titlebar
layout is unchanged.
---
 crates/ui/src/loaders.rs      | 77 +++++++++++++++++++++++++++++++++++
 crates/ui/src/running_pill.rs | 43 ++++++++++++++++++-
 crates/ui/src/shell/tabs.rs   | 22 +++-------
 3 files changed, 125 insertions(+), 17 deletions(-)

diff --git a/crates/ui/src/loaders.rs b/crates/ui/src/loaders.rs
index bebe3795d8..e5c36db408 100644
--- a/crates/ui/src/loaders.rs
+++ b/crates/ui/src/loaders.rs
@@ -341,6 +341,83 @@ impl Render for PulseDotView {
     }
 }
 
+/// A rounded fill that breathes on the zeron pulse clock between `floor` and
+/// `peak` opacity, filling whatever positioned box it is placed in. Like [`pulse_dot`] it repaints from its own cached
+/// view, so the surrounding chrome stays still.
+pub fn pulse_glow(
+    key: impl Into<SharedString>,
+    radius: f32,
+    tint: gpui::Hsla,
+    floor: f32,
+    peak: f32,
+) -> impl IntoElement {
+    PulseGlow {
+        key: key.into(),
+        style: GlowStyle {
+            radius,
+            tint,
+            floor,
+            peak,
+        },
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+struct GlowStyle {
+    radius: f32,
+    tint: gpui::Hsla,
+    floor: f32,
+    peak: f32,
+}
+
+#[derive(IntoElement)]
+struct PulseGlow {
+    key: SharedString,
+    style: GlowStyle,
+}
+
+impl RenderOnce for PulseGlow {
+    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let style = self.style;
+        let view = window.with_global_id(self.key.into(), |id, window| {
+            window.with_element_state(id, |previous: Option<Entity<PulseGlowView>>, _| {
+                let view = previous.unwrap_or_else(|| cx.new(|_| PulseGlowView { style }));
+                view.update(cx, |view, cx| {
+                    if view.style != style {
+                        view.style = style;
+                        cx.notify();
+                    }
+                });
+                (view.clone(), view)
+            })
+        });
+        view.cached(gpui::StyleRefinement::default().size_full())
+    }
+}
+
+struct PulseGlowView {
+    style: GlowStyle,
+}
+
+impl Render for PulseGlowView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let GlowStyle {
+            radius,
+            tint,
+            floor,
+            peak,
+        } = self.style;
+        let delta = motion::pulse_delta_slow(&ZERON_PULSE, cx.entity_id(), cx);
+        // pulse_opacity spans 0.08..1; renormalise to 0..1 before mapping.
+        let wave = (motion::pulse_opacity(delta) - 0.08) / 0.92;
+        div()
+            .size_full()
+            .rounded(px(radius))
+            .bg(tint)
+            .opacity(motion::lerp(floor, peak, wave))
+    }
+}
+
 /// Stroke width of [`upload_progress_ring`].
 const RING_STROKE: f32 = 2.5;
 /// Polyline segments for a full circle — plenty for a ≤40px ring.
diff --git a/crates/ui/src/running_pill.rs b/crates/ui/src/running_pill.rs
index 8d39f6f31e..9de5b1f5ca 100644
--- a/crates/ui/src/running_pill.rs
+++ b/crates/ui/src/running_pill.rs
@@ -3,7 +3,7 @@
 //! explorer button, and the explorer's Subagents header, so the number reads
 //! the same wherever it turns up.
 
-use gpui::{AnyElement, SharedString, div, prelude::*, px};
+use gpui::{AnyElement, SharedString, Styled as _, div, prelude::*, px};
 
 use crate::loaders;
 use crate::theme::Theme;
@@ -12,6 +12,8 @@ use crate::theme::Theme;
 /// matches the sidebar's pull-request badge so the two never disagree.
 const HEIGHT: f32 = 16.0;
 const DOT: f32 = 5.0;
+/// Corner radius of the titlebar's icon buttons.
+const BUTTON_RADIUS: f32 = 6.0;
 /// Past this the count would outgrow the pill; it reads "99+".
 const COUNT_CAP: u32 = 99;
 
@@ -62,3 +64,42 @@ mod tests {
         assert_eq!(count_label(100).as_ref(), "99+");
     }
 }
+
+/// Marks the titlebar's explorer button while subagents run, so they can be
+/// found with the panel closed: the button's face breathes in the activity
+/// tone, and a small count badge sits on its corner. Both are drawn over the
+/// button, so it keeps its size and position among the titlebar controls.
+pub fn mark_files_button(
+    button: gpui::Stateful<gpui::Div>,
+    count: u32,
+    theme: &Theme,
+) -> gpui::Stateful<gpui::Div> {
+    let tone = theme.busy;
+    button
+        .relative()
+        .child(div().absolute().inset_0().child(loaders::pulse_glow(
+            "files-button-glow",
+            BUTTON_RADIUS,
+            tone,
+            0.10,
+            0.30,
+        )))
+        .child(
+            div()
+                .absolute()
+                .top(px(-3.0))
+                .right(px(-3.0))
+                .min_w(px(13.0))
+                .h(px(13.0))
+                .px(px(3.0))
+                .flex()
+                .items_center()
+                .justify_center()
+                .rounded_full()
+                .bg(tone)
+                .text_size(crate::typography::ui_rems(9.0))
+                .font_weight(gpui::FontWeight::SEMIBOLD)
+                .text_color(gpui::white())
+                .child(count_label(count)),
+        )
+}
diff --git a/crates/ui/src/shell/tabs.rs b/crates/ui/src/shell/tabs.rs
index 8d3211500b..22b07f4929 100644
--- a/crates/ui/src/shell/tabs.rs
+++ b/crates/ui/src/shell/tabs.rs
@@ -513,23 +513,13 @@ impl Shell {
                                 .when(self.files_panel_open(cx), |button| {
                                     button.bg(crate::theme::wash(0.09))
                                 })
-                                // Running subagents live in this panel: badge
-                                // the button so they are findable while it is
-                                // closed.
+                                // Running subagents live in this panel: mark the
+                                // button so they are findable while it is closed.
                                 .when(running_subagents > 0, |button| {
-                                    button.relative().child(
-                                        div()
-                                            .absolute()
-                                            .left_0()
-                                            .right_0()
-                                            .bottom(px(-8.0))
-                                            .flex()
-                                            .justify_center()
-                                            .child(crate::running_pill::running_pill(
-                                                "toggle-files-panel-subagents",
-                                                running_subagents,
-                                                &theme,
-                                            )),
+                                    crate::running_pill::mark_files_button(
+                                        button,
+                                        running_subagents,
+                                        &theme,
                                     )
                                 }),
                             )

From 9df936c580960bd5b197f0a98a4b26e4b45cad64 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 11:36:36 -0700
Subject: [PATCH 69/74] Sidebar: running-subagents pill takes the time stamp's
 place

The pill no longer replaces the row's own activity indicator, so compact
titles stop shifting. In compact rows it stands where the time stamp is
while subagents run; in regular rows it leads the status label.
---
 crates/ui/src/shell.rs | 52 ++++++++++++++++++++++++------------------
 1 file changed, 30 insertions(+), 22 deletions(-)

diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index c578ee9f00..29977d3b1b 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -7387,9 +7387,10 @@ impl Shell {
         let shows_metadata = branch.is_some() || change_request.is_some();
         let queued = queued && !undelivered;
         let working = status == zeron_proto::ChatIndicator::Working && !queued && !undelivered;
-        // Subagents running under this chat trade the working spinner for the
-        // "● N" pill: the count is the more useful thing to know, and it keeps
-        // showing after the parent's own turn has settled.
+        // Subagents running under this chat show as a "● N" pill beside the
+        // row's own activity indicator, never in place of it: the pill takes
+        // the time stamp's spot (compact) or leads the status (regular), and
+        // keeps showing after the parent's own turn has settled.
         let running_subagents = self.state.read(cx).running_subagents_for(&id, Utc::now());
         let subagent_pill = |suffix: &str| {
             (running_subagents > 0).then(|| {
@@ -7401,11 +7402,7 @@ impl Shell {
             })
         };
         let compact_status = compact.then(|| {
-            let pill = subagent_pill("compact");
-            let has_pill = pill.is_some();
-            let glyph = if let Some(pill) = pill {
-                pill
-            } else if working {
+            let glyph = if working {
                 loaders::mini_glyph_spinner(
                     format!("{row_id}-working"),
                     2.0,
@@ -7432,10 +7429,7 @@ impl Shell {
                     let id = id.clone();
                     move || format!("chat-status-{id}")
                 })
-                // The pill is wider than the 13px glyph slot: the slot keeps its
-                // height and lets the width follow.
-                .h(px(13.0))
-                .when(!has_pill, |slot| slot.w(px(13.0)))
+                .size(px(13.0))
                 .flex_none()
                 .flex()
                 .items_center()
@@ -7527,9 +7521,7 @@ impl Shell {
                     // Glyph slot: Working wears the preset's animated pixel
                     // glyph beside its label, Done wears the check, and the
                     // remaining statuses use a compact dot.
-                    let glyph: AnyElement = if let Some(pill) = subagent_pill("label") {
-                        pill
-                    } else if status == zeron_proto::ChatIndicator::Completed {
+                    let glyph: AnyElement = if status == zeron_proto::ChatIndicator::Completed {
                         icon(icons::CHECK)
                             .size(px(11.0))
                             .flex_none()
@@ -7556,14 +7548,22 @@ impl Shell {
                         .flex()
                         .flex_row()
                         .items_center()
-                        .gap(px(4.0))
-                        .child(glyph)
+                        .gap(px(6.0))
+                        .children(subagent_pill("label"))
                         .child(
                             div()
-                                .text_size(crate::typography::ui_rems(10.0))
-                                .font_weight(gpui::FontWeight::MEDIUM)
-                                .text_color(status_color)
-                                .child(SharedString::from(label)),
+                                .flex()
+                                .flex_row()
+                                .items_center()
+                                .gap(px(4.0))
+                                .child(glyph)
+                                .child(
+                                    div()
+                                        .text_size(crate::typography::ui_rems(10.0))
+                                        .font_weight(gpui::FontWeight::MEDIUM)
+                                        .text_color(status_color)
+                                        .child(SharedString::from(label)),
+                                ),
                         )
                         .into_any_element()
                 }
@@ -7907,6 +7907,11 @@ impl Shell {
                         let text_hint = compact_jump_label
                             .as_ref()
                             .is_some_and(|label| label.chars().count() > 3);
+                        // Running subagents take the time stamp's place; the
+                        // legend and the hover archive still win.
+                        let pill = (!show_legend && !show_archive)
+                            .then(|| subagent_pill("compact"))
+                            .flatten();
                         let archive_id = id.clone();
                         el.children(change_request.clone().map(|summary| {
                             if preview {
@@ -7935,7 +7940,8 @@ impl Shell {
                                 .when(text_hint, |el| {
                                     el.min_w(crate::typography::ui_rems(COMPACT_JUMP_HINT_WIDTH))
                                 })
-                                .when(!text_hint, |el| el.w(px(30.0)))
+                                // A running-subagents pill can be wider than the plain time.
+                                .when(!text_hint, |el| el.min_w(px(30.0)))
                                 // Fixed height so swapping the time text for the
                                 // archive glyph never resizes the slot.
                                 .h(px(14.0))
@@ -7980,6 +7986,8 @@ impl Shell {
                                     .flex_none()
                                     .text_color(theme.text_muted)
                                     .into_any_element()
+                                } else if let Some(pill) = pill {
+                                    pill
                                 } else {
                                     div()
                                         .whitespace_nowrap()

From cd0562e3c51b6fb484a9609fc296e9e8acfd1063 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 12:29:45 -0700
Subject: [PATCH 70/74] Running-count pill and badge: centre the digits

The titlebar badge had no explicit line height and used the UI font, so its
digit sat about a pixel high; the sidebar pill's digits sat half a pixel low.
Both now draw their count through one helper: mono digits in a box exactly as
tall as the pill or badge, with a small optical lift (and, for the badge, a
rightward shift) measured from rendered captures at one, two and three
characters.
---
 crates/ui/src/running_pill.rs | 111 +++++++++++++++++++++++++---------
 1 file changed, 81 insertions(+), 30 deletions(-)

diff --git a/crates/ui/src/running_pill.rs b/crates/ui/src/running_pill.rs
index 9de5b1f5ca..bbbc372d2c 100644
--- a/crates/ui/src/running_pill.rs
+++ b/crates/ui/src/running_pill.rs
@@ -1,7 +1,7 @@
-//! The "● 3" pill: how many subagents are running. One shape shared by the
-//! sidebar's chat rows (in place of the working spinner), the titlebar's
-//! explorer button, and the explorer's Subagents header, so the number reads
-//! the same wherever it turns up.
+//! How many subagents are running, drawn the same way wherever it turns up:
+//! the "● 3" pill on the sidebar's chat rows (beside the row's own activity
+//! indicator) and the Subagents header, and the pulsing button with a count
+//! badge on the titlebar's explorer toggle.
 
 use gpui::{AnyElement, SharedString, Styled as _, div, prelude::*, px};
 
@@ -12,6 +12,8 @@ use crate::theme::Theme;
 /// matches the sidebar's pull-request badge so the two never disagree.
 const HEIGHT: f32 = 16.0;
 const DOT: f32 = 5.0;
+/// Height of the count badge on the titlebar button.
+const BADGE: f32 = 13.0;
 /// Corner radius of the titlebar's icon buttons.
 const BUTTON_RADIUS: f32 = 6.0;
 /// Past this the count would outgrow the pill; it reads "99+".
@@ -26,6 +28,38 @@ pub fn count_label(count: u32) -> SharedString {
     }
 }
 
+/// The count's digits in a box exactly `height` tall, so the line box, the
+/// container and the glyphs share one centre. Digits sit a touch off the
+/// centre of a text line (font ascent and descent are not symmetric about the
+/// cap height), so `nudge` lifts the text by that optical remainder, and
+/// `shift` moves it right for the same reason horizontally (a digit's ink is
+/// a little left of the middle of its advance).
+fn count_text(
+    count: u32,
+    size: f32,
+    height: f32,
+    nudge: f32,
+    shift: f32,
+    weight: gpui::FontWeight,
+    color: gpui::Hsla,
+    theme: &Theme,
+) -> gpui::Div {
+    div()
+        .h(px(height))
+        .flex_none()
+        .flex()
+        .items_center()
+        .text_size(crate::typography::ui_rems(size))
+        .line_height(px(height))
+        .font_weight(weight)
+        .font_family(theme.font_mono.clone())
+        .text_color(color)
+        .relative()
+        .top(px(-nudge))
+        .left(px(shift))
+        .child(count_label(count))
+}
+
 /// The pill for `count` running subagents; callers draw nothing at zero.
 /// `key` scopes the dot's animation state — one per placement.
 pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) -> AnyElement {
@@ -41,29 +75,28 @@ pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) ->
         .rounded(px(HEIGHT / 2.0))
         .bg(tone.opacity(0.16))
         .child(loaders::pulse_dot(key, DOT, tone))
-        .child(
-            div()
-                .text_size(crate::typography::ui_rems(10.0))
-                .line_height(px(HEIGHT))
-                .font_weight(gpui::FontWeight::MEDIUM)
-                .font_family(theme.font_mono.clone())
-                .text_color(tone)
-                .child(count_label(count)),
-        )
+        .child(count_text(
+            count,
+            10.0,
+            HEIGHT,
+            PILL_NUDGE,
+            0.0,
+            gpui::FontWeight::MEDIUM,
+            tone,
+            theme,
+        ))
         .into_any_element()
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn count_label_caps_at_ninety_nine() {
-        assert_eq!(count_label(1).as_ref(), "1");
-        assert_eq!(count_label(99).as_ref(), "99");
-        assert_eq!(count_label(100).as_ref(), "99+");
-    }
-}
+/// Optical lift of the digits, in px (see [`count_text`]). Measured on
+/// rendered captures: without it the digits sit about half a device pixel low
+/// in the pill and a full one high in the badge (which had no line height);
+/// 0.25 centres both to within half a device pixel, the most a 13px box and
+/// 6-7px-tall digits allow at fractional display scales.
+const PILL_NUDGE: f32 = 0.25;
+const BADGE_NUDGE: f32 = 0.25;
+/// Rightward optical shift of the badge's digits, in px.
+const BADGE_SHIFT: f32 = 0.4;
 
 /// Marks the titlebar's explorer button while subagents run, so they can be
 /// found with the panel closed: the button's face breathes in the activity
@@ -89,17 +122,35 @@ pub fn mark_files_button(
                 .absolute()
                 .top(px(-3.0))
                 .right(px(-3.0))
-                .min_w(px(13.0))
-                .h(px(13.0))
+                .h(px(BADGE))
+                .min_w(px(BADGE))
                 .px(px(3.0))
                 .flex()
                 .items_center()
                 .justify_center()
                 .rounded_full()
                 .bg(tone)
-                .text_size(crate::typography::ui_rems(9.0))
-                .font_weight(gpui::FontWeight::SEMIBOLD)
-                .text_color(gpui::white())
-                .child(count_label(count)),
+                .child(count_text(
+                    count,
+                    9.0,
+                    BADGE,
+                    BADGE_NUDGE,
+                    BADGE_SHIFT,
+                    gpui::FontWeight::SEMIBOLD,
+                    gpui::white(),
+                    theme,
+                )),
         )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn count_label_caps_at_ninety_nine() {
+        assert_eq!(count_label(1).as_ref(), "1");
+        assert_eq!(count_label(99).as_ref(), "99");
+        assert_eq!(count_label(100).as_ref(), "99+");
+    }
+}

From 956728c72bb860efc2aacf8d912e5def8c009c7a Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 12:35:48 -0700
Subject: [PATCH 71/74] Running count: centre digits by font metrics, drop
 hand-tuned offsets

Geist Mono's digits are centred on the line box and each digit's ink is
centred in its advance (checked from the font tables), so with the line height
equal to the box height nothing needs nudging. The earlier optical offsets
were fitted to two monitor scales and gave the same result there as none; at
a whole-number scale they would only add error. Residual misalignment is
device-pixel rounding of the baseline, at most half a device pixel.
---
 crates/ui/src/running_pill.rs | 31 ++++++-------------------------
 1 file changed, 6 insertions(+), 25 deletions(-)

diff --git a/crates/ui/src/running_pill.rs b/crates/ui/src/running_pill.rs
index bbbc372d2c..bc020e5ed2 100644
--- a/crates/ui/src/running_pill.rs
+++ b/crates/ui/src/running_pill.rs
@@ -28,18 +28,16 @@ pub fn count_label(count: u32) -> SharedString {
     }
 }
 
-/// The count's digits in a box exactly `height` tall, so the line box, the
-/// container and the glyphs share one centre. Digits sit a touch off the
-/// centre of a text line (font ascent and descent are not symmetric about the
-/// cap height), so `nudge` lifts the text by that optical remainder, and
-/// `shift` moves it right for the same reason horizontally (a digit's ink is
-/// a little left of the middle of its advance).
+/// The count's digits in a box exactly `height` tall. With the line height set
+/// to the box height, gpui centres the line's ascent-plus-descent in the box,
+/// and Geist Mono's metrics put the middle of its digits on that centre (about
+/// 0.00px off at these sizes), and each digit's ink is centred in its advance.
+/// So no manual offsets: whatever is left is device-pixel rounding of the
+/// baseline, at most half a device pixel.
 fn count_text(
     count: u32,
     size: f32,
     height: f32,
-    nudge: f32,
-    shift: f32,
     weight: gpui::FontWeight,
     color: gpui::Hsla,
     theme: &Theme,
@@ -54,9 +52,6 @@ fn count_text(
         .font_weight(weight)
         .font_family(theme.font_mono.clone())
         .text_color(color)
-        .relative()
-        .top(px(-nudge))
-        .left(px(shift))
         .child(count_label(count))
 }
 
@@ -79,8 +74,6 @@ pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) ->
             count,
             10.0,
             HEIGHT,
-            PILL_NUDGE,
-            0.0,
             gpui::FontWeight::MEDIUM,
             tone,
             theme,
@@ -88,16 +81,6 @@ pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) ->
         .into_any_element()
 }
 
-/// Optical lift of the digits, in px (see [`count_text`]). Measured on
-/// rendered captures: without it the digits sit about half a device pixel low
-/// in the pill and a full one high in the badge (which had no line height);
-/// 0.25 centres both to within half a device pixel, the most a 13px box and
-/// 6-7px-tall digits allow at fractional display scales.
-const PILL_NUDGE: f32 = 0.25;
-const BADGE_NUDGE: f32 = 0.25;
-/// Rightward optical shift of the badge's digits, in px.
-const BADGE_SHIFT: f32 = 0.4;
-
 /// Marks the titlebar's explorer button while subagents run, so they can be
 /// found with the panel closed: the button's face breathes in the activity
 /// tone, and a small count badge sits on its corner. Both are drawn over the
@@ -134,8 +117,6 @@ pub fn mark_files_button(
                     count,
                     9.0,
                     BADGE,
-                    BADGE_NUDGE,
-                    BADGE_SHIFT,
                     gpui::FontWeight::SEMIBOLD,
                     gpui::white(),
                     theme,

From f8a86888a710d284201ab45506ed0fb5b30af973 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 12:54:27 -0700
Subject: [PATCH 72/74] Running-count pill: hang dot and digits off one
 baseline; balance the 99+ badge

The pill's dot was a box centred in the pill while the digits' vertical
position followed the text engine's own metrics and rounding, so at
fractional display scales the two could differ by a device pixel. The pill
now paints its background, dot and digits in one canvas: the digits' baseline
is snapped to a device pixel and the dot is centred on the digits' middle
from that baseline, so they share a centre at any scale.

A capped label ends in '+', whose thin arms leave the eye a wider gap than a
digit does; trim the padding after it by a pixel in both the pill and the
titlebar badge.
---
 crates/ui/src/loaders.rs      |  71 -----------
 crates/ui/src/running_pill.rs | 214 ++++++++++++++++++++++++++++++----
 2 files changed, 189 insertions(+), 96 deletions(-)

diff --git a/crates/ui/src/loaders.rs b/crates/ui/src/loaders.rs
index e5c36db408..263c5dc77f 100644
--- a/crates/ui/src/loaders.rs
+++ b/crates/ui/src/loaders.rs
@@ -270,77 +270,6 @@ fn mini_spinner_cells(
         }))
 }
 
-/// A dot that breathes on the zeron pulse clock (opacity only, so it never
-/// moves layout). Like the mini spinners it repaints from its own cached
-/// view, so a row of them costs the surrounding list nothing.
-pub fn pulse_dot(
-    key: impl Into<SharedString>,
-    diameter: f32,
-    tint: gpui::Hsla,
-) -> impl IntoElement {
-    PulseDot {
-        key: key.into(),
-        diameter,
-        tint,
-    }
-}
-
-/// Rest opacity of [`pulse_dot`]'s trough: dimmer than full, never gone, so
-/// the dot still reads as a status between beats.
-const PULSE_DOT_FLOOR: f32 = 0.4;
-
-#[derive(IntoElement)]
-struct PulseDot {
-    key: SharedString,
-    diameter: f32,
-    tint: gpui::Hsla,
-}
-
-impl RenderOnce for PulseDot {
-    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let view = window.with_global_id(self.key.into(), |id, window| {
-            window.with_element_state(id, |previous: Option<Entity<PulseDotView>>, _| {
-                let view = previous.unwrap_or_else(|| {
-                    cx.new(|_| PulseDotView {
-                        diameter: self.diameter,
-                        tint: self.tint,
-                    })
-                });
-                view.update(cx, |view, cx| {
-                    if view.diameter != self.diameter || view.tint != self.tint {
-                        view.diameter = self.diameter;
-                        view.tint = self.tint;
-                        cx.notify();
-                    }
-                });
-                (view.clone(), view)
-            })
-        });
-        view.cached(
-            gpui::StyleRefinement::default()
-                .w(px(self.diameter))
-                .h(px(self.diameter)),
-        )
-    }
-}
-
-struct PulseDotView {
-    diameter: f32,
-    tint: gpui::Hsla,
-}
-
-impl Render for PulseDotView {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let delta = motion::pulse_delta_slow(&ZERON_PULSE, cx.entity_id(), cx);
-        let wave = motion::lerp(PULSE_DOT_FLOOR, 1.0, motion::pulse_opacity(delta));
-        div()
-            .size(px(self.diameter))
-            .rounded_full()
-            .bg(self.tint)
-            .opacity(wave)
-    }
-}
-
 /// A rounded fill that breathes on the zeron pulse clock between `floor` and
 /// `peak` opacity, filling whatever positioned box it is placed in. Like [`pulse_dot`] it repaints from its own cached
 /// view, so the surrounding chrome stays still.
diff --git a/crates/ui/src/running_pill.rs b/crates/ui/src/running_pill.rs
index bc020e5ed2..fc353c75ca 100644
--- a/crates/ui/src/running_pill.rs
+++ b/crates/ui/src/running_pill.rs
@@ -3,15 +3,31 @@
 //! indicator) and the Subagents header, and the pulsing button with a count
 //! badge on the titlebar's explorer toggle.
 
-use gpui::{AnyElement, SharedString, Styled as _, div, prelude::*, px};
+use gpui::{
+    AnyElement, App, AppContext as _, Bounds, Context, Entity, Hsla, IntoElement, Render,
+    RenderOnce, SharedString, Styled as _, TextAlign, TextRun, Window, canvas, div, fill, point,
+    prelude::*, px, size,
+};
 
 use crate::loaders;
+use crate::motion::{self, ZERON_PULSE};
 use crate::theme::Theme;
 
 /// Pill height. The sidebar's status slot is 13px and its rows 29px; 16px
 /// matches the sidebar's pull-request badge so the two never disagree.
 const HEIGHT: f32 = 16.0;
 const DOT: f32 = 5.0;
+/// Pill padding either side of the content, and the gap between dot and digits.
+const PAD: f32 = 6.0;
+const GAP: f32 = 4.0;
+/// A capped label ends in "+", whose thin arms leave the eye a wider gap
+/// than the same padding after a digit; the padding after it is trimmed by
+/// this much so the two ends look balanced.
+const PLUS_TRIM: f32 = 1.0;
+/// Where the middle of Geist Mono's digits sits above the baseline, as a
+/// fraction of the font size: (726 + -16) / 2 units of 1000 for the round
+/// digits, 710 / 2 for the flat ones.
+const DIGIT_MID: f32 = 0.355;
 /// Height of the count badge on the titlebar button.
 const BADGE: f32 = 13.0;
 /// Corner radius of the titlebar's icon buttons.
@@ -28,6 +44,10 @@ pub fn count_label(count: u32) -> SharedString {
     }
 }
 
+fn is_capped(count: u32) -> bool {
+    count > COUNT_CAP
+}
+
 /// The count's digits in a box exactly `height` tall. With the line height set
 /// to the box height, gpui centres the line's ascent-plus-descent in the box,
 /// and Geist Mono's metrics put the middle of its digits on that centre (about
@@ -39,7 +59,7 @@ fn count_text(
     size: f32,
     height: f32,
     weight: gpui::FontWeight,
-    color: gpui::Hsla,
+    color: Hsla,
     theme: &Theme,
 ) -> gpui::Div {
     div()
@@ -56,29 +76,167 @@ fn count_text(
 }
 
 /// The pill for `count` running subagents; callers draw nothing at zero.
-/// `key` scopes the dot's animation state — one per placement.
+/// `key` scopes the pulse's animation state — one per placement.
 pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) -> AnyElement {
-    let tone = theme.busy;
-    div()
-        .h(px(HEIGHT))
-        .flex_none()
-        .flex()
-        .flex_row()
-        .items_center()
-        .gap(px(4.0))
-        .px(px(6.0))
-        .rounded(px(HEIGHT / 2.0))
-        .bg(tone.opacity(0.16))
-        .child(loaders::pulse_dot(key, DOT, tone))
-        .child(count_text(
-            count,
-            10.0,
-            HEIGHT,
-            gpui::FontWeight::MEDIUM,
-            tone,
-            theme,
-        ))
-        .into_any_element()
+    RunningPill {
+        key: key.into(),
+        count,
+        tone: theme.busy,
+        family: theme.font_mono.clone(),
+    }
+    .into_any_element()
+}
+
+#[derive(IntoElement)]
+struct RunningPill {
+    key: SharedString,
+    count: u32,
+    tone: Hsla,
+    family: SharedString,
+}
+
+impl RenderOnce for RunningPill {
+    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let spec = PillSpec {
+            count: self.count,
+            tone: self.tone,
+            family: self.family,
+        };
+        // The pill's width follows its label, and a cached view needs that up
+        // front; shaping is cached by the text system.
+        let font_size = pill_font_size(window);
+        let width = spec.shape(window, font_size).width;
+        let total = px(PAD + DOT + GAP + spec.right_pad()) + width;
+        // Own the pulse in a cached view so the surrounding list stays still.
+        let view = window.with_global_id(self.key.into(), |id, window| {
+            window.with_element_state(id, |previous: Option<Entity<PillView>>, _| {
+                let view = previous.unwrap_or_else(|| cx.new(|_| PillView { spec: spec.clone() }));
+                view.update(cx, |view, cx| {
+                    if view.spec != spec {
+                        view.spec = spec.clone();
+                        cx.notify();
+                    }
+                });
+                (view.clone(), view)
+            })
+        });
+        view.cached(
+            gpui::StyleRefinement::default()
+                .w(total)
+                .h(px(HEIGHT))
+                .flex_none(),
+        )
+    }
+}
+
+fn pill_font_size(window: &Window) -> gpui::Pixels {
+    crate::typography::ui_rems(10.0).to_pixels(window.rem_size())
+}
+
+#[derive(Clone, PartialEq)]
+struct PillSpec {
+    count: u32,
+    tone: Hsla,
+    family: SharedString,
+}
+
+impl PillSpec {
+    fn right_pad(&self) -> f32 {
+        if is_capped(self.count) {
+            PAD - PLUS_TRIM
+        } else {
+            PAD
+        }
+    }
+
+    fn shape(&self, window: &Window, font_size: gpui::Pixels) -> gpui::ShapedLine {
+        let label = count_label(self.count);
+        let run = TextRun {
+            len: label.len(),
+            font: gpui::Font {
+                family: self.family.clone(),
+                features: gpui::FontFeatures::default(),
+                fallbacks: None,
+                weight: gpui::FontWeight::MEDIUM,
+                style: gpui::FontStyle::Normal,
+            },
+            color: self.tone,
+            background_color: None,
+            underline: None,
+            strikethrough: None,
+        };
+        window
+            .text_system()
+            .shape_line(label, font_size, &[run], None)
+    }
+}
+
+struct PillView {
+    spec: PillSpec,
+}
+
+impl Render for PillView {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let spec = self.spec.clone();
+        let font_size = pill_font_size(window);
+        let line = spec.shape(window, font_size);
+        let delta = motion::pulse_delta_slow(&ZERON_PULSE, cx.entity_id(), cx);
+        let wave = motion::lerp(0.4, 1.0, (motion::pulse_opacity(delta) - 0.08) / 0.92);
+        canvas(
+            |_, _, _| (),
+            move |bounds: Bounds<gpui::Pixels>, _, window, cx| {
+                paint_pill(bounds, &spec, &line, font_size, wave, window, cx);
+            },
+        )
+        .size_full()
+    }
+}
+
+/// Paint the pill: background, dot, digits. Everything hangs off the digits'
+/// own baseline so the dot and the digits can never drift apart. Text
+/// metrics and glyph rounding differ per font size and display scale, so the
+/// baseline is snapped to a device pixel here (as gpui would on painting),
+/// and the dot is centred on the digits' actual middle from that baseline.
+fn paint_pill(
+    bounds: Bounds<gpui::Pixels>,
+    spec: &PillSpec,
+    line: &gpui::ShapedLine,
+    font_size: gpui::Pixels,
+    wave: f32,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    let scale = window.scale_factor();
+    let snap = |value: f32| (value * scale).round() / scale;
+    let height = bounds.size.height;
+    window.paint_quad(fill(bounds, spec.tone.opacity(0.16)).corner_radii(height / 2.0));
+
+    // Baseline: the digits' middle on the pill's middle, then onto a device
+    // pixel. `line_top` is where gpui expects the line box so its own
+    // centring of ascent+descent lands the baseline there.
+    let digit_mid = f32::from(font_size) * DIGIT_MID;
+    let baseline = snap(f32::from(bounds.origin.y) + f32::from(height) / 2.0 + digit_mid);
+    let baseline_in_box = (f32::from(height) - f32::from(line.ascent) - f32::from(line.descent))
+        / 2.0
+        + f32::from(line.ascent);
+    let text_origin = point(
+        px(snap(f32::from(bounds.origin.x) + PAD + DOT + GAP)),
+        px(baseline - baseline_in_box),
+    );
+
+    // Dot: whole device pixels, centred on the digits.
+    let diameter = snap(DOT).max(1.0 / scale);
+    let centre_y = baseline - digit_mid;
+    let dot = Bounds::new(
+        point(
+            px(snap(f32::from(bounds.origin.x) + PAD)),
+            px(snap(centre_y - diameter / 2.0)),
+        ),
+        size(px(diameter), px(diameter)),
+    );
+    window.paint_quad(fill(dot, spec.tone.opacity(wave)).corner_radii(px(diameter / 2.0)));
+
+    let _ = line.paint(text_origin, height, TextAlign::Left, None, window, cx);
 }
 
 /// Marks the titlebar's explorer button while subagents run, so they can be
@@ -107,7 +265,13 @@ pub fn mark_files_button(
                 .right(px(-3.0))
                 .h(px(BADGE))
                 .min_w(px(BADGE))
-                .px(px(3.0))
+                .pl(px(3.0))
+                // See [`PLUS_TRIM`].
+                .pr(px(if is_capped(count) {
+                    3.0 - PLUS_TRIM
+                } else {
+                    3.0
+                }))
                 .flex()
                 .items_center()
                 .justify_center()

From 087c914d7b3a3561df50409ebff41ce1be6df680 Mon Sep 17 00:00:00 2001
From: Daniel Katulevskiy <katulevskiy@gmail.com>
Date: Tue, 29 Sep 2026 14:44:49 -0700
Subject: [PATCH 73/74] Titlebar count badge: paint it so the digit is centred
 exactly

The badge was a laid-out box, whose text landed on a rounded device pixel and
read as the digit sitting left of centre. Paint the badge and its digits in
one canvas instead: the digits are centred on the badge's real middle, with
the baseline placed as in the sidebar pill. Measured for every digit 1-9 on
1.25x and 1.875x captures: centred to within half a device pixel, exactly for
most.
---
 crates/ui/src/running_pill.rs | 190 ++++++++++++++++++++++------------
 1 file changed, 124 insertions(+), 66 deletions(-)

diff --git a/crates/ui/src/running_pill.rs b/crates/ui/src/running_pill.rs
index fc353c75ca..46e7fa670d 100644
--- a/crates/ui/src/running_pill.rs
+++ b/crates/ui/src/running_pill.rs
@@ -48,33 +48,6 @@ fn is_capped(count: u32) -> bool {
     count > COUNT_CAP
 }
 
-/// The count's digits in a box exactly `height` tall. With the line height set
-/// to the box height, gpui centres the line's ascent-plus-descent in the box,
-/// and Geist Mono's metrics put the middle of its digits on that centre (about
-/// 0.00px off at these sizes), and each digit's ink is centred in its advance.
-/// So no manual offsets: whatever is left is device-pixel rounding of the
-/// baseline, at most half a device pixel.
-fn count_text(
-    count: u32,
-    size: f32,
-    height: f32,
-    weight: gpui::FontWeight,
-    color: Hsla,
-    theme: &Theme,
-) -> gpui::Div {
-    div()
-        .h(px(height))
-        .flex_none()
-        .flex()
-        .items_center()
-        .text_size(crate::typography::ui_rems(size))
-        .line_height(px(height))
-        .font_weight(weight)
-        .font_family(theme.font_mono.clone())
-        .text_color(color)
-        .child(count_label(count))
-}
-
 /// The pill for `count` running subagents; callers draw nothing at zero.
 /// `key` scopes the pulse's animation state — one per placement.
 pub fn running_pill(key: impl Into<SharedString>, count: u32, theme: &Theme) -> AnyElement {
@@ -150,27 +123,45 @@ impl PillSpec {
     }
 
     fn shape(&self, window: &Window, font_size: gpui::Pixels) -> gpui::ShapedLine {
-        let label = count_label(self.count);
-        let run = TextRun {
-            len: label.len(),
-            font: gpui::Font {
-                family: self.family.clone(),
-                features: gpui::FontFeatures::default(),
-                fallbacks: None,
-                weight: gpui::FontWeight::MEDIUM,
-                style: gpui::FontStyle::Normal,
-            },
-            color: self.tone,
-            background_color: None,
-            underline: None,
-            strikethrough: None,
-        };
-        window
-            .text_system()
-            .shape_line(label, font_size, &[run], None)
+        shape_count(
+            window,
+            self.count,
+            &self.family,
+            gpui::FontWeight::MEDIUM,
+            self.tone,
+            font_size,
+        )
     }
 }
 
+fn shape_count(
+    window: &Window,
+    count: u32,
+    family: &SharedString,
+    weight: gpui::FontWeight,
+    color: Hsla,
+    font_size: gpui::Pixels,
+) -> gpui::ShapedLine {
+    let label = count_label(count);
+    let run = TextRun {
+        len: label.len(),
+        font: gpui::Font {
+            family: family.clone(),
+            features: gpui::FontFeatures::default(),
+            fallbacks: None,
+            weight,
+            style: gpui::FontStyle::Normal,
+        },
+        color,
+        background_color: None,
+        underline: None,
+        strikethrough: None,
+    };
+    window
+        .text_system()
+        .shape_line(label, font_size, &[run], None)
+}
+
 struct PillView {
     spec: PillSpec,
 }
@@ -197,6 +188,25 @@ impl Render for PillView {
 /// metrics and glyph rounding differ per font size and display scale, so the
 /// baseline is snapped to a device pixel here (as gpui would on painting),
 /// and the dot is centred on the digits' actual middle from that baseline.
+/// Where to put a line of digits so their middle sits on the middle of
+/// `bounds`: the digits' baseline, snapped to a device pixel (as gpui would on
+/// painting), and the top of the line box that lands gpui's own centring of
+/// ascent-plus-descent on that baseline. Returns `(line_top, baseline)`.
+fn digits_baseline(
+    bounds: Bounds<gpui::Pixels>,
+    font_size: gpui::Pixels,
+    line: &gpui::ShapedLine,
+    scale: f32,
+) -> (f32, f32) {
+    let height = f32::from(bounds.size.height);
+    let digit_mid = f32::from(font_size) * DIGIT_MID;
+    let baseline =
+        ((f32::from(bounds.origin.y) + height / 2.0 + digit_mid) * scale).round() / scale;
+    let baseline_in_box =
+        (height - f32::from(line.ascent) - f32::from(line.descent)) / 2.0 + f32::from(line.ascent);
+    (baseline - baseline_in_box, baseline)
+}
+
 fn paint_pill(
     bounds: Bounds<gpui::Pixels>,
     spec: &PillSpec,
@@ -263,29 +273,77 @@ pub fn mark_files_button(
                 .absolute()
                 .top(px(-3.0))
                 .right(px(-3.0))
-                .h(px(BADGE))
-                .min_w(px(BADGE))
-                .pl(px(3.0))
-                // See [`PLUS_TRIM`].
-                .pr(px(if is_capped(count) {
-                    3.0 - PLUS_TRIM
-                } else {
-                    3.0
-                }))
-                .flex()
-                .items_center()
-                .justify_center()
-                .rounded_full()
-                .bg(tone)
-                .child(count_text(
+                .child(CountBadge {
                     count,
-                    9.0,
-                    BADGE,
-                    gpui::FontWeight::SEMIBOLD,
-                    gpui::white(),
-                    theme,
-                )),
+                    tone,
+                    family: theme.font_mono.clone(),
+                }),
+        )
+}
+
+/// The count badge on the titlebar button, painted rather than laid out so
+/// the digits can be centred exactly: a laid-out text box lands on a rounded
+/// device pixel, which read as the digit sitting left of centre.
+#[derive(IntoElement)]
+struct CountBadge {
+    count: u32,
+    tone: Hsla,
+    family: SharedString,
+}
+
+/// Padding either side of the badge's digits.
+const BADGE_PAD: f32 = 3.0;
+
+impl RenderOnce for CountBadge {
+    fn render(self, window: &mut Window, _cx: &mut App) -> impl IntoElement {
+        let font_size = crate::typography::ui_rems(9.0).to_pixels(window.rem_size());
+        let line = shape_count(
+            window,
+            self.count,
+            &self.family,
+            gpui::FontWeight::SEMIBOLD,
+            gpui::white(),
+            font_size,
+        );
+        let capped = is_capped(self.count);
+        let text_width = f32::from(line.width);
+        // Capped labels trim the padding after the "+" (see [`PLUS_TRIM`]).
+        let right_pad = if capped {
+            BADGE_PAD - PLUS_TRIM
+        } else {
+            BADGE_PAD
+        };
+        let width = (BADGE_PAD + text_width + right_pad).max(BADGE);
+        let tone = self.tone;
+        canvas(
+            |_, _, _| (),
+            move |bounds: Bounds<gpui::Pixels>, _, window, cx| {
+                let scale = window.scale_factor();
+                let snap = |value: f32| (value * scale).round() / scale;
+                window.paint_quad(fill(bounds, tone).corner_radii(bounds.size.height / 2.0));
+                let (line_top, _) = digits_baseline(bounds, font_size, &line, scale);
+                // Single digits sit centred in the badge; a capped label sits
+                // at the padding, its trimmed side toward the "+".
+                let left = f32::from(bounds.origin.x);
+                let x = if capped {
+                    left + BADGE_PAD
+                } else {
+                    left + (f32::from(bounds.size.width) - text_width) / 2.0
+                };
+                let origin = point(px(snap(x)), px(line_top));
+                let _ = line.paint(
+                    origin,
+                    bounds.size.height,
+                    TextAlign::Left,
+                    None,
+                    window,
+                    cx,
+                );
+            },
         )
+        .w(px(width))
+        .h(px(BADGE))
+    }
 }
 
 #[cfg(test)]

From c7dfc37f8d15db71429e0b50b73aba91bb601f8f Mon Sep 17 00:00:00 2001
From: wing-anara <wing@anara.com>
Date: Thu, 8 Oct 2026 10:56:20 -0700
Subject: [PATCH 74/74] Add running_subagents to Session fixtures added on main

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/workspace_host.rs | 1 +
 crates/ui/src/composer.rs           | 1 +
 crates/ui/src/shell.rs              | 1 +
 3 files changed, 3 insertions(+)

diff --git a/crates/engine/src/workspace_host.rs b/crates/engine/src/workspace_host.rs
index 2051a1cea4..f0a9b776b2 100644
--- a/crates/engine/src/workspace_host.rs
+++ b/crates/engine/src/workspace_host.rs
@@ -1904,6 +1904,7 @@ mod tests {
             last_completed_turn: None,
             started_at: None,
             updated_at: at,
+            running_subagents: 0,
         }
     }
 
diff --git a/crates/ui/src/composer.rs b/crates/ui/src/composer.rs
index e72a6cf4e5..6241db2541 100644
--- a/crates/ui/src/composer.rs
+++ b/crates/ui/src/composer.rs
@@ -12585,6 +12585,7 @@ mod tests {
                 status: zeron_proto::SessionStatus::Working,
                 started_at: Some(updated),
                 updated_at: updated,
+                running_subagents: 0,
             }];
             state.selected_chat = Some("c".into());
             state.watch_clock_transitions(cx);
diff --git a/crates/ui/src/shell.rs b/crates/ui/src/shell.rs
index 29977d3b1b..82ef0503a5 100644
--- a/crates/ui/src/shell.rs
+++ b/crates/ui/src/shell.rs
@@ -13733,6 +13733,7 @@ mod tests {
             status,
             started_at: Some(updated_at),
             updated_at,
+            running_subagents: 0,
         }
     }