test(terminal): reproduce missing mouse reports on initial attach

A raw-input terminal enables SGR mouse reporting before the web client attaches. A trusted finger drag should reach its stdin, as it does when the same mode is enabled after attachment, but no report arrives. This diagnostic intentionally remains red; it changes no production behavior.

CLAUDE.md

@@ -55,6 +55,7 @@ At the start of non-trivial work, list `docs/` and skim anything relevant to the
 | [docs/terminal-performance.md](docs/terminal-performance.md)         | Terminal latency pipeline, coalescing/backpressure invariants, benchmark + perf spec usage                                     |
 | [docs/terminal-rendering.md](docs/terminal-rendering.md)             | Native terminal view: xterm owns the grid, cluster placement, emoji widths, mixed-direction limits, render regression          |
 | [docs/agent-stream-performance.md](docs/agent-stream-performance.md) | Assistant text pipeline — coalescing window, paced reveal, why arrival lumps are smoothed at render                            |
+| [docs/agent-stream-disclosure.md](docs/agent-stream-disclosure.md)   | Expand/collapse in the chat timeline — hold contract, native anchor sequence, frame spacing, render-window cost                |
 | [docs/markdown-renderer.md](docs/markdown-renderer.md)               | Shared Markdown engine, native selection, links, images and library constraints                                                |
 | [docs/native-text-selection.md](docs/native-text-selection.md)       | Native diagram grouping, selection boundaries and leading inline image limitations                                             |
 | [docs/file-observation.md](docs/file-observation.md)                 | Recursive watcher ownership, Linux constraints, teardown invariants, and Parcel comparison                                     |

docs/agent-stream-disclosure.md

@@ -0,0 +1,163 @@
+# Agent stream disclosures
+
+Expanding or collapsing something in the chat timeline (a turn's summary line, a tool-call group,
+a tool call's inline details, a todo card) keeps the tapped trigger at the same screen y in the
+first painted frame. No animation.
+
+## The contract
+
+A disclosure component knows nothing about the list. It wraps its state change:
+
+```tsx
+const hold = useDisclosureHold();
+const handleToggle = () => hold(() => setExpanded((value) => !value));
+```
+
+`view.tsx` wraps every timeline row in `DisclosureRow`, which routes `hold` to the strategy's
+`holdRow(rowId, apply)` (`packages/app/src/agent-stream/disclosure.tsx`). Outside a timeline row,
+`apply` runs as is. The strategy owns when `apply` runs and how the row keeps its place.
+
+Following output:
+
+- A hold always detaches the bottom anchor controller (`holdForDisclosure`).
+- When the hold ends, the controller re-sticks only if the list sits at its end and no user scroll
+  owns the viewport (`releaseDisclosure({ isAtEnd })`). Expanding at the bottom therefore leaves
+  the list detached with the scroll-to-bottom pill showing; collapsing back to the end resumes
+  following.
+- Scroll events during the hold never re-stick: the correction is a programmatic scroll that
+  would otherwise read as "back at the bottom".
+
+The trigger can only stay put when the list has scroll room for the change. When the loaded
+content fits the viewport, or a collapse at the end would need an offset past the end, the list
+ends at its end and the trigger moves by the difference.
+
+## Web
+
+`holdRow` pins the row in the reading anchor and runs `apply`; the next reading reconcile restores
+the row's top after layout, before paint (`strategy-web.tsx`).
+
+## Native
+
+On compact layouts, tool calls and tool-call groups open a sheet instead of expanding, so they do
+not hold. Summary lines and todo cards expand inline.
+
+The timeline is a LegendList in forward order: one `data` array of history rows followed by the
+live head, oldest first (`strategy-native.tsx`). LegendList keeps a row in place across a size
+change in the commit that makes it, so a hold needs no anchor neighbour, native child index or
+render window stretch. The inverted FlatList it replaced needed all three, and three commits per
+toggle; its applied commit took up to 3.5 s of JS on a long turn.
+
+### Who owns the offset
+
+One owner keeps the scroll offset at any moment:
+
+| State                  | Owner                                                                                     |
+| ---------------------- | ----------------------------------------------------------------------------------------- |
+| Before rows are placed | LegendList's initial scroll to the end. It keeps the rows hidden until they are measured. |
+| Following the end      | The end pin (`native-end-pin.tsx`).                                                       |
+| Disclosure hold        | LegendList's `maintainVisibleContentPosition`, restoring only the held row.               |
+| User scroll            | The finger. The controller detaches at drag start.                                        |
+| Detached               | LegendList's `maintainVisibleContentPosition` on the first visible row.                   |
+| Keyboard motion        | Nobody. The keyboard translates the list with the composer and leaves the offset alone.   |
+
+The end pin is a zero-height view at the bottom of the content and the content's first native
+child, with React Native's `maintainVisibleContentPosition` set to `{ minIndexForVisible: 0 }`. The
+native correction runs on the UI thread around each mount, so a row that grows or lands at the end
+scrolls in the frame it lays out. The controller scrolls only for a viewport resize (the composer
+growing or shrinking) and an explicit jump, both through the native `scrollToEnd`.
+
+Do not use LegendList's `maintainScrollAtEnd` instead. It scrolls from JS after the mount to the end
+its JS sizes predict: growth paints below the viewport for a frame, and the scroll lands short of
+the native end, which the controller reads as the user scrolling away.
+
+The keyboard never changes the list's size, padding or offset. `KeyboardTranslateView` moves the list
+and the composer together on the UI thread, and the composer viewport clips the top of the list
+while the keyboard is open. Do not add a keyboard-sized inset to keep that content reachable: it can
+only commit after the motion, and while detached or holding nothing corrects for it, so every row
+jumps by the keyboard height after the keyboard settles.
+
+### The hold
+
+`holdRow(rowId, apply)` runs in the toggle's event:
+
+1. Mark the row held and detach the controller (`holdForDisclosure`). The pin goes away and
+   LegendList's `maintainVisibleContentPosition` takes over, restoring only the held row
+   (`shouldRestorePosition`). Upstream LegendList anchors only rows from the first fully visible
+   one down, and a size change with no data change keeps the first row in view whatever
+   `shouldRestorePosition` says. A row cut off at the top would then let the row below it hold
+   instead, moving the trigger by the row's size change. The LegendList patch counts rows cut off
+   at the top as in view and applies `shouldRestorePosition` to size changes too.
+2. Run `apply`.
+3. Call the row's `useSyncLayout` trigger. The toggle changes the row from its own state, so
+   LegendList's container does not re-render and would learn the new height from `onLayout` a task
+   later, after the change painted. The trigger puts the measurement and the corrected positions
+   in the toggle's own commit.
+
+The hold ends two frames after the last item size change, since the list measures the toggled row
+and any rows it inserted over several frames (`native-disclosure-hold.ts`). The controller then
+re-sticks only if the list is within 1 px of its end, the same distance web resumes from.
+
+### User scroll
+
+The controller detaches at `onScrollBeginDrag`, so lines that stream in during a drag grow below
+the rows under the finger. The detach reaches native a JS round trip after the drag begins, so for
+those frames the pin is still mounted. The scroll view subclasses skip the pin's correction while
+the user drags (see [scroll view corrections](#scroll-view-corrections)). They skip only the pin's:
+in the detached state LegendList uses the same native correction, and a history page that lands
+mid-drag needs it. They key on the drag, not the touch, so a tap or long press while following
+keeps following.
+
+Following resumes only for a gesture that ends within 1 px of the end, either when the finger lifts
+or when momentum stops. A release past the end counts: iOS bounces back to the end, and lines that
+land during the bounce must keep scrolling in. A release anywhere short of the end stays detached
+with the scroll-to-bottom pill, so the rows the user let go of never move.
+
+### Draw distance
+
+`drawDistance` is 2000 px on each side of the viewport. A fling over rows that were never measured
+blanks the viewport until LegendList renders and measures them. Twelve flings over a chat with a
+15,000 px turn expanded, Android emulator, dev build:
+
+| List                          | Blank viewport             | Janky frames | p50 / p90 / p99  |
+| ----------------------------- | -------------------------- | ------------ | ---------------- |
+| Inverted FlatList             | 1.3 to 1.7 s over 5 flings | 10.8%        | 27 / 48 / 109 ms |
+| LegendList, drawDistance 500  | 1.0 to 1.5 s per fling     |              |                  |
+| LegendList, drawDistance 2000 | none                       | 1.7%         | 24 / 32 / 48 ms  |
+
+With every turn collapsed, flinging from a cold open into history did not blank at any value from
+500 to 2000, and jank followed host load (19 to 40 on 16 cores) rather than draw distance. Measure
+1000 and 1500 on the expanded chat, on a host under load 10, before lowering it.
+
+### LegendList patch
+
+`patches/@legendapp+list+3.7.1.patch` carries ten changes for the timeline. Its header lists
+them by purpose, and
+[legend-list #593](https://github.com/LegendApp/legend-list/issues/593) reports each upstream.
+Drop a hunk when the installed LegendList ships its fix.
+
+### Scroll view corrections
+
+`modules/paseo-scroll` replaces React Native's scroll view on both platforms with a subclass:
+Android's `PaseoScrollView` and iOS's `PaseoScrollViewComponentView`.
+`VisibleContentPositionClampTest` covers Android; iOS has no native test harness.
+
+**Content clamp.** A mount that shrinks the content while `maintainVisibleContentPosition` is set
+applies the shrink twice on both platforms: the scroll view clamps its offset to the new end during
+the mount, and React Native then adds the anchor's movement to the clamped offset
+([RN #58578](https://github.com/react/react-native/issues/58578), fix in
+[PR #58695](https://github.com/react/react-native/pull/58695)). A turn that folds while the list
+follows its end lands above the end. Android defers the clamp to the pre-draw pass, and iOS restores
+the pre-mount offset for the adjustment and clamps after it.
+
+**Removed anchor (iOS).** A hold removes the end pin in the same mount that opens the tapped
+disclosure, and React Native 0.86 on iOS moves the offset by the removed view's frame. The iOS
+subclass keeps the offset. Android keeps a removed view's last frame, so it keeps the offset already.
+React Native 0.88 skips the adjustment for a removed anchor
+([PR #57294](https://github.com/react/react-native/pull/57294)).
+
+**End pin during a drag.** Both subclasses recognize the pin by its native ID, `paseo-end-pin`,
+and skip its correction while the user drags ([user scroll](#user-scroll)). This one has no React
+Native counterpart; it stays while the timeline uses the pin.
+
+Remove the content clamp and removed-anchor overrides once the installed React Native includes
+their fixes.

docs/agent-stream-performance.md

@@ -34,10 +34,10 @@ So arrival sets a _target_ and the reveal rate is derived from the backlog inste
 - **First sight of a text is revealed whole.** Only growth is paced. This is what makes history hydration, timeline replay, a virtualized row remounting on scroll, and an already-finished message all render complete on first paint without a special case for each.
 - **Leaving `phase: "streaming"` snaps the reveal.** A completed turn must never be left holding characters. `layoutStream` sets the phase, so anything outside the live head with an active turn is already complete.
 - **The reducer queue commits on a frame, with a timer as the ceiling.** A frame callback never fires in a hidden tab, so a timer races it and wins when nothing is painting — the store has to keep advancing either way.
-- **A history row re-renders only when its item or layout item identity changes.** The inverted
-  FlatList hands every mounted cell a new `index` and `ref` whenever a row is prepended, so without a
-  memo boundary each coalesced tick re-rendered every mounted row (about 50 on a phone, 100–250 ms of
-  JS per tick). `layoutStream` keeps a layout item's identity when nothing about it changed,
+- **A history row re-renders only when its item or layout item identity changes.** Every
+  coalesced tick hands the list a new layout. Without a memo boundary each tick re-rendered every
+  mounted row (measured on the inverted FlatList native used before LegendList: about 50 rows on a
+  phone, 100–250 ms of JS per tick). `layoutStream` keeps a layout item's identity when nothing about it changed,
   `useRevisedHistoryRows` hands a fresh item identity to rows whose tool-call group, expanded state,
   or breakpoint changed, and `StreamRow` memoizes on both. Every viewport runs its history
   through that hook; the web viewport once skipped it and history hosts of a live tool group went

docs/android.md

@@ -174,18 +174,18 @@ REACT_NATIVE_PACKAGER_HOSTNAME=localhost \
 
 This is the Android counterpart of the iOS local-simulator flow in [development.md](development.md): on iOS the simulator shares the Mac's loopback so `localhost:<port>` works directly; on Android you need `10.0.2.2` or `adb reverse`.
 
-## Inverted timeline input
+## Scroll view corrections
 
-Android focus and selection visibility requests must not reposition inverted timelines. The
-`modules/paseo-scroll` package keeps React Native's scroll manager interface and returns zero for
-child-reveal scroll calculations when the view's transform matrix inverts the vertical axis. React
-Native's Android list uses `scale: -1`, which decomposes into a 180-degree rotation with positive
-`scaleY`; checking the scale property alone misses it. Dragging and explicit scroll
-commands still work; non-inverted scroll views keep Android's default behavior.
+`modules/paseo-scroll` replaces React Native's vertical scroll view with `PaseoScrollView`, which
+keeps React Native's scroll manager interface and corrects `maintainVisibleContentPosition` for the
+chat timeline. [agent-stream-disclosure.md](agent-stream-disclosure.md#scroll-view-corrections)
+lists the corrections and the React Native issues they work around. Its instrumentation test,
+`VisibleContentPositionClampTest`, mounts through React Native's own mounting manager:
 
-Mouse wheel axes also bypass the inversion transform. The same module reverses the vertical
-wheel axis for inverted scroll views before delegating to Android, preserving native scroll
-bounds and React Native's scroll events and disabled-scroll behavior.
+```bash
+cd packages/app/android
+./gradlew :paseo-scroll:connectedDebugAndroidTest --no-daemon --max-workers=2 -Dorg.gradle.parallel=false
+```
 
 Register this package before React Native's core package through its Expo config plugin. Normal
 Android builds use the prebuilt `react-android` library, so patching Java under `node_modules` does

docs/data-model.md

@@ -92,7 +92,6 @@ Each agent is stored as a separate JSON file, grouped by project directory.
 | `lastUserMessageAt`  | `string?` (ISO 8601)                     | Last user message timestamp                                                                                                                                                                                                                                                                                                                                                         |
 | `title`              | `string?`                                | User-visible title                                                                                                                                                                                                                                                                                                                                                                  |
 | `labels`             | `Record<string, string>`                 | Key-value labels (default `{}`). Paseo uses `paseo.parent-agent-id` for parentage and client-scoped `paseo.open-agent-tab.*` labels while managed subagent tabs are open — see [agent-lifecycle.md](./agent-lifecycle.md)                                                                                                                                                           |
-| `metadata`           | `Record<string, JsonValue>`              | Plugin-owned data (default `{}`). Paseo stores and forwards it and never reads a key. Set at creation or through `agent.metadata.update.request`; `null` in a patch removes a key                                                                                                                                                                                                   |
 | `lastStatus`         | `AgentStatus`                            | One of: `"initializing"`, `"idle"`, `"running"`, `"error"`, `"closed"`. `closed` means the record is resumable but has no live provider runtime; archive remains represented separately by `archivedAt`.                                                                                                                                                                            |
 | `lastModeId`         | `string?`                                | Last active mode ID                                                                                                                                                                                                                                                                                                                                                                 |
 | `config`             | `SerializableConfig?`                    | Agent session configuration (see below)                                                                                                                                                                                                                                                                                                                                             |
@@ -479,7 +478,6 @@ Array of workspace records. A workspace is a specific working directory within a
 | `archivedAt`                   | `string \| null` (ISO 8601)                                  | Soft-delete; required nullable                                                                                                                                                                |
 | `autoArchivedChangeRequestUrl` | `string \| null`                                             | Change request whose merged state triggered auto-archive. Restore replaces it with the current merged change request, when present, so repeated snapshots cannot archive the workspace again. |
 | `labels`                       | `string[]?`                                                  | Normalized display names assigned from this host's shared label catalog. Missing means unlabelled.                                                                                            |
-| `metadata`                     | `Record<string, JsonValue>`                                  | Plugin-owned data (default `{}`). Paseo stores and forwards it and never reads a key. Set at creation or through `workspace.metadata.update.request`.                                         |
 | `pinnedAt`                     | `string \| null` (ISO 8601)                                  | Pinned-to-top-of-sidebar timestamp; null means "not pinned"                                                                                                                                   |
 | `untrustedSource`              | `{ kind: "change_request", forge, number, headRepository }?` | Provenance captured when a cross-repository change request creates the workspace. Missing means repository automation is allowed; explicit setup removes the field.                           |
 

docs/design.md

@@ -68,9 +68,11 @@ the sidebar. Apply it as `backgroundColor`; setting `opacity` on the control als
 
 `destructive` is filled with `destructive`. It only appears inside a confirm. The button on the page is `outline`; the destructive button is the confirm button inside the dialog.
 
-Controls come in two sizes, defined once in `control-geometry.ts`. The default is the right size almost everywhere — pages, dialogs, forms, settings rows, the setup flow — so don't pass a size. It is 32px tall where a pointer drives it and 44px in the compact layout, so every phone control is a full touch target; the breakpoint, not the caller, makes that choice. `sm` is 28px with `fontSize.sm` labels and is for tight chrome only: toolbars, nested settings rows, dense inline row actions. A `size="sm"` on an ordinary page or dialog is wrong, and so is choosing a size from `useIsCompactFormFactor()`.
+Controls come in two sizes, defined once in `control-geometry.ts`. The default is the right size almost everywhere — pages, dialogs, forms, settings rows, the setup flow — so don't pass a size. It is 32px tall where a pointer drives it and 44px where controls are touch-sized, so every touch control meets the iOS HIG's 44pt hit region. `sm` is 28px pointer and 32px touch, with `fontSize.sm` labels, and is for tight chrome only: toolbars, nested settings rows, dense inline row actions. A `size="sm"` on an ordinary page or dialog is wrong, and so is choosing a size from `useIsCompactFormFactor()`.
 
-Buttons are pills (`borderRadius.full`) with medium-weight labels; an icon-only button is a circle. `<Switch>` follows the same two sizes: a 34×20 track by default and in `sm`, 44×26 in the compact layout, and it reserves its size's control height so a row holding one lines up with a row holding a button. Buttons, text fields, dropdown triggers, and `<SegmentedControl>` (`packages/app/src/components/ui/segmented-control.tsx`) share the size contract — the same size name means the same height and label size on every control kind, so controls in one row line up. Segments run tighter than a button, because the gap between segments already reads as padding. The selected segment is a `surface3` fill with `foreground` text, not an inverted one — inverting it inside thin chrome puts a white slab in the toolbar. A settings row sizes the controls in its trailing slot itself, default in a card and `sm` when nested (`packages/app/src/components/ui/control-size.tsx`), so don't pass a size to a button, dropdown or field placed in a row. Code that computes with a control's height outside a stylesheet uses `controlHeightForLayout`. Never shrink a control's font or padding locally to fit a context — if the context needs a smaller control, the size tier is missing or the wrong one is in use.
+One gate, `resolveControlSizing`, picks touch or pointer sizing: touch when the layout is compact or the device has a touch screen. An iPad with the sidebar docked is wide and touch-sized; a desktop is pointer-sized; a phone is both compact and touch. The touch-screen fact is read once at startup (`hasTouchScreen` in `hooks/use-fine-pointer.ts`), so attaching a mouse or keyboard to a tablet never shrinks its controls. Stylesheets take sizes from `bySizing({ touch, pointer })`, which resolves to a breakpoint value, so a caller never sees which sizing it got. Rows, icon buttons and icon slots take theirs from `styles/density.ts`, which uses the same gate. An `{ xs, md }` literal for a hit target or glyph is wrong: on an iPad it yields the pointer size.
+
+Buttons are pills (`borderRadius.full`) with medium-weight labels; an icon-only button is a circle. `<Switch>` follows the same two sizes: a 34×20 track by default and in `sm`, 44×26 where controls are touch-sized, and it reserves its size's control height so a row holding one lines up with a row holding a button. Buttons, text fields, dropdown triggers, and `<SegmentedControl>` (`packages/app/src/components/ui/segmented-control.tsx`) share the size contract — the same size name means the same height and label size on every control kind, so controls in one row line up. Segments run tighter than a button, because the gap between segments already reads as padding. The selected segment is a `surface3` fill with `foreground` text, not an inverted one — inverting it inside thin chrome puts a white slab in the toolbar. A settings row sizes the controls in its trailing slot itself, default in a card and `sm` when nested (`packages/app/src/components/ui/control-size.tsx`), so don't pass a size to a button, dropdown or field placed in a row. Code that computes with a control's height outside a stylesheet uses `controlHeightForLayout`. Never shrink a control's font or padding locally to fit a context — if the context needs a smaller control, the size tier is missing or the wrong one is in use.
 
 A `<Pressable>` wrapping a `<Text>` is a sixth variant. It is wrong. `<Button>` accepts `style`, `textStyle`, `leftIcon`, `disabled`, `size`, and `variant`.
 
@@ -150,7 +152,7 @@ One row off the rail makes the whole card look unconsidered.
 
 Compact-first. The small case is designed; the large case adds chrome around it.
 
-Use `md: 600` for both the compact/wide layout boundary and responsive density, in logical points on native and CSS pixels on web. Do not add a separate density breakpoint. Measured content constraints remain independent: composer controls use `COMPACT_CONTENT_WIDTH` (500), so a narrow pane can keep compact controls inside a wide window.
+Use `md: 600` for the compact/wide layout boundary, in logical points on native and CSS pixels on web. Do not add a separate density breakpoint; touch sizing comes from the control sizing gate in [Buttons](#4-buttons). Measured content constraints remain independent: composer controls use `COMPACT_CONTENT_WIDTH` (500), so a narrow pane can keep compact controls inside a wide window.
 
 The settings shell (`packages/app/src/screens/settings-screen.tsx`) and the projects screen (`packages/app/src/screens/projects-screen.tsx`) share the canonical list+detail navigation pattern:
 

docs/floating-panels.md

@@ -157,8 +157,7 @@ and the stream keeps its existing flick-to-dismiss gesture.
 The dock's private viewport and capacity model are extracted from chat. The
 app-wide `@/keyboard/shift` module owns shared motion for the dock, portals, streams,
 terminal, explorer, and dialogs. Import only its public entry point: the provider,
-shift hooks, shift style, translate view, keyboard anchor, settled stream inset, and explorer padding
-policy. Its contexts and reconciliation stay private. Keep `KeyboardShiftProvider`
+shift hooks, shift style, translate view, and keyboard anchor. Its contexts and reconciliation stay private. Keep `KeyboardShiftProvider`
 at its root mount point outside the portal host when changing dock hosts.
 
 `KeyboardTranslateView` owns visual keyboard motion inside `@/keyboard/shift`. Android uses the
@@ -171,15 +170,14 @@ animation. Keep this platform choice inside the keyboard module's private platfo
 `KeyboardTranslateView`. The panel root clips it at the header edge, so rows
 slide under the header on open and out from under it on close. Do not swap the
 dock to keyboard padding at rest. Changing its height creates either a blank
-band or a paused transition when the inverted list updates its viewport.
+band or a paused transition when the stream list updates its viewport.
 
 Do not animate a layout prop through the keyboard transition. On Android
 Fabric, each animated layout update clones the shadow tree and runs Yoga over
 the dock subtree. This measured about 10 ms per frame on the emulator and the
 mounted layouts arrived in bursts every 2–4 frames. A transform does not dirty
-layout. Preserve the translated dock's history scroll range with a far-end
-content inset on the inverted stream list. Update that inset only when keyboard
-motion settles; never drive it per frame.
+layout. The stream list gets no keyboard inset either; see
+[who owns the offset](agent-stream-disclosure.md#who-owns-the-offset).
 
 The translated dock's height is not the composer's available height. Bound the
 composer against the stationary space below the header inside

docs/markdown-renderer.md

@@ -26,6 +26,8 @@ Native code blocks use the library's copy control and compiled grammars. Web cod
 
 The package patch also keeps overflowing native horizontal blocks in control of their drags: Android claims parent interception at touch-down and releases it for vertical drags so the chat list can scroll; iOS keeps its scroll recognizer active for outward drags at the leading edge. This prevents compact sidebar pans from taking block scrolling without changing sidebar swipes on prose or non-overflowing blocks. Native changes require a client rebuild.
 
+On iOS a newly mounted Markdown view paints empty for a frame or more after it is laid out at its measured height: the library parses even a view's first content on a background queue and applies it in a later main-queue turn. Expanding a turn in chat therefore shows its rows in place with the text arriving a frame later (165 ms when the mount keeps the main thread busy). Android paints the text in the first frame. Rendering a view's first content synchronously fixes the frame but costs frame time when a fling mounts history rows, so the app keeps the library's behavior until [enriched-markdown #1131](https://github.com/software-mansion/enriched-markdown/issues/1131) is resolved.
+
 Android measurements use a size-only, 512-entry LRU across view unmounts, matching the library’s existing iOS cache. Scrolling back through history can reuse layout sizes without parsing those rows again. Content, layout props and width identify each entry; font-scale changes and native layout invalidation discard affected sizes. The cache retains no views or spans.
 
 The library determines how incomplete Markdown appears during streaming. Completed text uses the same component and engine as history. Find and scroll-to-message address source message ids; selection-copy understands semantic HTML and the web code component's copy metadata.

docs/mobile-testing.md

@@ -452,18 +452,9 @@ Regular `View` components can safely use Unistyles dynamic styles — the confli
 
 ## Native Chat Stream Layout
 
-The native agent stream uses an inverted `FlatList`, so chat layout has three coordinate systems:
-
-- chronological stream order
-- strategy-ordered array order
-- native inverted cell visual order
-
 Do not compute stream neighbors, history/live-head seams, turn footer ownership, assistant block spacing, or tool sequence endings inside React render loops. Those policies live in `packages/app/src/agent-stream/layout.ts` and are unit-tested without React Native rendering.
 
-Platform-specific stream edges belong on `StreamStrategy`:
-
-- forward web uses the last history item as the history/live-head boundary and renders content before a footer
-- native inverted uses the first history item as the history/live-head boundary and compensates for inverted cell child order
+Platform-specific stream edges belong on `StreamStrategy`. Web and native both render in chronological order, so both use the last history item as the history/live-head boundary and render content before a footer.
 
 If a chat footer looks duplicated or appears above the assistant message on mobile, start with `packages/app/src/agent-stream/layout.test.ts`. Do not add a React Native renderer test for this class of bug; make the pure layout invariant fail first.
 

docs/native-text-selection.md

@@ -2,15 +2,6 @@
 
 Keep completed assistant prose in one native text view so selection crosses paragraphs, headings and lists. The shared [Markdown renderer](markdown-renderer.md) owns that view.
 
-## Android inverted chat
-
-Keep selection visibility handling in `modules/paseo-scroll`. Android's visibility
-rectangles ignore list inversion. React Native decomposes Android's `scale: -1`
-into rotation with positive `scaleY`, so test the composed matrix when deciding
-whether those requests should move the viewport. Native tests must apply the
-list's transform through React Native's view manager; assigning `scaleY` directly
-misses that decomposition.
-
 ## Diagrams in lists and quotes
 
 Selection stops at a Mermaid diagram. Native extracts Mermaid fences into separate views because the library exposes no native block renderer override. A diagram inside a list or quote therefore appears outside that container, and its following prose starts a separate Markdown fragment.

docs/plugins.md

@@ -474,9 +474,6 @@ path shape: a plugin can place a worktree several directories below the default
 Emit from the operation owner, not a client subscription. Provider history replay must not trigger
 live hooks. Notifications must not be awaited inside agent mutations: a handler can send a prompt
 or answer a permission through its own daemon session. Awaiting it there deadlocks that command.
-The same holds for a hook that runs inside an agent's lifecycle lane: an `agent.open.before` hook
-that awaits a write to the agent being opened (`setMetadata`, `setLabels`) waits on the open, which
-waits on the hook. The hooks reference tells plugin authors to start such a write without awaiting it.
 
 ## Contribute a provider
 
@@ -532,21 +529,13 @@ need no change. See [catalogue ownership](providers.md#provider-snapshot-refresh
 `send()` resolves after acceptance. Publish operation completion, prompt disposition, turn state,
 configuration, permissions, persistence, and complete timeline snapshots through `onEvent()`.
 Route messages, structured commands, steering, and command side effects through `session.prompt`.
-A provider's configuration is the opaque `ProviderSessionConfig.providerOptions` object on
-`session.open`. It contains the provider defaults and per-agent overrides merged by the daemon.
+Provider settings are toggle/select data that Paseo renders in the composer. Keep private options in
+the opaque `ProviderSessionConfig.providerOptions` object on `session.open`.
+It contains the provider defaults and per-agent overrides merged by the daemon.
 Validate and apply it inside the provider; core does not know your option shape.
 See [provider options](custom-providers.md#provider-options) for configuration and
 merge semantics.
 
-The provider draws some of those keys in the composer by reporting `controls` and the values it runs
-(`providerOptions`) in `session.config`. A running-agent change arrives as
-`session.configure` with `changes.providerOptions` and follows the same apply-or-throw contract as
-built-in providers ([options flow](providers.md#options-flow)). `PluginAgentSession` in
-`packages/server/src/server/agent/plugin-provider.ts` is that adapter. A provider still reporting
-`settings` is read through `plugin-provider-options.ts`, which turns each setting into a control and
-its value into an option and is sent both shapes in `session.configure`; delete it with
-`COMPAT(plugin-provider-settings)`. The ACP shim still reports `settings`.
-
 Providers add an optional veto to daemon baseline cleanup through the per-session
 [runtime safety query](../public-docs/plugins/providers.md#permit-idle-runtime-cleanup).
 The daemon calls the same `AgentSession.canStopRuntime()` interface for built-ins and plugins;
@@ -665,90 +654,6 @@ Mounted surfaces and command invocations have shorter API lifetimes.
 Keep the client entry synchronous: return its cleanup function immediately and start asynchronous
 work inside it. See the maintained [composer pill example](../plugin-examples/local-plugin/client/main.tsx).
 
-## Contribute composer items
-
-`addComposerItem` mounts a plugin component in the agent, draft and New workspace composers. The
-public contract is the [composer items reference](../public-docs/plugins/reference.md#composer-items).
-
-The composer is two contexts, provided by two owners (`packages/app/src/composer/session.tsx`).
-`Composer` provides `ComposerInput` (prompt and attachments). `AgentControls` and
-`DraftAgentControls` provide `ComposerAgent` (provider, model, mode, thinking, options, metadata and
-their commands). `toPluginComposer` (`packages/app/src/plugins/composer-items/`) joins them into the
-`PluginComposer` an item reads, so a plugin cannot tell which composer a command reaches. Add a
-capability to `ComposerAgent` and both implementations; never branch on `context` in the model.
-
-Plugin `Toggle`, `Select` and `Action`, the thinking select and provider option controls all
-render through `ComposerControl` (`packages/app/src/composer/agent-controls/composer-control.tsx`),
-a toolbar icon or a row in the overflow sheet. Model and mode stay specialized but share its trigger,
-density and overflow. Plugin items count in the density presence in `layout.ts`, so a composer
-condenses to make room for them. A custom component renders wherever its item is placed, and an
-item that renders nothing still counts for density; there is no registration for either.
-
-A command runs against the owner's current state, not the render that built the callback. The
-draft's form (`openAgentForm`) and options (`openDraftOptions`) are plain stores for that reason,
-and `draftComposerAgent` rejects a provider the host does not offer or a model its loaded catalog
-does not list. `ComposerControl` owns the pending state and the error toast for callbacks that
-return a promise.
-
-The overflow sheet's content portals to the app root, away from the composer. Pass
-`useComposerSheetBridge()` as the sheet's `contextBridge`, or `useComposer()` returns nothing and
-the sheet draws no plugin rows.
-
-## Contribute New workspace items
-
-`addNewWorkspaceItem` mounts a plugin component on the New workspace screen. The public contract
-is the [New workspace items reference](../public-docs/plugins/reference.md#new-workspace-items).
-
-The screen's choices that a plugin may change live in one plain store,
-`createNewWorkspaceSetup` (`packages/app/src/screens/new-workspace/setup-model.ts`): the base
-picker selection, the manual isolation, the branch name and the workspace metadata. The pickers and
-the plugin commands write to it, so a command sees what an earlier command left. Project and host
-stay in the screen's hooks (`useNewWorkspaceHostSelector` reconciles them against each other), and
-they are read-only to plugins; a command that switched them would unmount the item that called it.
-
-The store is built in the render that creates the screen, with what the screen derives from its
-hooks (the lock, the project, whether the project can make worktrees, whether the host supports
-metadata), so a command is valid from a child's first effect, which runs before the screen's own
-effects. `syncInputs` refreshes those inputs in a layout effect on every commit, and commands read
-them when they run, never from the render that built them. The pickers and the commands pick
-through the same `chooseBase` and `chooseIsolation`, so a plugin command has the effects of a
-pick; the screen injects those effects when it builds the store (syncing the picker's PR attachment,
-remembering the isolation), so a command from a mount effect does the same as a click. Closing the
-picker stays in the picker's own handler. Add a capability by extending the store;
-do not read screen state from a plugin component.
-
-The item host (`PluginNewWorkspaceItems`) keys the items by `(serverId, project id)`, so a change of
-project or host remounts them. That is what keeps an item's own state and a `Combobox`'s cached
-results from outliving their project: the `Combobox` cannot tell that an author's inline `search`
-now means another project, because its identity changes every render. The store clears `branch`
-and `metadata` on the same change in `syncInputs`, and a remounted item's mount effect sets them
-again.
-
-An item's commands come from `setup.commandsFor({ serverId, projectId })`, bound to the target the
-item was mounted for. Once `syncInputs` reports another target they reject with a "moved" error, so
-a lookup that finishes after a project switch cannot write into the new project's choices. The
-reset only clears what was already written; this check covers what is written later. Rejecting, not
-ignoring, matches the lock: a command's promise resolves only when the change took effect.
-
-Known limit: an item that issues a command from `useLayoutEffect` on mount after a project or host
-switch runs before the screen's `syncInputs` layout effect, so its commands (bound to the new
-target) still see the previous target and reject as moved. This applies to a project switch as well as a host switch, since items
-remount per `(serverId, project id)`. Passive effects are not affected.
-
-`ensureWorkspace` sends the store's `branch` as `source.branchName` whenever the worktree cuts a
-new branch (`startsNewBranch`, which mirrors the daemon: anything but a checkout, including no base
-at all on a detached HEAD), and its `metadata` on `workspace.create` when it is not empty. The
-server uses `branchName ?? worktreeSlug` as the new branch. `baseRef.name` is the exact ref
-creation uses; `branchNameFromRef` is for labels only.
-
-Items render through `ComposerControl` with `surface="field"`: a `FieldTrigger` (a badge on
-desktop, a full-width field when compact) and the same pending state, error toast and list as the
-composer's controls. `ComposerControlLockProvider` carries the screen's lock to them. Plugin
-`Combobox` is a `select` item with `remoteSearch`: the app `Combobox` does not filter locally, and
-`PluginCombobox` (`plugins/react-native/composer-controls.tsx`) runs `search` through
-`useFetchQuery` with `dataShape: "list"`, which keeps the previous results while a newer query runs.
-`plugins/item-host.tsx` is the host shared by composer and New workspace items.
-
 ## Contribute timeline items
 
 Timeline transformers and renderers are client contributions. The daemon's canonical rows and

docs/providers.md

@@ -30,65 +30,6 @@ at session startup. See [provider configuration](custom-providers.md#provider-op
 for defaults and merge rules, and the [SDK guide](../public-docs/sdk/provider-options.md)
 for native keys and examples.
 
-### Options flow
-
-`options` on the agent snapshot is the only option state. Controls describe how to draw an
-option and read `options`; they hold no value of their own. Any option can be read and set with
-or without a control.
-
-- **Create and resume.** The provider opens with the options it is given and emits nothing about
-  them while opening. `openOptionsPatch` carries every option the session ended up with that
-  differs from what it was given, including a setting nobody asked for (a native default such as
-  Cursor opening with Fast on). It is set before `createSession`/`resumeSession` resolves and the
-  daemon stores it before the agent is published. A reopened agent resumes that state, so a
-  native default the provider later changes does not follow. `options` on the snapshot is what
-  the session opened with, and afterwards it moves only through an apply or an `options_changed`.
-  Editing a provider default in `config.json` affects agents the next time they open.
-- **Live apply.** `applyOptions` receives the keys the patch touches, resolved against the
-  `config.json` defaults. A removal arrives as the default the key falls back to, or `null` when
-  there is none; the provider returns the setting to its own default if it can, or throws to
-  reject. A key the running session cannot apply (one the provider reads only when it opens) is
-  rejected too, so a stored option always describes what runs. Claude reads most options when it
-  starts its query, and replacing a started query would end its background work, so after the
-  first prompt only Fast can change. Codex fixes its approval policy and sandbox when the thread
-  starts, so it applies only `service_tier` and `plan_mode` live. A session with no
-  `applyOptions` rejects every patch; the daemon enforces this. The provider returns the options
-  it ended up with when they differ from the request. The daemon
-  stores the patch and that result in one step after the call resolves, onto the agent's options
-  as they are at that moment, so the last write wins. Throwing rejects the whole patch and
-  none of it is stored. Emit nothing from inside the call. If the provider's own state moved
-  before it refused, it reports the moved values once as `options_changed` after the call has
-  ended, because the stored options must match what runs.
-- **Old data converts in the agent manager.** Codex used to take `fast_mode`; it takes
-  `service_tier` now. `AgentManager` runs `convertLegacyOptions` (`option-controls.ts`) on an
-  agent's own options when it creates, resumes, imports, reloads or applies to it, and on draft
-  controls, before defaults merge and before anything is stored (`true` is `"fast"`, `false` is
-  `"default"`, and a `service_tier` in the same input wins). The manager converts for the adapter
-  behind the provider id, following `derivedFromProviderId`, so a custom provider with
-  `extends: "codex"` is converted too. Configured defaults convert in the provider registry. A
-  stored record keeps `fast_mode` until the agent is next opened or applied to, and is stored
-  converted from then on. Nothing past the manager sees `fast_mode` for Codex. Codex resolves
-  `"fast"` to the model's Fast tier and reports the id it runs through `openOptionsPatch` or the
-  `applyOptions` result like any other value. The `featureValues` to `options` fold is separate
-  and provider-agnostic; it stays at the protocol and legacy edges.
-- **Clients draw from the daemon's answer.** The app reads `controls` and `options` from the
-  agent snapshot for a running or closed agent. A draft and a profile form send everything they
-  would create with (seed, the provider's last-used control values once the provider has said it
-  still draws them, and the user's edits) in `provider.controls.list.request` and draw only what
-  comes back, so an alias such as a legacy Fast profile's `service_tier: "fast"` is resolved once,
-  by the daemon. A toggle shows over the last answer until its own answer arrives. The draft's
-  layers live in a plain model (`agent-controls/draft-options-model.ts`): applying a profile
-  replaces provider and options in one step, while choosing a provider by hand starts over. A
-  profile saves its stored options plus the form's edits, so options no control draws survive an
-  edit. A daemon without `server_info.features.providerOptionControls` sends `features` and
-  `featureValues`; `packages/client/src/compat/legacy-provider-options.ts` is the one place that
-  turns those into `controls` and `options` and back, so nothing in the app branches on it. A
-  create that carries options first lists the controls for its own provider, model, mode and
-  thinking level, since which options are controls differs by model, and sends those as
-  `featureValues`; callers do not prime anything.
-- **Provider-initiated changes.** A setting the provider changes on its own is an
-  `options_changed` event. The daemon stores and forwards it and does not push the old value back.
-
 Exact MCP preapproval is a separate daemon-owned contract. A new provider must fail
 closed for Hub unattended execution until it can approve one exact injected MCP
 server and tool identity without approving native tools.
@@ -174,7 +115,7 @@ Submitted user-message wire items carry the same Paseo ID in `messageId` and `cl
 
 Provider adapters must terminalize every transient timeline row before emitting the turn's terminal event. Codex may omit the completed `contextCompaction` item when a turn ends during compaction, so its adapter closes any pending root compaction before forwarding `turn_completed`, `turn_failed`, or `turn_canceled`. A terminal turn must never leave the client showing an operation as still loading.
 
-Draft metadata lookups should avoid creating provider sessions when the upstream provider has top-level APIs for that metadata. Prefer `AgentClient.fetchCatalog`, `listCommands`, or `listControls` over creating a scratch `AgentSession`; scratch sessions can show up as empty native sessions in provider import/history UIs. `fetchCatalog` is the single discovery API for models and modes — provider implementations may use one process, separate upstream calls, or static data internally, but callers outside the provider do not get separate runtime model/mode probes. Draft command listing and scratch-session control listing require an explicit draft model. Do not resolve a default model through catalog discovery. A client-level `listControls` implementation may return controls from an incomplete, model-less draft and owns which features are valid in that state.
+Draft metadata lookups should avoid creating provider sessions when the upstream provider has top-level APIs for that metadata. Prefer `AgentClient.fetchCatalog`, `listCommands`, or `listFeatures` over creating a scratch `AgentSession`; scratch sessions can show up as empty native sessions in provider import/history UIs. `fetchCatalog` is the single discovery API for models and modes — provider implementations may use one process, separate upstream calls, or static data internally, but callers outside the provider do not get separate runtime model/mode probes. Draft command listing and scratch-session feature listing require an explicit draft model. Do not resolve a default model through catalog discovery. A client-level `listFeatures` implementation may return features from an incomplete, model-less draft and owns which features are valid in that state.
 
 Provider session import has its own contract. The picker calls `listImportableSessions` and receives rows only: provider handle, cwd, title, prompt previews, and last activity. Import calls `importSession({ providerHandleId, cwd })` for the selected row and must not call listing again. The provider returns the resumed session, storage config, persistence handle, and hydrated timeline for that one native session; `AgentManager.importProviderSession` seeds the daemon timeline and publishes the Paseo agent only after it is ready.
 
@@ -537,7 +478,7 @@ interface AgentSession {
   readonly provider: AgentProvider;
   readonly id: string | null;
   readonly capabilities: AgentCapabilityFlags;
-  readonly controls?: AgentOptionControl[];
+  readonly features?: AgentFeature[];
   run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
   startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{ turnId: string }>;
   steerActiveTurn?(prompt: AgentPromptInput, options: SteerActiveTurnOptions): Promise<SteerResult>;
@@ -559,7 +500,7 @@ interface AgentSession {
   listCommands?(): Promise<AgentSlashCommand[]>;
   setModel?(modelId: string | null): Promise<void>;
   setThinkingOption?(thinkingOptionId: string | null): Promise<void | AgentProviderNotice>;
-  applyOptions?(options: ProviderOptions): Promise<void>;
+  setFeature?(featureId: string, value: unknown): Promise<void>;
   tryHandleOutOfBand?(prompt: AgentPromptInput): {
     run(ctx: { emit: (event: AgentStreamEvent) => void }): Promise<void>;
   } | null;

docs/timeline-sync.md

@@ -95,9 +95,10 @@ Provider message IDs are not guaranteed for every displayed item. Paseo-generate
 Actions that address a point in chat history, such as Fork, use the daemon timeline `epoch` plus the projected item's `seqEnd`. The app carries that position on the rendered assistant item for both live and fetched history. When adjacent projected chunks merge, the merged item retains the newer chunk's position.
 
 The daemon validates the epoch and locates the projected item at the selected position. A fork
-includes projected items through that checkpoint. If an item spans the checkpoint and changed
-afterward, the daemon refuses that fork with an actionable error: discarded historical payloads
-cannot be reconstructed from sequence metadata. Forking the current context remains available.
+includes projected items through that checkpoint. If an item the fork copies spans the checkpoint
+and changed afterward, the daemon refuses that fork with an actionable error: discarded historical
+payloads cannot be reconstructed from sequence metadata. Plugin cards are not copied, so a card
+updated after the checkpoint does not block it. Forking the current context remains available.
 
 ## Resume behavior
 

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-p97CaALgkY+x9XVvS4/ILqmbwYSX0fSbVUgQl35BjiU=
+sha256-sLaLHD1u1eJRdGdflcwWBGxnnhRQpB1T74BlaWcmxbU=

package-lock.json

@@ -8142,6 +8142,26 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@legendapp/list": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/@legendapp/list/-/list-3.7.1.tgz",
+      "integrity": "sha512-zgIy84yG2JP93+kib61rZBTcYGZ6fULrkCQz/MF7WrjVJeJQa/rR4z+rXfM5oveirO5mYkro4IDGytARIjJe9w==",
+      "license": "MIT",
+      "dependencies": {
+        "use-sync-external-store": "^1.5.0"
+      },
+      "peerDependencies": {
+        "react": "*"
+      },
+      "peerDependenciesMeta": {
+        "react-dom": {
+          "optional": true
+        },
+        "react-native": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@lezer/common": {
       "version": "1.5.1",
       "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.5.1.tgz",
@@ -37466,6 +37486,7 @@
         "@getpaseo/protocol": "*",
         "@gorhom/bottom-sheet": "^5.2.14",
         "@gorhom/portal": "^1.0.14",
+        "@legendapp/list": "^3.7.1",
         "@marijn/find-cluster-break": "^1.0.2",
         "@mattermost/react-native-paste-input": "2.0.1",
         "@react-native-async-storage/async-storage": "2.2.0",

packages/app/e2e/browser/agent-profile-modeless-preferences.spec.ts

@@ -62,7 +62,7 @@ async function readProviderFeaturePreferences(page: Page, provider: string): Pro
       const raw = localStorage.getItem(preferencesKey);
       if (!raw) return null;
       const preferences = JSON.parse(raw) as FormPreferences;
-      return preferences.providerPreferences?.[providerId]?.options ?? null;
+      return preferences.providerPreferences?.[providerId]?.featureValues ?? null;
     },
     { preferencesKey: CREATE_AGENT_PREFERENCES_KEY, providerId: provider },
   );
@@ -145,7 +145,7 @@ test.describe("Agent profiles repair modeless provider preferences", () => {
         provider: featureProviderId,
         model: featureModelId,
         modeId: "bypassPermissions",
-        options: { fast_mode: true },
+        featureValues: { fast_mode: true },
       },
     ]);
     const provider = await seedModelProvider({
@@ -181,7 +181,7 @@ test.describe("Agent profiles repair modeless provider preferences", () => {
       expect(createAgentRequest).toMatchObject({
         config: {
           provider: featureProviderId,
-          providerOptions: { fast_mode: true },
+          featureValues: { fast_mode: true },
         },
       });
     } finally {

packages/app/e2e/browser/changes-pane.spec.ts

@@ -928,11 +928,11 @@ test("compact Changes keeps its actions compact and menu-only", async ({ page })
     throw new Error("Compact Changes toolbar geometry could not be measured");
   }
   expect(actionsBox.width).toBe(48);
-  expect(actionsBox.height).toBe(28);
-  expect(optionsBox.width).toBe(32);
-  expect(optionsBox.height).toBe(32);
-  expect(glyphBox.width).toBe(18);
-  expect(glyphBox.height).toBe(18);
+  expect(actionsBox.height).toBe(32);
+  expect(optionsBox.width).toBe(44);
+  expect(optionsBox.height).toBe(44);
+  expect(glyphBox.width).toBe(20);
+  expect(glyphBox.height).toBe(20);
 
   await expect(actions).not.toContainText("Commit");
   await expect(actions.locator("svg")).toHaveCount(2);

packages/app/e2e/browser/compact-workspace-header.spec.ts

@@ -1,5 +1,6 @@
 import type { Page, TestInfo } from "@playwright/test";
 import { test, expect } from "../support/fixtures";
+import { pauseWorkspaceTerminalWorker } from "../support/helpers/workspace-setup";
 import { seedWorkspace } from "../support/helpers/seed-client";
 import { openAgentRoute } from "../support/helpers/mock-agent";
 import { getServerId } from "../support/helpers/server-id";
@@ -190,3 +191,49 @@ test("compact header menu runs, shows, and stops workspace scripts", async ({ pa
     await workspace.cleanup();
   }
 });
+
+async function restartScriptAcrossHeaderRemoval(page: Page, terminalId: string) {
+  await openRunningScriptPage(page, "lint");
+  const resumeWorker = await pauseWorkspaceTerminalWorker(terminalId);
+  try {
+    await menuRow(page, "Restart").click();
+    await page.setViewportSize({ width: 1280, height: 844 });
+    await expect(page.getByRole("button", { name: /Switch tabs/ })).toHaveCount(0);
+    await expect(page.getByTestId("workspace-scripts-button")).toBeVisible();
+  } finally {
+    resumeWorker();
+  }
+}
+
+async function expectScriptTerminalReplaced(
+  workspace: Awaited<ReturnType<typeof openWorkspaceWithScripts>>,
+  previousId: string,
+) {
+  await expect
+    .poll(
+      async () => {
+        const after = await workspace.client.listTerminals(undefined, undefined, {
+          workspaceId: workspace.workspaceId,
+        });
+        return after.terminals.filter((terminal) => terminal.id !== previousId).length;
+      },
+      { timeout: 15_000 },
+    )
+    .toBe(1);
+}
+
+test("pending script restart survives removal of the compact header", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  const workspace = await openWorkspaceWithScripts(page);
+  try {
+    await runScriptFromScriptsPage(page, "lint");
+    const before = await workspace.client.listTerminals(undefined, undefined, {
+      workspaceId: workspace.workspaceId,
+    });
+    expect(before.terminals).toHaveLength(1);
+    await restartScriptAcrossHeaderRemoval(page, before.terminals[0]!.id);
+    await expectScriptTerminalReplaced(workspace, before.terminals[0]!.id);
+  } finally {
+    await workspace.cleanup();
+  }
+});

packages/app/e2e/browser/composer-control-density.spec.ts

@@ -5,6 +5,7 @@ import {
   recordComposerToolbarFrames,
 } from "../support/helpers/composer-control-density";
 import { clickNewChat, gotoWorkspace } from "../support/helpers/launcher";
+import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
 import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
 
 const SETTLE_MS = 1_000;
@@ -92,3 +93,34 @@ test.describe("Composer control density across tab switches", () => {
     }
   });
 });
+
+test.describe("Composer controls folding on a touch device", () => {
+  test.use({ viewport: { width: 1194, height: 834 }, isMobile: true, hasTouch: true });
+  test.describe.configure({ timeout: 180_000 });
+
+  test("an open menu stays closed after the controls fold and unfold", async ({ page }) => {
+    const session = await seedMockAgentWorkspace({
+      repoPrefix: "composer-density-fold-",
+      title: "Folding chat",
+      model: "ten-second-stream",
+    });
+    try {
+      await openAgentRoute(page, session);
+      const thinking = page.getByTestId("agent-thinking-selector").filter({ visible: true });
+      const thinkingMenu = page.getByTestId("combobox-desktop-container");
+
+      await thinking.click();
+      await expect(thinkingMenu).toBeVisible();
+
+      // Still a wide layout, but too narrow for separate controls: they fold into the model control.
+      await page.setViewportSize({ width: 640, height: 834 });
+      await expect(thinking).toHaveCount(0);
+
+      await page.setViewportSize({ width: 1194, height: 834 });
+      await expect(thinking).toBeVisible();
+      await expect(thinkingMenu).toHaveCount(0);
+    } finally {
+      await session.cleanup();
+    }
+  });
+});

packages/app/e2e/browser/plugin-composer-items.spec.ts

@@ -1,12 +0,0 @@
-import { test } from "../support/fixtures";
-import { withComposerControlsExample } from "../support/helpers/plugin-composer-items";
-
-test("a narrow composer's overflow sheet shows a plugin item's row", async ({ page }) => {
-  test.setTimeout(120_000);
-  await withComposerControlsExample(page, async (composer) => {
-    await composer.narrowTheWindow();
-    await composer.openAgentFeatures();
-    await composer.expectFeatureRow("Needs review");
-    await composer.expectFeatureRow("Insert checklist");
-  });
-});

packages/app/e2e/browser/plugin-new-workspace-items.spec.ts

@@ -1,110 +0,0 @@
-import { expect, test } from "../support/fixtures";
-import { withNewWorkspaceIssuesExample } from "../support/helpers/plugin-new-workspace-items";
-
-for (const layout of [
-  { name: "desktop", compact: false },
-  { name: "compact", compact: true },
-]) {
-  test(`a plugin's New workspace item sets the branch and metadata on ${layout.name}`, async ({
-    page,
-  }) => {
-    test.setTimeout(180_000);
-    await withNewWorkspaceIssuesExample(page, { compact: layout.compact }, async (screen) => {
-      await screen.chooseWorktree();
-      await screen.chooseIssue("PAS-102 Crash on resume");
-      const created = await screen.createWorkspace();
-      expect(created.branch).toBe("pas-102-crash-on-resume");
-      expect(created.metadata).toEqual({ "new-workspace-issues.issue": "PAS-102" });
-    });
-  });
-}
-
-test("a branch chosen while Local applies once the user switches to a new worktree", async ({
-  page,
-}) => {
-  test.setTimeout(180_000);
-  await withNewWorkspaceIssuesExample(page, { compact: false }, async (screen) => {
-    await screen.chooseIssue("PAS-101 Slow sidebar");
-    await screen.chooseWorktree();
-    const created = await screen.createWorkspace({ prompt: "" });
-    expect(created.branch).toBe("pas-101-slow-sidebar");
-    expect(created.metadata).toEqual({ "new-workspace-issues.issue": "PAS-101" });
-  });
-});
-
-test("a plugin's branch applies when the project has no default base to branch off", async ({
-  page,
-}) => {
-  test.setTimeout(180_000);
-  await withNewWorkspaceIssuesExample(
-    page,
-    { compact: false, detachedHead: true },
-    async (screen) => {
-      await screen.chooseWorktree();
-      await screen.chooseIssue("PAS-101 Slow sidebar");
-      const created = await screen.createWorkspace();
-      expect(created.branch).toBe("pas-101-slow-sidebar");
-    },
-  );
-});
-
-test("a branch and metadata chosen for one project are not sent for another", async ({ page }) => {
-  test.setTimeout(180_000);
-  await withNewWorkspaceIssuesExample(
-    page,
-    { compact: false, otherProject: true },
-    async (screen) => {
-      await screen.chooseWorktree();
-      await screen.chooseIssue("PAS-101 Slow sidebar");
-      await screen.switchToOtherProject();
-      const created = await screen.createWorkspace();
-      expect(created.branch).not.toBe("pas-101-slow-sidebar");
-      expect(created.metadata ?? {}).toEqual({});
-    },
-  );
-});
-
-test("an item's Issue list does not keep the previous project's results after a project switch", async ({
-  page,
-}) => {
-  test.setTimeout(180_000);
-  await withNewWorkspaceIssuesExample(
-    page,
-    { compact: false, otherProject: true, searchesByProject: true },
-    async (screen) => {
-      await screen.openIssueList();
-      await screen.expectIssueListText(`Issue of ${screen.firstProjectName}`, true);
-      await screen.closeIssueList();
-      await screen.switchToOtherProject();
-      await screen.openIssueList();
-      await screen.expectIssueListText(`Issue of ${screen.firstProjectName}`, false);
-    },
-  );
-});
-
-test("an isolation set from a mount effect is remembered like a pick", async ({ page }) => {
-  test.setTimeout(180_000);
-  await withNewWorkspaceIssuesExample(
-    page,
-    { compact: false, setsOnMount: true },
-    async (screen) => {
-      await screen.expectIsolation("worktree");
-      await screen.reopenWithoutPlugin();
-      await screen.expectIsolation("worktree");
-    },
-  );
-});
-
-test("an item can set the branch and metadata from its mount effect", async ({ page }) => {
-  test.setTimeout(180_000);
-  await withNewWorkspaceIssuesExample(
-    page,
-    { compact: false, setsOnMount: true },
-    async (screen) => {
-      await screen.expectIsolation("worktree");
-      const created = await screen.createWorkspace();
-      expect(created.branch).toBe("set-on-mount");
-      expect(created.metadata).toEqual({ "new-workspace-issues.issue": "ON-MOUNT" });
-    },
-  );
-});

packages/app/e2e/browser/plugin-sidebar-items.spec.ts

@@ -317,7 +317,10 @@ test.describe("Plugin sidebar items", () => {
       const compactSync = footerItem(page, SHOWCASE_PLUGIN_ID, "sync");
       await expect(compactSync).toBeInViewport();
       await expectFooterRow(page, compactSync);
-      await expect(headerRow(page, SHOWCASE_PLUGIN_ID, "deploys")).toBeInViewport();
+      // The compact nav block is capped at half the sidebar and scrolls past it.
+      const compactDeploys = headerRow(page, SHOWCASE_PLUGIN_ID, "deploys");
+      await compactDeploys.scrollIntoViewIfNeeded();
+      await expect(compactDeploys).toBeInViewport();
       await qaScreenshot(page, "phase2-compact-sidebar");
       await qaScreenshot(page, "phase5-compact-footer", sidebarFooter(page));
       await compactSync.click();

packages/app/e2e/browser/terminal-find.spec.ts

@@ -1,3 +1,4 @@
+import { getServerId } from "../support/helpers/server-id";
 import { runWorkspaceActionFromCommandCenter } from "../support/helpers/command-center-workspace-actions";
 import { spawnSync } from "node:child_process";
 import { readFile, writeFile } from "node:fs/promises";
@@ -487,3 +488,175 @@ test("keeps the shared Find controls usable in a compact dark browser", async ({
   await page.getByRole("button", { name: "Close Find" }).click();
   await expect(input(page)).toBeFocused();
 });
+
+// A phone browser installs xterm's document-level touch gesture listener too.
+// Keep this journey touch-enabled so it catches duplicate scroll handling.
+test.describe("terminal history with a finger", () => {
+  test.use({ isMobile: true, hasTouch: true, viewport: { width: 390, height: 844 } });
+
+  test("scrolls history once per finger drag", async ({ page }) => {
+    await openPhoneTerminalHistory(page);
+    await expectSingleFingerScroll(page, 24);
+    await expectSingleFingerScroll(page, 1);
+    await expectMouseWheelScrollsHistory(page);
+  });
+
+  for (const mode of ["alternate", "mouse"] as const) {
+    test(`preserves finger navigation in ${mode} input mode`, async ({ page }) => {
+      await openPhoneInputCapture(page, mode);
+      await expectFingerNavigationInput(page, mode);
+    });
+  }
+});
+
+async function expectFingerNavigationInput(page: Page, mode: "alternate" | "mouse") {
+  await dragTerminalWithFinger(page, 24, async () => {
+    const prefix = mode === "alternate" ? "TOUCH_BYTES:1b4f41" : "TOUCH_BYTES:1b5b3c3634";
+    await expect.poll(() => getTerminalBufferText(page)).toContain(prefix);
+  });
+}
+
+async function openPhoneTerminalHistory(page: Page) {
+  await harness.createTerminal({
+    name: "Finger scroll history",
+    command: "bash",
+    args: [
+      "--noprofile",
+      "--norc",
+      "-c",
+      "for i in $(seq 1 150); do echo HISTORY_$i; done; exec sleep 300",
+    ],
+  });
+  await openPhoneTerminal(page);
+  await expect.poll(() => getTerminalBufferText(page)).toContain("HISTORY_150");
+}
+
+async function openPhoneInputCapture(page: Page, mode: "alternate" | "mouse") {
+  const escapes = mode === "alternate" ? "\x1b[?1049h\x1b[?1h" : "\x1b[?1000h\x1b[?1006h";
+  await harness.createTerminal({
+    name: "Touch application input",
+    command: process.execPath,
+    args: [
+      "-e",
+      `
+      process.stdin.setRawMode(true);
+      process.stdin.once("data", () => {
+        process.stdin.on("data", chunk => {
+          process.stdout.write("\\r\\nTOUCH_BYTES:" + chunk.toString("hex") + ":END\\r\\n");
+        });
+        process.stdout.write(${JSON.stringify(escapes)} + "TOUCH_INPUT_READY\\r\\n");
+      });
+      process.stdout.write("TOUCH_START_READY\\r\\n");
+    `,
+    ],
+  });
+  await openPhoneTerminal(page);
+  await expect.poll(() => getTerminalBufferText(page)).toContain("TOUCH_START_READY");
+  await input(page).press("x");
+  await expect.poll(() => getTerminalBufferText(page)).toContain("TOUCH_INPUT_READY");
+  await expect
+    .poll(() => page.evaluate(() => window.__paseoTerminal!.buffer.active.type))
+    .toBe(mode === "alternate" ? "alternate" : "normal");
+  await expect
+    .poll(() => page.evaluate(() => window.__paseoTerminal!.modes.mouseTrackingMode))
+    .toBe(mode === "mouse" ? "vt200" : "none");
+}
+
+async function openPhoneTerminal(page: Page) {
+  await page.goto("/");
+  await page.getByRole("button", { name: "Open menu", exact: true }).click();
+  await page.getByTestId(`sidebar-workspace-row-${getServerId()}:${harness.workspaceId}`).click();
+  await expect(page.getByRole("textbox", { name: "Terminal input" })).toBeVisible();
+  await expect(page.getByTestId("terminal-surface").filter({ visible: true })).toBeVisible();
+}
+
+async function expectMouseWheelScrollsHistory(page: Page) {
+  const beforeWheel = (await viewport(page))!;
+  await page.mouse.move(200, 300);
+  await page.mouse.wheel(0, -120);
+  await expect.poll(() => viewport(page)).toBeLessThan(beforeWheel);
+}
+
+async function expectSingleFingerScroll(page: Page, moves: number) {
+  await dragTerminalWithFinger(page, moves, async ({ lineHeight, before }) => {
+    await expect.poll(async () => before - (await viewport(page))!).toBeGreaterThan(0);
+    const moved = before - (await viewport(page))!;
+    await test.info().attach("finger-scroll", {
+      body: JSON.stringify({ moves, distancePx: 120, lineHeight, rowsMoved: moved }),
+      contentType: "application/json",
+    });
+    expect(moved, "one gesture must not scroll twice its physical distance").toBeLessThanOrEqual(
+      Math.ceil(120 / lineHeight),
+    );
+  });
+}
+
+async function dragTerminalWithFinger(
+  page: Page,
+  moves: number,
+  inspect: (state: { lineHeight: number; before: number }) => Promise<void>,
+) {
+  await test.step(`Drag history with ${moves} touch moves`, async () => {
+    const screen = page
+      .getByTestId("terminal-surface")
+      .filter({ visible: true })
+      .locator(".xterm-screen");
+    const box = await screen.boundingBox();
+    if (!box) throw new Error("Terminal screen is not visible");
+    const rows = await page.evaluate(() => window.__paseoTerminal!.rows);
+    const lineHeight = box.height / rows;
+    const before = (await viewport(page))!;
+    const session = await page.context().newCDPSession(page);
+    try {
+      const start = { x: box.x + box.width / 2, y: box.y + box.height / 3 };
+      await session.send("Input.dispatchTouchEvent", {
+        type: "touchStart",
+        touchPoints: [{ ...start, id: 1 }],
+      });
+      for (let step = 1; step <= moves; step++) {
+        await session.send("Input.dispatchTouchEvent", {
+          type: "touchMove",
+          touchPoints: [{ x: start.x, y: start.y + (120 * step) / moves, id: 1 }],
+        });
+      }
+      // Check before lifting the finger to exclude inertial scrolling.
+      await inspect({ lineHeight, before });
+    } finally {
+      await session.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
+      await session.detach();
+    }
+  });
+}
+
+// Diagnostic-only: application modes emitted before the first attachment.
+// The existing live-mode tests above are the control for this failure.
+test.describe("mouse mode enabled before terminal attachment", () => {
+  test.use({ isMobile: true, hasTouch: true, viewport: { width: 390, height: 844 } });
+
+  test("preserves SGR wheel reports when opening a running terminal", async ({ page }) => {
+    await openPreAttachedMouseCapture(page);
+    await expectFingerNavigationInput(page, "mouse");
+  });
+});
+
+async function openPreAttachedMouseCapture(page: Page) {
+  await harness.createTerminal({
+    name: "Mouse mode before attachment",
+    command: process.execPath,
+    args: [
+      "-e",
+      `
+      process.stdin.setRawMode(true);
+      process.stdin.on("data", chunk => {
+        process.stdout.write("\\r\\nTOUCH_BYTES:" + chunk.toString("hex") + ":END\\r\\n");
+      });
+      process.stdout.write("\\x1b[?1000h\\x1b[?1006hTOUCH_INPUT_READY\\r\\n");
+    `,
+    ],
+  });
+  await openPhoneTerminal(page);
+  await expect.poll(() => getTerminalBufferText(page)).toContain("TOUCH_INPUT_READY");
+  await expect
+    .poll(() => page.evaluate(() => window.__paseoTerminal!.modes.mouseTrackingMode))
+    .toBe("vt200");
+}

packages/app/e2e/mobile/agent-device/native-sidebar-drag-release.ios.ad

@@ -6,6 +6,11 @@ env APP_ID=sh.paseo.debug
 # Hold past drag arming (180ms), then release.
 open "${APP_ID}"
 press "label=\"Open menu\""
+wait "id=\"sidebar-close\"" 10000
+press "id=\"sidebar-close\""
+# The close target must clear system controls, including a trailing status column.
+wait "label=\"Open menu\"" 5000
+press "label=\"Open menu\""
 wait "id=\"${WORKSPACE_ROW}\"" 10000
 longpress "id=\"${WORKSPACE_ROW}\"" 250
 press "id=\"${WORKSPACE_ROW}\""

packages/app/e2e/support/helpers/plugin-composer-items.ts

@@ -1,59 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-import { gotoAppShell } from "./app";
-import { openAgentRoute } from "./mock-agent";
-import { connectNewWorkspaceDaemonClient } from "./new-workspace";
-import { copyPluginExample } from "./plugin-fixture";
-import { seedWorkspace } from "./seed-client";
-
-const PLUGIN_ID = "composer-controls-example";
-const NARROW = { width: 500, height: 800 };
-
-/** Runs `run` in an agent's composer with the composer-controls example installed. */
-export async function withComposerControlsExample(
-  page: Page,
-  run: (composer: {
-    narrowTheWindow(): Promise<void>;
-    openAgentFeatures(): Promise<void>;
-    expectFeatureRow(name: string): Promise<void>;
-  }) => Promise<void>,
-) {
-  const workspace = await seedWorkspace({
-    repoPrefix: "composer-items-",
-    title: "Composer items",
-  });
-  const agent = await workspace.client.createAgent({
-    provider: "mock",
-    cwd: workspace.repoPath,
-    workspaceId: workspace.workspaceId,
-    title: "Composer items agent",
-    model: "ten-second-stream",
-    modeId: "load-test",
-  });
-  const client = await connectNewWorkspaceDaemonClient({ ownProjects: false });
-  const previous = await client.getDaemonConfig();
-  const example = await copyPluginExample("composer-controls");
-  try {
-    await client.patchDaemonConfig({ pluginsEnabled: true });
-    await client.installDirectoryPlugin(example.directory);
-    await gotoAppShell(page);
-    await openAgentRoute(page, { workspaceId: workspace.workspaceId, agentId: agent.id });
-    await run({
-      narrowTheWindow: () =>
-        test.step("narrow the window until the composer folds its controls away", () =>
-          page.setViewportSize(NARROW)),
-      openAgentFeatures: () =>
-        test.step("open the agent features sheet", async () => {
-          await page.getByRole("button", { name: "Open agent features", exact: true }).click();
-        }),
-      expectFeatureRow: (name) =>
-        test.step(`the sheet has a row for "${name}"`, () =>
-          expect(page.getByRole("button", { name, exact: true })).toBeVisible()),
-    });
-  } finally {
-    await client.removePlugin(PLUGIN_ID);
-    await client.patchDaemonConfig({ pluginsEnabled: previous.config.pluginsEnabled });
-    await client.close();
-    await example.cleanup();
-    await workspace.cleanup();
-  }
-}

packages/app/e2e/support/helpers/plugin-new-workspace-items.ts

@@ -1,228 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { expect, test, type Page } from "@playwright/test";
-import { gotoAppShell } from "./app";
-import {
-  archiveWorkspaceFromDaemon,
-  assertNewWorkspaceSidebarAndHeader,
-  connectNewWorkspaceDaemonClient,
-  expectWorkspaceIsolationSelected,
-  openNewWorkspaceComposer,
-  openProjectViaDaemon,
-  submitNewWorkspacePrompt,
-} from "./new-workspace";
-import { copyPluginExample } from "./plugin-fixture";
-import { getServerId } from "./server-id";
-import { createTempGitRepo } from "./workspace";
-import { waitForSidebarHydration } from "./workspace-ui";
-
-/** Presses Create, typing the prompt first unless the test wants an empty one. */
-async function submitCreate(page: Page, prompt: string | undefined) {
-  if (prompt !== "") return submitNewWorkspacePrompt(page, prompt);
-  await page.getByTestId("message-input-root").getByRole("button", { name: "Create" }).click();
-}
-
-/** An item that sets the branch and metadata from its mount effect, before the user touches anything. */
-async function replaceWithMountEffectItem(directory: string) {
-  await writeFile(
-    path.join(directory, "index.client.tsx"),
-    `import { useEffect } from "react";
-import { useNewWorkspace } from "@getpaseo/plugin/client";
-import { Action } from "@getpaseo/plugin/client/ui";
-function OnMount() {
-  const newWorkspace = useNewWorkspace();
-  useEffect(() => {
-    void newWorkspace.setIsolation("worktree");
-    void newWorkspace.setBranch("set-on-mount");
-    void newWorkspace.setMetadata({ "new-workspace-issues.issue": "ON-MOUNT" });
-  }, []);
-  return <Action title="Mount" icon="Flag" onPress={() => {}} />;
-}
-export default function contribute(client) {
-  client.addNewWorkspaceItem({ id: "on-mount", Component: OnMount });
-  return () => {};
-}
-`,
-  );
-}
-
-/**
- * An item whose search depends on the project: it answers with the project's name, and never
- * answers for the project named "other", so a list that still shows the first project's answer
- * there is stale.
- */
-async function replaceWithProjectSearchItem(directory: string) {
-  await writeFile(
-    path.join(directory, "index.client.tsx"),
-    `import { useNewWorkspace } from "@getpaseo/plugin/client";
-import { Combobox } from "@getpaseo/plugin/client/ui";
-function ProjectIssues() {
-  const { project } = useNewWorkspace();
-  const name = project?.name ?? "";
-  return (
-    <Combobox
-      title="Issue"
-      icon="CircleDot"
-      value={null}
-      search={() =>
-        name.includes("other")
-          ? new Promise(() => {})
-          : Promise.resolve([{ id: name, label: "Issue of " + name }])
-      }
-      onSelect={() => {}}
-    />
-  );
-}
-export default function contribute(client) {
-  client.addNewWorkspaceItem({ id: "project-issues", Component: ProjectIssues });
-  return () => {};
-}
-`,
-  );
-}
-
-type Client = Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
-
-/** The daemon fills in the git runtime after it creates the workspace, so wait for the branch. */
-async function readCreatedWorkspace(client: Client, workspaceId: string) {
-  const deadline = Date.now() + 30_000;
-  for (;;) {
-    const { entries } = await client.fetchWorkspaces();
-    const workspace = entries.find((entry) => entry.id === workspaceId);
-    const branch = workspace?.gitRuntime?.currentBranch ?? null;
-    if (workspace && branch) return { branch, metadata: workspace.metadata };
-    if (Date.now() > deadline) throw new Error(`Workspace ${workspaceId} never reported a branch`);
-    await new Promise((resolve) => setTimeout(resolve, 250));
-  }
-}
-
-const PLUGIN_ID = "new-workspace-issues-example";
-const COMPACT = { width: 500, height: 800 };
-
-/** Runs `run` on the New workspace screen with the new-workspace-issues example installed. */
-export async function withNewWorkspaceIssuesExample(
-  page: Page,
-  options: {
-    compact: boolean;
-    detachedHead?: boolean;
-    setsOnMount?: boolean;
-    /** Installs an item whose Issue list depends on the project instead of the example's. */
-    searchesByProject?: boolean;
-    /** A second project the screen can switch to. */
-    otherProject?: boolean;
-  },
-  run: (screen: {
-    chooseWorktree(): Promise<void>;
-    chooseIssue(label: string): Promise<void>;
-    createWorkspace(options?: { prompt?: string }): Promise<{ branch: string; metadata: unknown }>;
-    switchToOtherProject(): Promise<void>;
-    openIssueList(): Promise<void>;
-    closeIssueList(): Promise<void>;
-    /** The Issue list shows `text`, or does not show it when `shown` is false. */
-    expectIssueListText(text: string, shown: boolean): Promise<void>;
-    /** The name the first project's items read as `project.name`. */
-    firstProjectName: string;
-    expectIsolation(isolation: "local" | "worktree"): Promise<void>;
-    /** Removes the plugin, leaves the screen, and opens New workspace for the project again. */
-    reopenWithoutPlugin(): Promise<void>;
-  }) => Promise<void>,
-) {
-  const client = await connectNewWorkspaceDaemonClient();
-  const previous = await client.getDaemonConfig();
-  const example = await copyPluginExample("new-workspace-issues");
-  if (options.searchesByProject) await replaceWithProjectSearchItem(example.directory);
-  if (options.setsOnMount) await replaceWithMountEffectItem(example.directory);
-  const repo = await createTempGitRepo("new-workspace-issues-", { branches: ["main"] });
-  const otherRepo = options.otherProject
-    ? await createTempGitRepo("new-workspace-other-", { branches: ["main"] })
-    : null;
-  let createdDirectory: string | null = null;
-  try {
-    // A detached HEAD leaves the screen with no default base to branch off.
-    if (options.detachedHead) execFileSync("git", ["checkout", "--detach"], { cwd: repo.path });
-    await client.patchDaemonConfig({ pluginsEnabled: true });
-    await client.installDirectoryPlugin(example.directory);
-    const project = await openProjectViaDaemon(client, repo.path);
-    const other = otherRepo ? await openProjectViaDaemon(client, otherRepo.path) : null;
-    let target = project;
-    await gotoAppShell(page);
-    await waitForSidebarHydration(page);
-    await openNewWorkspaceComposer(page, project);
-    // The sidebar rows used to reach the screen exist only at desktop width.
-    if (options.compact) await page.setViewportSize(COMPACT);
-    await run({
-      chooseWorktree: () =>
-        test.step("choose a new worktree", async () => {
-          await page.getByTestId("workspace-create-isolation-trigger").click();
-          await page.getByTestId("workspace-create-isolation-worktree").click();
-        }),
-      chooseIssue: (label) =>
-        test.step(`choose the issue "${label}"`, async () => {
-          await page.getByRole("button", { name: "Issue", exact: true }).click();
-          await page.getByText(label, { exact: true }).click();
-        }),
-      firstProjectName: project.projectDisplayName,
-      openIssueList: () =>
-        test.step("open the Issue list", async () => {
-          await page.getByRole("button", { name: "Issue", exact: true }).click();
-        }),
-      closeIssueList: () => test.step("close the Issue list", () => page.keyboard.press("Escape")),
-      expectIssueListText: (text, shown) =>
-        test.step(`the Issue list ${shown ? "shows" : "does not show"} "${text}"`, async () => {
-          const list = page.getByTestId("combobox-desktop-container").last();
-          await expect(list.getByText(text, { exact: true })).toHaveCount(shown ? 1 : 0);
-        }),
-      switchToOtherProject: () =>
-        test.step("switch to the other project", async () => {
-          if (!other) throw new Error("Open the example with otherProject to switch projects");
-          await page.getByRole("button", { name: "Workspace project" }).click();
-          await page
-            .getByTestId("combobox-desktop-container")
-            .last()
-            .getByText(other.projectDisplayName, { exact: true })
-            .click();
-          await expect(page.getByRole("button", { name: "Workspace project" })).toContainText(
-            other.projectDisplayName,
-          );
-          target = other;
-        }),
-      expectIsolation: (isolation) =>
-        test.step(`the screen is on ${isolation}`, () =>
-          expectWorkspaceIsolationSelected(page, isolation)),
-      reopenWithoutPlugin: () =>
-        test.step("reopen the screen without the plugin", async () => {
-          await client.removePlugin(PLUGIN_ID);
-          // Leaving the screen drops its in-memory choice, so only the saved preference is left.
-          await page.goBack();
-          await expect(page.getByTestId("workspace-create-isolation-trigger")).toHaveCount(0);
-          await openNewWorkspaceComposer(page, project);
-          await expect(page.getByRole("button", { name: "Mount", exact: true })).toHaveCount(0);
-        }),
-      createWorkspace: (createOptions) =>
-        test.step("create the workspace and read what it carries", async () => {
-          await submitCreate(page, createOptions?.prompt);
-          const created = await assertNewWorkspaceSidebarAndHeader(page, {
-            serverId: getServerId(),
-            client,
-            previousWorkspaceId: target.workspaceId,
-            projectDisplayName: target.projectDisplayName,
-            // The sidebar is closed at compact width.
-            assertSidebarRow: !options.compact,
-          });
-          createdDirectory = created.workspaceDirectory;
-          return readCreatedWorkspace(client, created.workspaceId);
-        }),
-    });
-  } finally {
-    if (createdDirectory) {
-      await archiveWorkspaceFromDaemon(client, createdDirectory).catch(() => undefined);
-    }
-    await client.removePlugin(PLUGIN_ID).catch(() => undefined);
-    await client.patchDaemonConfig({ pluginsEnabled: previous.config.pluginsEnabled });
-    await client.close();
-    await example.cleanup();
-    await repo.cleanup();
-    await otherRepo?.cleanup();
-  }
-}

packages/app/e2e/support/helpers/workspace-setup.ts

@@ -1,3 +1,5 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
 import { realpathSync } from "node:fs";
 import { expect, type Page } from "@playwright/test";
 import type { DaemonClient as InternalDaemonClient } from "@getpaseo/client/internal/daemon-client";
@@ -380,3 +382,21 @@ export function observeSetupPanelTraffic(page: Page) {
 export function setupCommandOutput(detail: { commands: Array<{ log: string }> }): string {
   return detail.commands.map((command) => command.log).join("\n");
 }
+
+/** Hold this isolated daemon's terminal worker so script exit cannot race a layout change. */
+export async function pauseWorkspaceTerminalWorker(terminalId: string): Promise<() => void> {
+  const home = process.env.E2E_PASEO_HOME;
+  if (!home) throw new Error("Missing isolated E2E home");
+  const directory = path.join(home, "terminal-worker");
+  for (const name of await readdir(directory)) {
+    if (!name.endsWith(".json")) continue;
+    const record = JSON.parse(await readFile(path.join(directory, name), "utf8")) as {
+      pid: number;
+      terminals: Array<{ id: string }>;
+    };
+    if (!record.terminals.some((terminal) => terminal.id === terminalId)) continue;
+    process.kill(record.pid, "SIGSTOP");
+    return () => process.kill(record.pid, "SIGCONT");
+  }
+  throw new Error(`No isolated terminal worker owns ${terminalId}`);
+}

packages/app/modules/paseo-scroll/android/src/androidTest/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <application>
+    <!-- Hosts a scroll view in a real window, so layout clamps and draws run as they do on device. -->
+    <activity android:name="android.app.Activity" android:exported="false" />
+  </application>
+</manifest>

packages/app/modules/paseo-scroll/android/src/androidTest/java/sh/paseo/scroll/MountingReactContext.java

@@ -0,0 +1,77 @@
+package sh.paseo.scroll;
+
+import android.content.Context;
+import com.facebook.react.bridge.BridgeReactContext;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.bridge.UIManagerListener;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.uimanager.events.EventDispatcherProvider;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A React context with a running Fabric UIManager, so scroll views find the mount listener
+ * registry and event dispatcher the way they do in the app. The UIManager only records mount
+ * listeners and the dispatcher drops events; every other call returns a default. Java, because
+ * {@link EventDispatcherProvider} is internal to React Native's Kotlin module.
+ */
+final class MountingReactContext extends BridgeReactContext implements EventDispatcherProvider {
+  final List<UIManagerListener> mountListeners = new ArrayList<>();
+  final UIManager uiManager;
+  private final EventDispatcher eventDispatcher = inert(EventDispatcher.class, null);
+
+  MountingReactContext(Context base) {
+    super(base);
+    uiManager = inert(UIManager.class, this);
+  }
+
+  /** Runs one Fabric mount: listeners see willMountItems, then the change, then didMountItems. */
+  void mount(Runnable change) {
+    for (UIManagerListener listener : new ArrayList<>(mountListeners)) listener.willMountItems(uiManager);
+    change.run();
+    for (UIManagerListener listener : new ArrayList<>(mountListeners)) listener.didMountItems(uiManager);
+  }
+
+  @Override
+  public boolean hasActiveReactInstance() {
+    return true;
+  }
+
+  @Override
+  public UIManager getFabricUIManager() {
+    return uiManager;
+  }
+
+  @Override
+  public EventDispatcher getEventDispatcher() {
+    return eventDispatcher;
+  }
+
+  private static <T> T inert(Class<T> type, MountingReactContext owner) {
+    return type.cast(
+        Proxy.newProxyInstance(
+            type.getClassLoader(),
+            new Class<?>[] {type},
+            (proxy, method, args) -> {
+              switch (method.getName()) {
+                case "addUIManagerEventListener":
+                  owner.mountListeners.add((UIManagerListener) args[0]);
+                  return null;
+                case "removeUIManagerEventListener":
+                  owner.mountListeners.remove((UIManagerListener) args[0]);
+                  return null;
+                case "getEventDispatcher":
+                  return owner.eventDispatcher;
+                default:
+                  Class<?> result = method.getReturnType();
+                  if (result == boolean.class) return false;
+                  if (result == int.class) return 0;
+                  if (result == long.class) return 0L;
+                  if (result == float.class) return 0f;
+                  if (result == double.class) return 0.0;
+                  return null;
+              }
+            }));
+  }
+}

packages/app/modules/paseo-scroll/android/src/androidTest/java/sh/paseo/scroll/ScrollSelectionTest.kt

@@ -1,159 +0,0 @@
-package sh.paseo.scroll
-
-import android.graphics.Rect
-import android.text.Selection
-import android.text.Spannable
-import android.view.View
-import android.view.InputDevice
-import android.view.MotionEvent
-import android.os.SystemClock
-import android.widget.FrameLayout
-import android.widget.TextView
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import com.facebook.react.bridge.JavaOnlyArray
-import com.facebook.react.bridge.JavaOnlyMap
-import com.facebook.react.soloader.OpenSourceMergedSoMapping
-import com.facebook.react.uimanager.DisplayMetricsHolder
-import com.facebook.react.uimanager.ReactStylesDiffMap
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.views.scroll.ReactScrollView
-import com.facebook.react.views.scroll.ReactScrollViewManager
-import com.facebook.soloader.SoLoader
-import org.junit.Assert.*
-import org.junit.Test
-import org.junit.runner.RunWith
-
-@RunWith(AndroidJUnit4::class)
-class ScrollSelectionTest {
-  @Test fun mouseWheelMovesInvertedViewportInVisualDirection() = withScroll(inverted = true) { scroll, _ ->
-    val before = scroll.scrollY
-    withWheel(1f) { event ->
-      assertTrue(scroll.dispatchGenericMotionEvent(event))
-      assertTrue("Wheel up must move toward older messages: $before -> ${scroll.scrollY}", scroll.scrollY > before)
-      assertEquals("The caller's event must not change", 1f, event.getAxisValue(MotionEvent.AXIS_VSCROLL))
-    }
-    val afterUp = scroll.scrollY
-    withWheel(-1f) { event ->
-      assertTrue(scroll.dispatchGenericMotionEvent(event))
-      assertTrue("Wheel down must move toward newer messages: $afterUp -> ${scroll.scrollY}", scroll.scrollY < afterUp)
-    }
-  }
-
-  @Test fun mouseWheelKeepsOrdinaryScrollDirection() = withScroll(inverted = false) { scroll, _ ->
-    val before = scroll.scrollY
-    withWheel(1f) { event ->
-      assertTrue(scroll.dispatchGenericMotionEvent(event))
-      assertTrue(scroll.scrollY < before)
-    }
-    val afterUp = scroll.scrollY
-    withWheel(-1f) { event ->
-      assertTrue(scroll.dispatchGenericMotionEvent(event))
-      assertTrue(scroll.scrollY > afterUp)
-    }
-  }
-
-  @Test fun mouseWheelRespectsDisabledScrolling() = withScroll(inverted = true) { scroll, _ ->
-    scroll.setScrollEnabled(false)
-    val before = scroll.scrollY
-    withWheel(1f) { scroll.dispatchGenericMotionEvent(it) }
-    assertEquals(before, scroll.scrollY)
-  }
-
-  @Test fun focusingSelectableTextKeepsInvertedViewportStill() = withScroll(inverted = true) { scroll, text ->
-    val before = scroll.scrollY
-    assertTrue(text.requestFocus())
-    assertSame(text, scroll.findFocus())
-    assertEquals("Text focus must not move the inverted viewport", before, scroll.scrollY)
-    assertTrue(text.isTextSelectable)
-  }
-
-  @Test fun selectingTextKeepsInvertedViewportStill() = withScroll(inverted = true) { scroll, text ->
-    val before = scroll.scrollY
-    Selection.setSelection(text.text as Spannable, 0, 8)
-    text.requestRectangleOnScreen(Rect(0, 0, 80, 40), true)
-    assertEquals("Selection visibility requests must not move the inverted viewport", before, scroll.scrollY)
-    assertEquals("Selectab", text.text.subSequence(text.selectionStart, text.selectionEnd).toString())
-  }
-
-  @Test fun explicitScrollCommandsStillMoveInvertedViewport() = withScroll(inverted = true) { scroll, _ ->
-    scroll.scrollTo(0, 600)
-    assertEquals(600, scroll.scrollY)
-  }
-
-  @Test fun ordinaryScrollViewsStillRevealSelectedText() = withScroll(inverted = false) { scroll, text ->
-    val before = scroll.scrollY
-    text.requestRectangleOnScreen(Rect(0, 0, 80, 40), true)
-    assertNotEquals(before, scroll.scrollY)
-  }
-
-  @Test fun verticalScaleStillKeepsFocusAndSelectionInPlace() = withScroll(inverted = true, transform = "scaleY") { scroll, text ->
-    val before = scroll.scrollY
-    assertTrue(text.requestFocus())
-    text.requestRectangleOnScreen(Rect(0, 0, 80, 40), true)
-    assertEquals(before, scroll.scrollY)
-  }
-
-  @Test fun horizontalScaleStillRevealsSelectedText() = withScroll(inverted = true, transform = "scaleX") { scroll, text ->
-    val before = scroll.scrollY
-    text.requestRectangleOnScreen(Rect(0, 0, 80, 40), true)
-    assertNotEquals(before, scroll.scrollY)
-  }
-
-  private fun withScroll(inverted: Boolean, transform: String = "scale", check: (ReactScrollView, TextView) -> Unit) {
-    val instrumentation = InstrumentationRegistry.getInstrumentation()
-    instrumentation.runOnMainSync {
-      val appContext = instrumentation.targetContext
-      DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(appContext)
-      SoLoader.init(appContext, OpenSourceMergedSoMapping)
-      val reactContext = ScrollTestContext(appContext)
-      val context = ThemedReactContext(reactContext, appContext)
-      val manager = PaseoScrollPackage().createViewManager(reactContext, ReactScrollViewManager.REACT_CLASS) as ReactScrollViewManager
-      val scroll = manager.createViewInstance(context)
-      val content = FrameLayout(context)
-      val text = TextView(context).apply {
-        setText("Selectable timeline text", TextView.BufferType.SPANNABLE)
-        setTextIsSelectable(true)
-      }
-      content.addView(text, FrameLayout.LayoutParams(300, 100).apply { topMargin = 1400 })
-      scroll.addView(content)
-      content.measure(exact(300), exact(2000))
-      content.layout(0, 0, 300, 2000)
-      scroll.measure(exact(300), exact(300))
-      scroll.layout(0, 0, 300, 300)
-      // Apply RN's actual Android inversion through the manager's transform decomposition.
-      val transforms = JavaOnlyArray.of(JavaOnlyMap.of(transform, if (inverted) -1.0 else 1.0))
-      manager.updateProperties(scroll, ReactStylesDiffMap(JavaOnlyMap.of("transform", transforms)))
-      if (inverted && transform == "scale") {
-        assertEquals(1f, scroll.scaleY, 0f)
-        assertEquals(180f, kotlin.math.abs(scroll.rotation), 0f)
-      }
-      scroll.scrollTo(0, 400)
-      check(scroll, text)
-    }
-  }
-
-  private fun exact(size: Int) = View.MeasureSpec.makeMeasureSpec(size, View.MeasureSpec.EXACTLY)
-
-  private fun withWheel(axis: Float, check: (MotionEvent) -> Unit) {
-    val time = SystemClock.uptimeMillis()
-    val properties = MotionEvent.PointerProperties().apply {
-      id = 0
-      toolType = MotionEvent.TOOL_TYPE_MOUSE
-    }
-    val coordinates = MotionEvent.PointerCoords().apply {
-      x = 150f
-      y = 150f
-      setAxisValue(MotionEvent.AXIS_VSCROLL, axis)
-    }
-    val event = MotionEvent.obtain(
-      time, time, MotionEvent.ACTION_SCROLL, 1, arrayOf(properties), arrayOf(coordinates),
-      0, 0, 1f, 1f, 0, 0, InputDevice.SOURCE_MOUSE, 0,
-    )
-    try {
-      check(event)
-    } finally {
-      event.recycle()
-    }
-  }
-}

packages/app/modules/paseo-scroll/android/src/androidTest/java/sh/paseo/scroll/ScrollTestContext.java

@@ -1,19 +0,0 @@
-package sh.paseo.scroll;
-
-import android.content.Context;
-import com.facebook.react.bridge.BridgeReactContext;
-import com.facebook.react.uimanager.events.BlackHoleEventDispatcher;
-import com.facebook.react.uimanager.events.EventDispatcher;
-import com.facebook.react.uimanager.events.EventDispatcherProvider;
-
-/** Native-only tests use RN's dispatcher for a context without a JS instance. */
-final class ScrollTestContext extends BridgeReactContext implements EventDispatcherProvider {
-  ScrollTestContext(Context context) {
-    super(context);
-  }
-
-  @Override
-  public EventDispatcher getEventDispatcher() {
-    return BlackHoleEventDispatcher.INSTANCE;
-  }
-}

packages/app/modules/paseo-scroll/android/src/androidTest/java/sh/paseo/scroll/VisibleContentPositionClampTest.kt

@@ -0,0 +1,271 @@
+package sh.paseo.scroll
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.graphics.Canvas
+import android.os.SystemClock
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.soloader.OpenSourceMergedSoMapping
+import com.facebook.react.uimanager.DisplayMetricsHolder
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.views.scroll.ReactScrollView
+import com.facebook.react.views.scroll.ReactScrollViewManager
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.soloader.SoLoader
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * A Fabric mount that shrinks the content of a scroll view with `maintainVisibleContentPosition`
+ * set. The mount runs through React Native's real position keeper, driven by the same
+ * willMountItems/didMountItems calls Fabric makes, inside a real window so layout clamps and draws
+ * happen as they do on a device.
+ */
+@RunWith(AndroidJUnit4::class)
+class VisibleContentPositionClampTest {
+  private val instrumentation = InstrumentationRegistry.getInstrumentation()
+  private var activity: Activity? = null
+
+  @After fun finish() {
+    activity?.finish()
+  }
+
+  @Test fun shrinkAtTheEndLandsAtTheNewEnd() {
+    val timeline = openTimeline(anchor = Anchor.END)
+
+    timeline.shrinkInOneMount()
+
+    assertEquals("Offset after the mount", NEW_END, timeline.scrollY())
+    assertEquals("Offset in the first frame drawn after the mount", NEW_END, timeline.firstDrawnScrollY())
+  }
+
+  @Test fun shrinkBelowAnUnmovedAnchorIsClampedBeforeTheFrameDraws() {
+    val timeline = openTimeline(anchor = Anchor.TOP_ROW)
+
+    timeline.shrinkInOneMount()
+
+    assertEquals("Offset in the first frame drawn after the mount", NEW_END, timeline.firstDrawnScrollY())
+    assertEquals("Offset after the mount", NEW_END, timeline.scrollY())
+  }
+
+  @Test fun shrinkDuringATouchDragLeavesNoOffsetPastTheEnd() {
+    val timeline = openTimeline(anchor = Anchor.TOP_ROW)
+
+    timeline.beginDrag()
+    assertTrue("The drag owns the viewport", timeline.scrollY() < CONTENT_HEIGHT - VIEWPORT)
+    timeline.shrinkInOneMount()
+    val drawn = timeline.firstDrawnScrollY()
+    timeline.endDrag()
+    val settled = timeline.settledScrollY()
+
+    assertTrue("Offset $drawn drawn past the end $NEW_END", drawn <= NEW_END)
+    assertTrue("Offset $settled settled past the end $NEW_END", settled <= NEW_END)
+    timeline.awaitFrames(10)
+    assertEquals("Offset kept moving after the drag ended", settled, timeline.scrollY())
+  }
+
+  @Test fun growthAtTheEndFollowsWithoutATouch() {
+    val timeline = openTimeline(anchor = Anchor.END)
+
+    timeline.growInOneMount()
+
+    assertEquals("Offset after the mount", CONTENT_HEIGHT + GROWTH - VIEWPORT, timeline.scrollY())
+  }
+
+  // The drag begins before JS stops following and removes the pin, so a line mounting in the drag's
+  // first frames must not scroll the rows the finger is on.
+  @Test fun growthAtTheEndDuringATouchDragKeepsTheRowsUnderTheFinger() {
+    val timeline = openTimeline(anchor = Anchor.END)
+
+    timeline.beginDrag()
+    val dragged = timeline.scrollY()
+    assertTrue("The drag owns the viewport", dragged < CONTENT_HEIGHT - VIEWPORT)
+    timeline.growInOneMount()
+
+    assertEquals("Offset after the mount", dragged, timeline.scrollY())
+    assertEquals("Offset in the first frame drawn after the mount", dragged, timeline.firstDrawnScrollY())
+    timeline.endDrag()
+  }
+
+  private enum class Anchor {
+    /** A zero-height view at the bottom of the content, first child: the end pin. */
+    END,
+    /** A row at the top of the content that reaches into the viewport and does not move. */
+    TOP_ROW,
+  }
+
+  private inner class Timeline(
+    val scroll: ReactScrollView,
+    private val content: ReactViewGroup,
+    private val endPin: View,
+    private val probe: DrawProbe,
+    private val reactContext: MountingReactContext,
+  ) {
+    private var dragY = 0f
+    private var downTime = 0L
+
+    fun scrollY(): Int {
+      var y = 0
+      instrumentation.runOnMainSync { y = scroll.scrollY }
+      return y
+    }
+
+    fun shrinkInOneMount() = resizeInOneMount(CONTENT_HEIGHT - SHRINK)
+
+    fun growInOneMount() = resizeInOneMount(CONTENT_HEIGHT + GROWTH)
+
+    private fun resizeInOneMount(height: Int) {
+      instrumentation.runOnMainSync {
+        probe.drawnScrollY.clear()
+        reactContext.mount { layoutContent(height) }
+        probe.invalidate()
+      }
+    }
+
+    fun firstDrawnScrollY(): Int {
+      val deadline = SystemClock.uptimeMillis() + 2000
+      while (SystemClock.uptimeMillis() < deadline) {
+        instrumentation.waitForIdleSync()
+        var drawn: Int? = null
+        instrumentation.runOnMainSync { drawn = probe.drawnScrollY.firstOrNull() }
+        drawn?.let { return it }
+        SystemClock.sleep(16)
+      }
+      throw AssertionError("No frame was drawn after the mount")
+    }
+
+    fun beginDrag() {
+      downTime = SystemClock.uptimeMillis()
+      dragY = 300f
+      touch(MotionEvent.ACTION_DOWN)
+      // Finger moves down, so the content scrolls up from the end and the drag owns the viewport.
+      repeat(6) {
+        dragY += 12f
+        touch(MotionEvent.ACTION_MOVE)
+      }
+    }
+
+    fun endDrag() {
+      dragY += 4f
+      touch(MotionEvent.ACTION_MOVE)
+      touch(MotionEvent.ACTION_UP)
+    }
+
+    fun settledScrollY(): Int {
+      var previous = scrollY()
+      repeat(60) {
+        awaitFrames(2)
+        val current = scrollY()
+        if (current == previous) return current
+        previous = current
+      }
+      throw AssertionError("Offset never settled")
+    }
+
+    fun awaitFrames(count: Int) {
+      repeat(count) {
+        instrumentation.waitForIdleSync()
+        SystemClock.sleep(16)
+      }
+    }
+
+    fun layoutContent(height: Int) {
+      content.layout(0, 0, WIDTH, height)
+      endPin.layout(0, height, 0, height)
+    }
+
+    private fun touch(action: Int) {
+      instrumentation.runOnMainSync {
+        val event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), action, WIDTH / 2f, dragY, 0)
+        scroll.dispatchTouchEvent(event)
+        event.recycle()
+      }
+    }
+  }
+
+  /** The React surface root a scroll view reports its native gestures to. */
+  private class SurfaceRoot(context: Context) : FrameLayout(context), RootView {
+    override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {}
+
+    override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {}
+
+    override fun handleException(t: Throwable) {
+      throw t
+    }
+  }
+
+  private class DrawProbe(context: Context) : View(context) {
+    val drawnScrollY = mutableListOf<Int>()
+
+    override fun onDraw(canvas: Canvas) {
+      drawnScrollY += (parent.parent as View).scrollY
+    }
+  }
+
+  private fun openTimeline(anchor: Anchor): Timeline {
+    val started =
+      instrumentation.startActivitySync(
+        Intent(instrumentation.targetContext, Activity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      )
+    activity = started
+    lateinit var timeline: Timeline
+    instrumentation.runOnMainSync {
+      DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(started)
+      SoLoader.init(started, OpenSourceMergedSoMapping)
+      val reactContext = MountingReactContext(started.applicationContext)
+      val context = ThemedReactContext(reactContext, started)
+      val manager =
+        PaseoScrollPackage().createViewManager(reactContext, ReactScrollViewManager.REACT_CLASS)
+          as ReactScrollViewManager
+      val scroll = manager.createViewInstance(context)
+      val content = ReactViewGroup(context)
+      val endPin = View(context).apply { setTag(com.facebook.react.R.id.view_tag_native_id, END_PIN_NATIVE_ID) }
+      val probe = DrawProbe(context)
+      if (anchor == Anchor.END) {
+        content.addView(endPin)
+        content.addView(probe)
+      } else {
+        content.addView(probe)
+        content.addView(endPin)
+      }
+      scroll.addView(content)
+      manager.updateProperties(
+        scroll,
+        ReactStylesDiffMap(
+          JavaOnlyMap.of("maintainVisibleContentPosition", JavaOnlyMap.of("minIndexForVisible", 0))
+        ),
+      )
+      started.setContentView(SurfaceRoot(started).apply { addView(scroll, FrameLayout.LayoutParams(WIDTH, VIEWPORT)) })
+      timeline = Timeline(scroll, content, endPin, probe, reactContext)
+      timeline.layoutContent(CONTENT_HEIGHT)
+      probe.layout(0, 0, WIDTH, PROBE_HEIGHT)
+    }
+    timeline.awaitFrames(2)
+    instrumentation.runOnMainSync { timeline.scroll.scrollTo(0, CONTENT_HEIGHT - VIEWPORT) }
+    timeline.awaitFrames(2)
+    assertEquals("Starts at the end", CONTENT_HEIGHT - VIEWPORT, timeline.scrollY())
+    return timeline
+  }
+
+  private companion object {
+    const val WIDTH = 300
+    const val VIEWPORT = 600
+    const val CONTENT_HEIGHT = 1000
+    const val SHRINK = 240
+    const val GROWTH = 120
+    const val END_PIN_NATIVE_ID = "paseo-end-pin"
+    const val NEW_END = CONTENT_HEIGHT - SHRINK - VIEWPORT
+    const val PROBE_HEIGHT = 700
+  }
+}

packages/app/modules/paseo-scroll/android/src/main/java/sh/paseo/scroll/PaseoScrollPackage.kt

@@ -1,9 +1,5 @@
 package sh.paseo.scroll
 
-import android.graphics.Matrix
-import android.graphics.Rect
-import android.view.InputDevice
-import android.view.MotionEvent
 import com.facebook.react.ReactPackage
 import com.facebook.react.ViewManagerOnDemandReactPackage
 import com.facebook.react.bridge.NativeModule
@@ -28,51 +24,3 @@ private class PaseoScrollViewManager : ReactScrollViewManager() {
   override fun createViewInstance(context: ThemedReactContext): ReactScrollView =
     PaseoScrollView(context)
 }
-
-private class PaseoScrollView(context: ThemedReactContext) : ReactScrollView(context) {
-  private val transformValues = FloatArray(9)
-
-  private fun isVerticallyInverted(): Boolean {
-    // Android FlatList uses scale: -1, which RN decomposes into a 180-degree
-    // rotation with positive scaleY. Read the resulting transform, not scaleY.
-    matrix.getValues(transformValues)
-    return transformValues[Matrix.MSCALE_Y] < 0
-  }
-
-  override fun onGenericMotionEvent(event: MotionEvent): Boolean {
-    if (!isVerticallyInverted() || event.actionMasked != MotionEvent.ACTION_SCROLL ||
-        !event.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
-      return super.onGenericMotionEvent(event)
-    }
-    if (!scrollEnabled) return false
-
-    // Android applies wheel axes directly to scrollY; the inversion transform only
-    // transforms pointer coordinates. Reverse the vertical axis before delegating so
-    // platform scroll bounds and scroll events still apply.
-    val properties = Array(event.pointerCount) { index ->
-      MotionEvent.PointerProperties().also { event.getPointerProperties(index, it) }
-    }
-    val coordinates = Array(event.pointerCount) { index ->
-      MotionEvent.PointerCoords().also {
-        event.getPointerCoords(index, it)
-        it.setAxisValue(MotionEvent.AXIS_VSCROLL, -it.getAxisValue(MotionEvent.AXIS_VSCROLL))
-      }
-    }
-    val correctedEvent = MotionEvent.obtain(
-      event.downTime, event.eventTime, event.action, event.pointerCount, properties, coordinates,
-      event.metaState, event.buttonState, event.xPrecision, event.yPrecision,
-      event.deviceId, event.edgeFlags, event.source, event.flags,
-    )
-    return try {
-      super.onGenericMotionEvent(correctedEvent)
-    } finally {
-      correctedEvent.recycle()
-    }
-  }
-
-  // Both RN focus handling and Android selection visibility requests use this calculation.
-  // Its coordinates ignore inversion. Keep focus/selection bookkeeping, but leave timeline
-  // movement to user gestures and explicit scroll commands.
-  override fun computeScrollDeltaToGetChildRectOnScreen(rect: Rect): Int =
-    if (isVerticallyInverted()) 0 else super.computeScrollDeltaToGetChildRectOnScreen(rect)
-}

packages/app/modules/paseo-scroll/android/src/main/java/sh/paseo/scroll/PaseoScrollView.java

@@ -0,0 +1,142 @@
+package sh.paseo.scroll;
+
+import android.content.Context;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import androidx.annotation.Nullable;
+import com.facebook.react.R;
+import com.facebook.react.views.scroll.MaintainVisibleScrollPositionHelper;
+import com.facebook.react.views.scroll.ReactScrollView;
+import com.facebook.react.views.scroll.ReactScrollViewHelper;
+
+/**
+ * React Native's vertical scroll view with two corrections. Java, because the content-position
+ * config type is internal to React Native's Kotlin module.
+ */
+final class PaseoScrollView extends ReactScrollView {
+  // The chat timeline's end pin, packages/app/src/agent-stream/native-end-pin.tsx.
+  private static final String END_PIN_NATIVE_ID = "paseo-end-pin";
+
+  private final ViewTreeObserver.OnPreDrawListener clampBeforeDraw =
+      () -> {
+        clampToContentEnd();
+        return true;
+      };
+  private @Nullable MaintainVisibleScrollPositionHelper.Config visibleContentPosition = null;
+  private boolean isClampPending = false;
+  private boolean isUserDragging = false;
+
+  PaseoScrollView(Context context) {
+    super(context);
+  }
+
+  @Override
+  public void setMaintainVisibleContentPosition(
+      @Nullable MaintainVisibleScrollPositionHelper.Config config) {
+    super.setMaintainVisibleContentPosition(config);
+    visibleContentPosition = config;
+  }
+
+  // While the timeline follows its end, its end pin anchors the content position, so every line that
+  // mounts scrolls the content by its height. A drag owns the offset from the frame it begins, and
+  // JS removes the pin only a round trip later. While the user drags, the correction for the pin is
+  // skipped, so the line grows below the rows under the finger. iOS's PaseoScrollViewComponentView
+  // does the same.
+  // MaintainVisibleScrollPositionHelper is the only caller: it moves the offset by its anchor's move.
+  @Override
+  public void scrollToPreservingMomentum(int x, int y) {
+    if (isUserDragging && isEndPinTheAnchor()) return;
+    super.scrollToPreservingMomentum(x, y);
+  }
+
+  // The drag begins where React Native emits onScrollBeginDrag.
+  @Override
+  protected void handleInterceptedTouchEvent(MotionEvent ev) {
+    super.handleInterceptedTouchEvent(ev);
+    isUserDragging = true;
+  }
+
+  @Override
+  public boolean onTouchEvent(MotionEvent ev) {
+    boolean handled = super.onTouchEvent(ev);
+    int action = ev.getActionMasked();
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+      isUserDragging = false;
+    }
+    return handled;
+  }
+
+  // The helper anchors on the first content child from minIndexForVisible that reaches into the
+  // viewport. The pin is the first child and sits at the bottom of the content, so it always does.
+  private boolean isEndPinTheAnchor() {
+    if (visibleContentPosition == null || visibleContentPosition.getMinIndexForVisible() != 0) {
+      return false;
+    }
+    View content = getChildAt(0);
+    if (!(content instanceof ViewGroup) || ((ViewGroup) content).getChildCount() == 0) return false;
+    Object nativeId = ((ViewGroup) content).getChildAt(0).getTag(R.id.view_tag_native_id);
+    return END_PIN_NATIVE_ID.equals(nativeId);
+  }
+
+  // With maintainVisibleContentPosition set, a mount that shrinks the content past the offset would
+  // apply the shrink twice:
+  // 1. MaintainVisibleScrollPositionHelper.willMountItems records the anchor's frame.
+  // 2. The mount lays out the shorter content, and ReactScrollView.onLayoutChange clamps the offset
+  //    to the new end.
+  // 3. MaintainVisibleScrollPositionHelper.didMountItems adds the anchor's move to the clamped
+  //    offset, so the shrink moves the offset a second time (to the top, for a shrink at the end).
+  // The clamp waits for the pre-draw pass instead, which runs after didMountItems and before the
+  // frame draws: the anchor's move applies to the offset the content had before the mount, and the
+  // clamp only catches what the anchor did not account for.
+  // https://github.com/react/react-native/issues/58578 tracks it; remove this override once
+  // https://github.com/react/react-native/pull/58695 ships in the React Native version we use.
+  @Override
+  public void onLayoutChange(
+      View v,
+      int left,
+      int top,
+      int right,
+      int bottom,
+      int oldLeft,
+      int oldTop,
+      int oldRight,
+      int oldBottom) {
+    if (visibleContentPosition == null) {
+      super.onLayoutChange(v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom);
+      return;
+    }
+    if (!isClampPending) {
+      isClampPending = true;
+      getViewTreeObserver().addOnPreDrawListener(clampBeforeDraw);
+    }
+    ReactScrollViewHelper.emitLayoutChangeEvent(this);
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    cancelPendingClamp();
+    isUserDragging = false;
+    super.onDetachedFromWindow();
+  }
+
+  private void clampToContentEnd() {
+    cancelPendingClamp();
+    View content = getChildAt(0);
+    if (content == null || content.getWidth() == 0 || content.getHeight() == 0 || !isShown()) {
+      return;
+    }
+    int viewportHeight = getHeight() - getPaddingTop() - getPaddingBottom();
+    int maxScrollY = Math.max(0, content.getHeight() - viewportHeight);
+    if (getScrollY() > maxScrollY) {
+      scrollTo(getScrollX(), maxScrollY);
+    }
+  }
+
+  private void cancelPendingClamp() {
+    if (!isClampPending) return;
+    isClampPending = false;
+    getViewTreeObserver().removeOnPreDrawListener(clampBeforeDraw);
+  }
+}

packages/app/modules/paseo-scroll/expo-module.config.json

@@ -1 +1 @@
-{ "platforms": ["android"], "android": { "modules": [] } }
+{ "platforms": ["android", "ios"], "android": { "modules": [] }, "ios": { "modules": [] } }

packages/app/modules/paseo-scroll/ios/PaseoScroll.podspec

@@ -0,0 +1,16 @@
+Pod::Spec.new do |s|
+  s.name           = 'PaseoScroll'
+  s.version        = '0.1.0'
+  s.summary        = 'Scroll view corrections for Paseo'
+  s.description    = 'Scroll view corrections for Paseo'
+  s.license        = 'Apache-2.0'
+  s.author         = 'Paseo'
+  s.homepage       = 'https://paseo.sh'
+  s.platforms      = { :ios => '15.1' }
+  s.source         = { :path => '.' }
+  s.static_framework = true
+
+  s.source_files = "**/*.{h,mm}"
+
+  install_modules_dependencies(s)
+end

packages/app/modules/paseo-scroll/ios/PaseoScrollViewComponentView.mm

@@ -0,0 +1,148 @@
+#import <React/RCTComponentViewFactory.h>
+#import <React/RCTCustomPullToRefreshViewProtocol.h>
+#import <React/RCTScrollViewComponentView.h>
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/scrollview/ScrollViewProps.h>
+#import <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+
+using namespace facebook::react;
+
+/**
+ * React Native's scroll view with three maintainVisibleContentPosition corrections.
+ *
+ * An anchor removed by the mount it anchors. React Native picks the anchor before the mount and
+ * moves the offset by the anchor's movement after it. When the mount removes that view, its frame
+ * after the mount no longer describes the content, and the offset jumps by an unrelated amount.
+ * Android keeps a removed view's last frame, so it keeps the offset. This class keeps the offset on
+ * iOS too.
+ * The chat timeline hits this when it stops following its end: the same mount removes the end pin
+ * and opens the disclosure the reader tapped.
+ * React Native 0.88 skips the adjustment for a removed anchor
+ * (https://github.com/react/react-native/pull/57294). Its view-registry tag check matches the check
+ * here; its superview check also skips anchors that removeClippedSubviews detached
+ * (https://github.com/react/react-native/issues/58910). Remove this part once the installed React
+ * Native includes the tag check.
+ *
+ * The chat timeline's end pin during a drag. While the timeline follows its end, a zero-height view
+ * at the bottom of the content (native ID "paseo-end-pin", packages/app/src/agent-stream/
+ * native-end-pin.tsx) is the anchor, so every line that mounts scrolls the content by its height.
+ * A drag owns the offset from the frame it begins, and JS removes the pin only a round trip later.
+ * While the user drags, a mount anchored on the pin keeps the offset, so the line grows below the
+ * rows under the finger. Android's PaseoScrollView does the same.
+ *
+ * A shrink at the end. A mount that shrinks the content sets the smaller contentSize, and UIKit
+ * clamps contentOffset to the new end. React Native then adds the anchor's movement to the clamped
+ * offset, so the shrink is applied twice and the viewport lands above the content it kept.
+ * The chat timeline hits this when a finished turn folds while the end pin follows the latest row.
+ * https://github.com/react/react-native/issues/58578
+ * Remove once https://github.com/react/react-native/pull/58695 ships; it keeps the pre-mount
+ * offset and clamps after the adjustment, as this class does.
+ */
+@interface PaseoScrollViewComponentView : RCTScrollViewComponentView
+@end
+
+@implementation PaseoScrollViewComponentView {
+  CGPoint _offsetBeforeMount;
+  __weak UIView *_anchorBeforeMount;
+  NSInteger _anchorTagBeforeMount;
+}
+
+// Replaces React Native's class for the ScrollView component. The factory looks a component up the
+// first time it mounts, so the registration has to come before the first surface.
++ (void)load
+{
+  [[RCTComponentViewFactory currentComponentViewFactory] registerComponentViewClass:self];
+}
+
+- (void)mountingTransactionWillMount:(const MountingTransaction &)transaction
+                withSurfaceTelemetry:(const SurfaceTelemetry &)surfaceTelemetry
+{
+  _offsetBeforeMount = self.scrollView.contentOffset;
+  _anchorBeforeMount = [self visibleContentAnchor];
+  _anchorTagBeforeMount = _anchorBeforeMount.tag;
+  [super mountingTransactionWillMount:transaction withSurfaceTelemetry:surfaceTelemetry];
+}
+
+- (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
+               withSurfaceTelemetry:(const SurfaceTelemetry &)surfaceTelemetry
+{
+  // The view registry sets a removed view's tag to 0; a released view reads nil here.
+  BOOL isAnchorRemoved = _anchorTagBeforeMount != 0 && _anchorBeforeMount.tag != _anchorTagBeforeMount;
+  if (isAnchorRemoved || (self.scrollView.isDragging && [self isEndPin:_anchorBeforeMount])) {
+    // Without the content-position props, React Native's mount completes without moving the offset.
+    SharedViewProps props = _props;
+    _props = ScrollViewShadowNode::defaultSharedProps();
+    [super mountingTransactionDidMount:transaction withSurfaceTelemetry:surfaceTelemetry];
+    _props = props;
+    return;
+  }
+  if (![self didClampOffsetDuringMount]) {
+    [super mountingTransactionDidMount:transaction withSurfaceTelemetry:surfaceTelemetry];
+    return;
+  }
+  UIScrollView *scrollView = self.scrollView;
+  scrollView.contentOffset = _offsetBeforeMount;
+  [super mountingTransactionDidMount:transaction withSurfaceTelemetry:surfaceTelemetry];
+  CGFloat y = MAX(MIN(scrollView.contentOffset.y, [self maxOffsetY]), -scrollView.adjustedContentInset.top);
+  if (y != scrollView.contentOffset.y) {
+    scrollView.contentOffset = CGPointMake(scrollView.contentOffset.x, y);
+  }
+}
+
+// UIKit moved the offset to the new end while the mount set a smaller contentSize. A user scroll
+// never gets here: React Native keeps the offset through contentSize changes while the user scrolls.
+- (BOOL)didClampOffsetDuringMount
+{
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
+  if (!props.maintainVisibleContentPosition) {
+    return NO;
+  }
+  CGFloat y = self.scrollView.contentOffset.y;
+  return y < _offsetBeforeMount.y - 0.5 && ABS(y - [self maxOffsetY]) <= 0.5;
+}
+
+// The view React Native anchors on for vertical content: the first content child from
+// minIndexForVisible that reaches into the viewport, or the last one.
+- (UIView *)visibleContentAnchor
+{
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
+  UIScrollView *scrollView = self.scrollView;
+  if (!props.maintainVisibleContentPosition || scrollView.contentSize.width > self.frame.size.width) {
+    return nil;
+  }
+  NSArray<UIView *> *children = [self contentView].subviews;
+  NSUInteger first = props.maintainVisibleContentPosition.value().minIndexForVisible;
+  for (NSUInteger index = first; index < children.count; ++index) {
+    UIView *child = children[index];
+    if (CGRectGetMaxY(child.frame) > scrollView.contentOffset.y || index == children.count - 1) {
+      return child;
+    }
+  }
+  return nil;
+}
+
+- (BOOL)isEndPin:(UIView *)view
+{
+  return [view isKindOfClass:[RCTViewComponentView class]] &&
+      [((RCTViewComponentView *)view).nativeId isEqualToString:@"paseo-end-pin"];
+}
+
+- (UIView *)contentView
+{
+  for (UIView *child in self.containerView.subviews) {
+    if (![child conformsToProtocol:@protocol(RCTCustomPullToRefreshViewProtocol)]) {
+      return child;
+    }
+  }
+  return nil;
+}
+
+- (CGFloat)maxOffsetY
+{
+  UIScrollView *scrollView = self.scrollView;
+  return MAX(
+      scrollView.contentSize.height - scrollView.bounds.size.height + scrollView.adjustedContentInset.bottom,
+      -scrollView.adjustedContentInset.top);
+}
+
+@end

packages/app/modules/paseo-window-layout/expo-module.config.json

@@ -0,0 +1,4 @@
+{
+  "platforms": ["ios"],
+  "ios": { "modules": ["PaseoWindowLayoutModule"] }
+}

packages/app/modules/paseo-window-layout/ios/PaseoWindowLayout.podspec

@@ -0,0 +1,15 @@
+Pod::Spec.new do |s|
+  s.name = 'PaseoWindowLayout'
+  s.version = '0.1.0'
+  s.summary = 'System window layout geometry for Paseo'
+  s.description = 'Publishes system bar and division geometry'
+  s.license = 'Apache-2.0'
+  s.author = 'Paseo'
+  s.homepage = 'https://paseo.sh'
+  s.platforms = { :ios => '16.4' }
+  s.swift_version = '5.4'
+  s.source = { :path => '.' }
+  s.static_framework = true
+  s.dependency 'ExpoModulesCore'
+  s.source_files = '**/*.swift'
+end

packages/app/modules/paseo-window-layout/ios/PaseoWindowLayoutModule.swift

@@ -0,0 +1,110 @@
+import ExpoModulesCore
+import UIKit
+
+public final class PaseoWindowLayoutModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("PaseoWindowLayout")
+    View(WindowLayoutView.self) {
+      Events("onGeometryChange")
+    }
+  }
+}
+
+final class WindowLayoutView: ExpoView {
+  let onGeometryChange = EventDispatcher()
+  private var updateScheduled = false
+  private var previousPayload: [String: Any]?
+  private var divisions: [CGRect] = []
+  private var barGuide: UILayoutGuide?
+  private var barEdge = "none"
+  private var measuredBounds = CGRect.zero
+
+  required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    isUserInteractionEnabled = false
+    #if compiler(>=6.4)
+    if #available(iOS 27.1, *) {
+      registerForTraitChanges(UITraitCollection.systemTraitsAffectingVerticalBarEdge) {
+        (view: WindowLayoutView, _) in
+        view.setNeedsUpdateConstraints()
+        view.scheduleUpdate()
+      }
+    }
+    #endif
+  }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    previousPayload = nil
+    setNeedsUpdateConstraints()
+    scheduleUpdate()
+  }
+
+  override func safeAreaInsetsDidChange() {
+    super.safeAreaInsetsDidChange()
+    setNeedsUpdateConstraints()
+    scheduleUpdate()
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    if bounds != measuredBounds {
+      measuredBounds = bounds
+      setNeedsUpdateConstraints()
+    }
+    scheduleUpdate()
+  }
+
+  override func updateConstraints() {
+    #if compiler(>=6.4)
+    if #available(iOS 27.1, *) {
+      // UIKit tracks these reads and invalidates constraints when regions change.
+      divisions = reservedRegions(kind: .division).compactMap { $0.isActive ? $0.frame : nil }
+      let edge: String
+      switch traitCollection.verticalBarEdge {
+      case .leading: edge = "leading"
+      case .trailing: edge = "trailing"
+      default: edge = "none"
+      }
+      if edge != barEdge {
+        barEdge = edge
+        barGuide = edge == "none" ? nil : layoutGuide(
+          for: .bar(onEdge: edge == "trailing" ? .right : .left, extent: 44)
+        )
+      }
+    }
+    #endif
+    super.updateConstraints()
+    scheduleUpdate()
+  }
+
+  private func scheduleUpdate() {
+    guard !updateScheduled else { return }
+    updateScheduled = true
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      self.updateScheduled = false
+      self.publish()
+    }
+  }
+
+  private func publish() {
+    guard window != nil, bounds.width > 0, bounds.height > 0 else { return }
+    let bar = barGuide?.layoutFrame
+    var barPayload: Any = NSNull()
+    if let bar, bar.width > 0, bar.height > 0 { barPayload = rect(bar) }
+    let payload: [String: Any] = [
+      "bounds": rect(bounds),
+      "verticalBarEdge": barEdge,
+      "verticalBar": barPayload,
+      "divisions": divisions.map(rect)
+    ]
+    guard !NSDictionary(dictionary: payload).isEqual(to: previousPayload ?? [:]) else { return }
+    previousPayload = payload
+    onGeometryChange(payload)
+  }
+
+  private func rect(_ frame: CGRect) -> [String: CGFloat] {
+    ["x": frame.minX, "y": frame.minY, "width": frame.width, "height": frame.height]
+  }
+}

packages/app/package.json

@@ -59,6 +59,7 @@
     "@getpaseo/protocol": "*",
     "@gorhom/bottom-sheet": "^5.2.14",
     "@gorhom/portal": "^1.0.14",
+    "@legendapp/list": "^3.7.1",
     "@marijn/find-cluster-break": "^1.0.2",
     "@mattermost/react-native-paste-input": "2.0.1",
     "@react-native-async-storage/async-storage": "2.2.0",

packages/app/src/agent-commands/cache/index.ts

@@ -18,7 +18,7 @@ export interface AgentCommandsDraftConfig {
   modeId?: string;
   model?: string;
   thinkingOptionId?: string;
-  providerOptions?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
 }
 
 export function normalizeAgentCommandsCwd(cwd: string): string {
@@ -98,7 +98,7 @@ export function draftAgentCommandsQueryKey(input: {
     "thinking",
     draftConfig.thinkingOptionId ?? null,
     "features",
-    draftConfig.providerOptions ?? null,
+    draftConfig.featureValues ?? null,
   ] as const;
 }
 

packages/app/src/agent-controls/draft-options-model.test.ts

@@ -1,189 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AgentOptionControl } from "@getpaseo/protocol/agent-types";
-import { isControlActive } from "./option-controls";
-import {
-  draftControlsRequest,
-  openDraftOptions,
-  ownDraftOptions,
-  viewDraftOptions,
-} from "./draft-options-model";
-
-const SPEED: AgentOptionControl = {
-  type: "select",
-  key: "service_tier",
-  label: "Speed",
-  defaultValue: "default",
-  choices: [
-    { value: "default", label: "Standard" },
-    { value: "priority", label: "Fast" },
-  ],
-};
-const WEB_SEARCH: AgentOptionControl = { type: "toggle", key: "web_search", label: "Web search" };
-
-function answer(
-  provider: string,
-  requestKey: string,
-  options: Record<string, unknown>,
-  controls = [SPEED, WEB_SEARCH],
-) {
-  return { provider, requestKey, controls, options };
-}
-
-describe("draft options model", () => {
-  it("draws a legacy Fast profile as the Fast tier the daemon resolved", () => {
-    const model = openDraftOptions({ provider: "codex", seed: { service_tier: "fast" } });
-    model.applyResolved(answer("codex", "k1", { service_tier: "priority" }));
-
-    const view = viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k1" });
-
-    expect(view?.options).toEqual({ service_tier: "priority" });
-    expect(view && isControlActive(SPEED, view.options)).toBe(true);
-    // The daemon still gets the stored value to resolve, and so does create.
-    expect(ownDraftOptions(model.getState())).toEqual({ service_tier: "fast" });
-  });
-
-  it("applying a profile from another provider keeps its options through the provider change", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", {}));
-
-    model.applyProfile({
-      provider: "codex",
-      options: { sandbox_mode: "read-only", service_tier: "fast" },
-    });
-    // The form follows the profile to its provider.
-    model.observeProvider("codex");
-
-    expect(ownDraftOptions(model.getState())).toEqual({
-      sandbox_mode: "read-only",
-      service_tier: "fast",
-    });
-    expect(model.getState().resolved).toBeNull();
-  });
-
-  it("choosing another provider by hand starts the options over", () => {
-    const model = openDraftOptions({ provider: "codex", seed: { sandbox_mode: "read-only" } });
-    model.setOption("web_search", true);
-
-    model.observeProvider("claude");
-
-    expect(ownDraftOptions(model.getState())).toBeUndefined();
-    expect(model.getState().resolved).toBeNull();
-  });
-
-  it("never pairs a manually chosen provider with the previous provider's options", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(
-      answer("claude", "k1", { fast_mode: true }, [
-        { type: "toggle", key: "fast_mode", label: "Fast" },
-      ]),
-    );
-    model.setOption("fast_mode", true);
-    const form = { provider: "claude", cwd: "/repo" };
-    expect(draftControlsRequest(model.getState(), form)).toMatchObject({
-      provider: "claude",
-      providerOptions: { fast_mode: true },
-    });
-
-    // The form shows OpenCode on its next render; the model has not observed it yet.
-    expect(draftControlsRequest(model.getState(), { ...form, provider: "opencode" })).toBeNull();
-
-    model.observeProvider("opencode");
-    const request = draftControlsRequest(model.getState(), { ...form, provider: "opencode" });
-    expect(request).toEqual({ provider: "opencode", cwd: "/repo" });
-  });
-
-  it("stops sending a toggle once the model in use draws no control for it", () => {
-    const FAST_MODE: AgentOptionControl = { type: "toggle", key: "fast_mode", label: "Fast" };
-    const model = openDraftOptions({ provider: "claude", seed: { sandbox_mode: "read-only" } });
-    model.applyResolved(answer("claude", "opus", { fast_mode: false }, [FAST_MODE]));
-    model.setOption("fast_mode", true);
-    expect(ownDraftOptions(model.getState())).toEqual({
-      sandbox_mode: "read-only",
-      fast_mode: true,
-    });
-
-    // The form moves to a model without Fast; its answer lists no such control.
-    model.applyResolved(answer("claude", "haiku", {}, []));
-
-    expect(ownDraftOptions(model.getState())).toEqual({ sandbox_mode: "read-only" });
-
-    // Back on a model that draws the control, the toggle applies again. The daemon's answer
-    // for the request without it said Fast was off; the request that carries it follows.
-    model.applyResolved(answer("claude", "opus-again", { fast_mode: false }, [FAST_MODE]));
-    expect(ownDraftOptions(model.getState())).toEqual({
-      sandbox_mode: "read-only",
-      fast_mode: true,
-    });
-  });
-
-  it("always sends an option no control has drawn", () => {
-    const FAST_MODE: AgentOptionControl = { type: "toggle", key: "fast_mode", label: "Fast" };
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", {}, [FAST_MODE]));
-
-    model.setOption("token_budget", 5);
-
-    expect(ownDraftOptions(model.getState())).toEqual({ token_budget: 5 });
-    model.applyResolved(answer("claude", "k2", {}, []));
-    expect(ownDraftOptions(model.getState())).toEqual({ token_budget: 5 });
-  });
-
-  it("keeps a draft's seed when the first provider is chosen", () => {
-    const model = openDraftOptions({ provider: null, seed: { web_search: true } });
-
-    model.observeProvider("claude");
-
-    expect(ownDraftOptions(model.getState())).toEqual({ web_search: true });
-  });
-
-  it("sends a remembered value to the daemon, and draws only what comes back", () => {
-    const model = openDraftOptions({ provider: "codex" });
-    model.setRemembered({ service_tier: "fast", retired: true });
-    // Nothing is known about the provider's controls yet.
-    expect(ownDraftOptions(model.getState())).toBeUndefined();
-
-    model.applyResolved(answer("codex", "k1", { service_tier: "default" }));
-    expect(ownDraftOptions(model.getState())).toEqual({ service_tier: "fast" });
-    // The answer to the first request does not show the remembered value as if it applied.
-    expect(
-      viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k2" })?.options,
-    ).toEqual({ service_tier: "default" });
-
-    model.applyResolved(answer("codex", "k2", { service_tier: "priority" }));
-    expect(
-      viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k2" })?.options,
-    ).toEqual({ service_tier: "priority" });
-  });
-
-  it("does not let a remembered value override the seed", () => {
-    const model = openDraftOptions({ provider: "codex", seed: { service_tier: "default" } });
-    model.applyResolved(answer("codex", "k1", { service_tier: "default" }));
-    model.setRemembered({ service_tier: "fast" });
-
-    expect(ownDraftOptions(model.getState())).toEqual({ service_tier: "default" });
-  });
-
-  it("lays a toggle over the previous answer until the new one arrives", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", { web_search: false }));
-
-    model.setOption("web_search", true);
-
-    expect(
-      viewDraftOptions(model.getState(), { provider: "claude", requestKey: "k2" })?.options,
-    ).toEqual({ web_search: true });
-    model.applyResolved(answer("claude", "k2", { web_search: true }));
-    expect(
-      viewDraftOptions(model.getState(), { provider: "claude", requestKey: "k2" })?.options,
-    ).toEqual({ web_search: true });
-  });
-
-  it("draws nothing for a provider the answer is not for", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", {}));
-
-    expect(viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k1" })).toBe(
-      undefined,
-    );
-  });
-});

packages/app/src/agent-controls/draft-options-model.ts

@@ -1,217 +0,0 @@
-import type {
-  AgentOptionControl,
-  AgentSessionConfig,
-  ProviderOptions,
-} from "@getpaseo/protocol/agent-types";
-import { withoutLostControls } from "./lost-controls";
-
-/**
- * The options of one draft agent, as a plain model (see docs/forms.md). It owns which layers
- * make up the draft's options; the daemon owns what they mean. Every layer is sent to the daemon
- * (`ownDraftOptions`) and the UI draws what comes back (`viewDraftOptions`), so no alias,
- * default or legacy key is resolved here.
- *
- * - `seed`: options the draft started from (a profile, a forked agent).
- * - `remembered`: the provider's last-used control values.
- * - `edits`: toggles made in this draft.
- *
- * An edit of `null` removes the key from every layer, the way a patch does on a running agent, so
- * the provider's default applies again.
- *
- * Choosing a provider by hand starts the options over; applying a profile replaces the provider
- * and the options in one step, so the provider change that follows does not clear them.
- */
-export interface ResolvedDraftOptions {
-  provider: string;
-  /** Names the request that produced this answer; see `viewDraftOptions`. */
-  requestKey: string;
-  controls: AgentOptionControl[];
-  options: ProviderOptions;
-}
-
-export interface DraftOptionsState {
-  provider: string | null;
-  seed: ProviderOptions;
-  remembered: ProviderOptions;
-  edits: ProviderOptions;
-  resolved: ResolvedDraftOptions | null;
-  /** Every key an answer for this provider has drawn as a control. */
-  drawn: ReadonlySet<string>;
-}
-
-export interface DraftOptionsModel {
-  getState: () => DraftOptionsState;
-  subscribe: (listener: () => void) => () => void;
-  /** The provider the draft's form now has. A different one than the model's is a manual choice. */
-  observeProvider: (provider: string | null) => void;
-  applyProfile: (profile: { provider: string; options: ProviderOptions }) => void;
-  setRemembered: (remembered: ProviderOptions) => void;
-  setOption: (key: string, value: unknown) => void;
-  applyResolved: (resolved: ResolvedDraftOptions) => void;
-}
-
-export function openDraftOptions(input: {
-  provider: string | null;
-  seed?: ProviderOptions;
-  /**
-   * The provider the draft's form has now. An edit belongs to it even before the screen has
-   * rendered the change, so `setOption` observes it first.
-   */
-  currentProvider?: () => string | null;
-}): DraftOptionsModel {
-  let state: DraftOptionsState = {
-    provider: input.provider,
-    seed: input.seed ?? {},
-    remembered: {},
-    edits: {},
-    resolved: null,
-    drawn: new Set(),
-  };
-  const listeners = new Set<() => void>();
-
-  function publish(update: (current: DraftOptionsState) => DraftOptionsState): void {
-    const next = update(state);
-    if (next === state) return;
-    state = next;
-    for (const listener of listeners) listener();
-  }
-
-  function observeProvider(provider: string | null): void {
-    publish((current) => {
-      if (provider === current.provider) return current;
-      // The first provider a draft picks does not discard what it was opened with.
-      if (current.provider === null) return { ...current, provider };
-      return { ...current, provider, seed: {}, edits: {}, resolved: null, drawn: new Set() };
-    });
-  }
-
-  return {
-    getState: () => state,
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    observeProvider,
-    applyProfile: (profile) =>
-      publish((current) => ({
-        ...current,
-        provider: profile.provider,
-        seed: profile.options,
-        edits: {},
-        resolved: current.provider === profile.provider ? current.resolved : null,
-        drawn: current.provider === profile.provider ? current.drawn : new Set(),
-      })),
-    setRemembered: (remembered) => publish((current) => ({ ...current, remembered })),
-    setOption: (key, value) => {
-      if (input.currentProvider) observeProvider(input.currentProvider());
-      publish((current) =>
-        Object.is(current.edits[key], value)
-          ? current
-          : { ...current, edits: { ...current.edits, [key]: value } },
-      );
-    },
-    applyResolved: (resolved) =>
-      publish((current) => ({
-        ...current,
-        resolved,
-        drawn: new Set([...current.drawn, ...resolved.controls.map((control) => control.key)]),
-      })),
-  };
-}
-
-/**
- * Everything the draft would create with, for the daemon to resolve. A last-used value applies
- * once the provider has told us it still draws a control for that key, and never over the seed.
- * An edit of a key an earlier answer drew as a control stops applying when the latest answer
- * draws none for it (the model changed to one without that control) and applies again when a
- * control for it returns. An edit of a key no answer has drawn is an option without a control
- * and always applies.
- */
-export function ownDraftOptions(state: DraftOptionsState): ProviderOptions | undefined {
-  const controlKeys = new Set((state.resolved?.controls ?? []).map((control) => control.key));
-  const remembered = Object.fromEntries(
-    Object.entries(state.remembered).filter(
-      ([key]) => controlKeys.has(key) && !(key in state.seed),
-    ),
-  );
-  const edits = withoutLostControls(state.edits, state.drawn, controlKeys);
-  const own = withoutRemovals({ ...state.seed, ...remembered, ...edits });
-  return Object.keys(own).length > 0 ? own : undefined;
-}
-
-function withoutRemovals(options: ProviderOptions): ProviderOptions {
-  return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== null));
-}
-
-export type DraftControlsRequest = Pick<
-  AgentSessionConfig,
-  "provider" | "cwd" | "modeId" | "model" | "thinkingOptionId" | "providerOptions"
->;
-
-/** What the draft's form has chosen; the options come from the model. */
-export interface DraftControlsForm {
-  provider: string | null;
-  cwd: string;
-  modeId?: string | null;
-  modelId?: string | null;
-  thinkingOptionId?: string | null;
-}
-
-/**
- * The listing request for the draft's form, built from one snapshot of the model. The form
- * reaches a new provider before the model has observed it, and the model still holds the
- * previous provider's options until it does; that render has no request, so a request never
- * pairs one provider with another's options.
- */
-export function draftControlsRequest(
-  state: DraftOptionsState,
-  form: DraftControlsForm,
-): DraftControlsRequest | null {
-  if (!form.provider || !form.cwd || form.provider !== state.provider) return null;
-  const providerOptions = ownDraftOptions(state);
-  return {
-    provider: form.provider,
-    cwd: form.cwd,
-    ...(form.modeId ? { modeId: form.modeId } : {}),
-    ...(form.modelId ? { model: form.modelId } : {}),
-    ...(form.thinkingOptionId ? { thinkingOptionId: form.thinkingOptionId } : {}),
-    ...(providerOptions ? { providerOptions } : {}),
-  };
-}
-
-/**
- * What the controls draw: the daemon's answer for this provider. The last answer stays up while
- * a newer request is in flight, with the toggles made since laid over it, so a switch does not
- * wait for the round trip. It never carries a seed or remembered value the daemon has not
- * resolved.
- */
-export function viewDraftOptions(
-  state: DraftOptionsState,
-  current: { provider: string | null; requestKey: string },
-): { controls: AgentOptionControl[]; options: ProviderOptions } | undefined {
-  const { resolved } = state;
-  if (!resolved || resolved.provider !== current.provider) return undefined;
-  return {
-    controls: resolved.controls,
-    options:
-      resolved.requestKey === current.requestKey
-        ? resolved.options
-        : withoutRemovals({ ...resolved.options, ...state.edits }),
-  };
-}
-
-const NO_OPTIONS: ProviderOptions = {};
-
-/**
- * The options the draft will create with, for a plugin or a control to read: the daemon's answer
- * for this provider when there is one, otherwise the draft's own layers, so an edit shows before
- * the daemon has answered.
- */
-export function shownDraftOptions(
-  state: DraftOptionsState,
-  current: { provider: string | null; requestKey: string },
-): ProviderOptions {
-  return viewDraftOptions(state, current)?.options ?? ownDraftOptions(state) ?? NO_OPTIONS;
-}

packages/app/src/agent-controls/icons.test.ts

@@ -1,16 +0,0 @@
-import { Settings2 } from "lucide-react-native";
-import { describe, expect, it } from "vitest";
-import { getAgentFeatureIcon } from "./icons";
-
-describe("getAgentFeatureIcon", () => {
-  it("draws the Lucide icon a plugin provider names", () => {
-    const icon = getAgentFeatureIcon("Mic");
-    expect(icon).not.toBe(Settings2);
-    expect(getAgentFeatureIcon("Mic")).toBe(icon);
-  });
-
-  it("falls back to the generic icon for a missing or unknown name", () => {
-    expect(getAgentFeatureIcon()).toBe(Settings2);
-    expect(getAgentFeatureIcon("not-an-icon")).toBe(Settings2);
-  });
-});

packages/app/src/agent-controls/icons.ts

@@ -13,7 +13,6 @@ import {
   ShieldQuestionMark,
   Zap,
 } from "lucide-react-native";
-import { isLucideIconName, pluginIconComponent } from "@/plugins/icons";
 import { getModeVisuals, type AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 
 export interface AgentControlIconProps {
@@ -61,9 +60,6 @@ export function getAgentModeOptionIcon(
   return icon ? MODE_ICONS[icon] : undefined;
 }
 
-/** A built-in control names its icon in kebab case; a plugin provider names a Lucide icon. */
 export function getAgentFeatureIcon(icon?: string): AgentControlIcon {
-  if (!icon) return Settings2;
-  if (FEATURE_ICONS[icon]) return FEATURE_ICONS[icon];
-  return isLucideIconName(icon) ? pluginIconComponent(icon) : Settings2;
+  return (icon ? FEATURE_ICONS[icon] : undefined) ?? Settings2;
 }

packages/app/src/agent-controls/lost-controls.ts

@@ -1,17 +0,0 @@
-import type { ProviderOptions } from "@getpaseo/protocol/agent-types";
-
-/**
- * The options that still apply after an answer from the daemon. A key an earlier answer drew as a
- * control and the latest answer does not (the model changed to one without that control) is
- * dropped, and applies again if a control for it returns. A key no answer has drawn is an option
- * without a control and always applies.
- */
-export function withoutLostControls(
-  options: ProviderOptions,
-  drawn: ReadonlySet<string>,
-  current: ReadonlySet<string>,
-): ProviderOptions {
-  return Object.fromEntries(
-    Object.entries(options).filter(([key]) => !drawn.has(key) || current.has(key)),
-  );
-}

packages/app/src/agent-controls/option-controls.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AgentOptionControl } from "@getpaseo/protocol/agent-types";
-import {
-  getControlTooltip,
-  isControlActive,
-  readSelectOption,
-  readToggleOption,
-} from "./option-controls";
-
-const speed: AgentOptionControl = {
-  type: "select",
-  key: "service_tier",
-  label: "Speed",
-  defaultValue: "default",
-  choices: [
-    { value: "default", label: "Normal" },
-    { value: "priority", label: "Fast" },
-  ],
-};
-const fast: AgentOptionControl = { type: "toggle", key: "fast_mode", label: "Fast" };
-
-describe("option controls", () => {
-  it("reads a select from options and falls back to the control's default", () => {
-    if (speed.type !== "select") throw new Error("select expected");
-    expect(readSelectOption(speed, { service_tier: "priority" })).toBe("priority");
-    expect(readSelectOption(speed, {})).toBe("default");
-    expect(readSelectOption(speed, { service_tier: "unknown-tier" })).toBe("default");
-  });
-
-  it("reads a toggle from options and is off when unset", () => {
-    if (fast.type !== "toggle") throw new Error("toggle expected");
-    expect(readToggleOption(fast, { fast_mode: true })).toBe(true);
-    expect(readToggleOption(fast, {})).toBe(false);
-  });
-
-  it("is active when the option differs from the control's default", () => {
-    expect(isControlActive(speed, { service_tier: "priority" })).toBe(true);
-    expect(isControlActive(speed, { service_tier: "default" })).toBe(false);
-    expect(isControlActive(speed, {})).toBe(false);
-    expect(isControlActive(fast, { fast_mode: true })).toBe(true);
-    expect(isControlActive(fast, {})).toBe(false);
-  });
-
-  it("prefers a control's tooltip over its label", () => {
-    expect(getControlTooltip({ label: "Plan", tooltip: "Toggle plan mode" })).toBe(
-      "Toggle plan mode",
-    );
-    expect(getControlTooltip({ label: "Custom" })).toBe("Custom");
-  });
-});

packages/app/src/agent-controls/option-controls.ts

@@ -1,47 +0,0 @@
-import type {
-  AgentOptionControl,
-  AgentOptionSelectControl,
-  AgentOptionToggleControl,
-  ProviderOptions,
-} from "@getpaseo/protocol/agent-types";
-
-/**
- * The composer's option controls. A control only describes how to draw one option key; the
- * value is read from `options`, which the daemon resolved (defaults, aliases, what runs).
- */
-export interface ComposerOptionControls {
-  controls: AgentOptionControl[];
-  options: ProviderOptions;
-  onSetOption: (key: string, value: unknown) => void;
-}
-
-export function readToggleOption(
-  control: AgentOptionToggleControl,
-  options: ProviderOptions,
-): boolean {
-  const value = options[control.key];
-  return typeof value === "boolean" ? value : (control.defaultValue ?? false);
-}
-
-/** The selected choice's value, or the control's default when the option names no choice. */
-export function readSelectOption(
-  control: AgentOptionSelectControl,
-  options: ProviderOptions,
-): string | null {
-  const value = options[control.key];
-  if (typeof value === "string" && control.choices.some((choice) => choice.value === value)) {
-    return value;
-  }
-  return control.defaultValue ?? null;
-}
-
-/** Whether the option is set to something other than the control's default. */
-export function isControlActive(control: AgentOptionControl, options: ProviderOptions): boolean {
-  if (control.type === "toggle") return readToggleOption(control, options);
-  const value = readSelectOption(control, options);
-  return value !== null && value !== control.defaultValue;
-}
-
-export function getControlTooltip(control: Pick<AgentOptionControl, "label" | "tooltip">): string {
-  return control.tooltip ?? control.label;
-}

packages/app/src/agent-profiles/internal/materialize-profile.test.ts

@@ -23,7 +23,7 @@ describe("materializeAgentProfile", () => {
           model: "claude-opus-5",
           modeId: "plan",
           thinkingOptionId: "think-hard",
-          options: { web_search: true },
+          featureValues: { web_search: true },
         }),
       ),
     ).toEqual({
@@ -31,7 +31,7 @@ describe("materializeAgentProfile", () => {
       modelId: "claude-opus-5",
       modeId: "plan",
       thinkingOptionId: "think-hard",
-      options: { web_search: true },
+      featureValues: { web_search: true },
     });
   });
 
@@ -41,7 +41,7 @@ describe("materializeAgentProfile", () => {
       modelId: "",
       modeId: "",
       thinkingOptionId: "",
-      options: {},
+      featureValues: {},
     });
   });
 
@@ -61,7 +61,7 @@ describe("toAgentConfigApply", () => {
             model: "claude-opus-5",
             modeId: "plan",
             thinkingOptionId: "think-hard",
-            options: { web_search: true },
+            featureValues: { web_search: true },
           }),
         ),
       ),
@@ -69,7 +69,7 @@ describe("toAgentConfigApply", () => {
       modelId: "claude-opus-5",
       modeId: "plan",
       thinkingOptionId: "think-hard",
-      options: { web_search: true },
+      featureValues: { web_search: true },
     });
   });
 
@@ -81,8 +81,8 @@ describe("toAgentConfigApply", () => {
 
   it("omits an empty feature map so the agent keeps its own feature values", () => {
     expect(
-      toAgentConfigApply(materializeAgentProfile(profile({ options: {} }))),
-    ).not.toHaveProperty("options");
+      toAgentConfigApply(materializeAgentProfile(profile({ featureValues: {} }))),
+    ).not.toHaveProperty("featureValues");
   });
 
   it("never carries a provider, which a running agent cannot change", () => {

packages/app/src/agent-profiles/internal/materialize-profile.ts

@@ -12,7 +12,7 @@ export interface MaterializedAgentProfile {
   modelId: string;
   modeId: string;
   thinkingOptionId: string;
-  options: Record<string, unknown>;
+  featureValues: Record<string, unknown>;
 }
 
 function trimmed(value: string | undefined): string {
@@ -25,7 +25,7 @@ export function materializeAgentProfile(profile: AgentProfile): MaterializedAgen
     modelId: trimmed(profile.model),
     modeId: trimmed(profile.modeId),
     thinkingOptionId: trimmed(profile.thinkingOptionId),
-    options: profile.options ?? {},
+    featureValues: profile.featureValues ?? {},
   };
 }
 
@@ -52,6 +52,8 @@ export function toAgentConfigApply(profile: MaterializedAgentProfile): AgentConf
     ...(profile.modelId ? { modelId: profile.modelId } : {}),
     ...(profile.modeId ? { modeId: profile.modeId } : {}),
     ...(profile.thinkingOptionId ? { thinkingOptionId: profile.thinkingOptionId } : {}),
-    ...(Object.keys(profile.options).length > 0 ? { options: profile.options } : {}),
+    ...(Object.keys(profile.featureValues).length > 0
+      ? { featureValues: profile.featureValues }
+      : {}),
   };
 }

packages/app/src/agent-profiles/internal/profile-form-model.test.ts

@@ -1,7 +1,7 @@
 import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
 import { describe, expect, it } from "vitest";
 import {
-  buildControlsRequestKey,
+  buildFeatureRequestKey,
   openAgentProfileForm,
   type AgentProfileFormModel,
 } from "./profile-form-model";
@@ -70,21 +70,6 @@ function optionValues(options: readonly { value: string }[]): string[] {
   return options.map((option) => option.value);
 }
 
-const FAST = {
-  controls: [{ type: "toggle" as const, key: "fast_mode", label: "Fast" }],
-  options: { fast_mode: false },
-};
-const NO_CONTROLS = { controls: [], options: {} };
-
-function toggledOnOpus(): AgentProfileFormModel {
-  const model = openWithCatalog({ mode: "create" });
-  model.setName("Fast");
-  selectClaude(model);
-  model.applyControls(model.getState().controlsRequestKey ?? "", FAST);
-  model.setOption("fast_mode", true);
-  return model;
-}
-
 describe("openAgentProfileForm", () => {
   it("starts a create form empty and cannot submit", () => {
     const model = openWithCatalog({ mode: "create" });
@@ -188,7 +173,7 @@ describe("openAgentProfileForm", () => {
         model: "claude-opus-5",
         modeId: "plan",
         thinkingOptionId: "think-hard",
-        options: { webSearch: true },
+        featureValues: { webSearch: true },
         notes: "Visual work only.",
       },
     });
@@ -244,11 +229,10 @@ describe("openAgentProfileForm", () => {
       selectClaude(model);
       model.setModel("claude-opus-5", { label: "Opus 5" });
       model.setThinking("think-hard", { label: "Think hard" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", {
-        controls: [{ type: "toggle", key: "webSearch", label: "Web search" }],
-        options: { webSearch: false },
-      });
-      model.setOption("webSearch", true);
+      model.applyFeatures(model.getState().featureRequestKey ?? "", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
+      model.setFeatureValue("webSearch", true);
 
       model.setProvider("codex", { label: "Codex" });
       const state = model.getState();
@@ -258,9 +242,8 @@ describe("openAgentProfileForm", () => {
       expect(state.modelDisplay).toEqual({ label: "GPT-5.2 Codex" });
       expect(state.thinkingOptionId).toBe("");
       expect(state.thinkingDisplay).toBeNull();
-      expect(state.options).toEqual({});
-      expect(state.optionEdits).toEqual({});
-      expect(state.controls).toEqual([]);
+      expect(state.featureValues).toEqual({});
+      expect(state.features).toEqual([]);
       expect(state.name).toBe("Test writer");
     });
 
@@ -351,28 +334,23 @@ describe("openAgentProfileForm", () => {
     });
   });
 
-  const WEB_SEARCH_CONTROLS = {
-    controls: [{ type: "toggle" as const, key: "webSearch", label: "Web search" }],
-    options: { webSearch: false },
-  };
-
-  describe("controls", () => {
-    it("asks for controls per provider/model/mode/thinking combination", () => {
+  describe("features", () => {
+    it("asks for features per provider/model/mode/thinking combination", () => {
       const model = openWithCatalog({ mode: "create" });
       selectClaude(model);
 
-      expect(model.getState().controlsRequest).toEqual({
+      expect(model.getState().featureRequest).toEqual({
         provider: "claude",
         model: "claude-opus-5",
         modeId: "plan",
         thinkingOptionId: "think",
       });
-      const firstKey = model.getState().controlsRequestKey;
+      const firstKey = model.getState().featureRequestKey;
 
       model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
 
-      expect(model.getState().controlsRequestKey).not.toBe(firstKey);
-      expect(model.getState().controlsRequest).toEqual({
+      expect(model.getState().featureRequestKey).not.toBe(firstKey);
+      expect(model.getState().featureRequest).toEqual({
         provider: "claude",
         model: "claude-haiku-4-5",
         modeId: "plan",
@@ -383,233 +361,77 @@ describe("openAgentProfileForm", () => {
     it("moves from pending to complete only for the current request", () => {
       const model = openWithCatalog({ mode: "create" });
       selectClaude(model);
-      const key = model.getState().controlsRequestKey ?? "";
-      expect(model.getState().controlsResolution).toBe("pending");
+      const key = model.getState().featureRequestKey ?? "";
+      expect(model.getState().featureResolution).toBe("pending");
 
-      model.applyControls("stale-key", {
-        controls: [{ type: "toggle", key: "webSearch", label: "Web search" }],
-        options: { webSearch: false },
-      });
-      expect(model.getState().controlsResolution).toBe("pending");
-      expect(model.getState().controls).toEqual([]);
+      model.applyFeatures("stale-key", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
+      expect(model.getState().featureResolution).toBe("pending");
+      expect(model.getState().features).toEqual([]);
 
-      model.applyControls(key, {
-        controls: [{ type: "toggle", key: "webSearch", label: "Web search" }],
-        options: { webSearch: false },
-      });
-      expect(model.getState().controlsResolution).toBe("complete");
-      expect(model.getState().disclosure.showControlsField).toBe(true);
+      model.applyFeatures(key, [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
+      expect(model.getState().featureResolution).toBe("complete");
+      expect(model.getState().disclosure.showFeaturesField).toBe(true);
     });
 
-    it("reflects a set option back into the rendered controls", () => {
+    it("reflects a set feature value back into the rendered feature", () => {
       const model = openWithCatalog({ mode: "create" });
-      model.setName("Searcher");
       selectClaude(model);
-      model.applyControls(model.getState().controlsRequestKey ?? "", WEB_SEARCH_CONTROLS);
+      model.applyFeatures(model.getState().featureRequestKey ?? "", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
 
-      model.setOption("webSearch", true);
+      model.setFeatureValue("webSearch", true);
 
-      expect(model.getState().controls[0]).toMatchObject({ key: "webSearch" });
-      expect(model.getState().controlOptions).toEqual({ webSearch: true });
-      expect(model.getState().submitValue?.options).toEqual({ webSearch: true });
+      expect(model.getState().features[0]).toMatchObject({ id: "webSearch", value: true });
+      expect(model.getState().featureValues).toEqual({ webSearch: true });
     });
 
-    it("keeps stored options while the controls are still pending", () => {
-      const model = openAgentProfileForm({
-        mode: "edit",
-        profile: { id: "p1", name: "UI work", provider: "claude", options: { webSearch: true } },
-      });
-      model.applyProviderCatalog(ENTRIES);
-
-      expect(model.getState().controlsResolution).toBe("pending");
-      expect(model.getState().submitValue?.options).toEqual({ webSearch: true });
-    });
-
-    it("keeps options no control draws, so editing a profile does not drop them", () => {
+    it("keeps stored feature values while the feature list is still pending", () => {
       const model = openAgentProfileForm({
         mode: "edit",
         profile: {
           id: "p1",
           name: "UI work",
           provider: "claude",
-          options: { webSearch: true, sandbox_mode: "read-only" },
+          featureValues: { webSearch: true },
         },
       });
       model.applyProviderCatalog(ENTRIES);
-      model.applyControls(model.getState().controlsRequestKey ?? "", WEB_SEARCH_CONTROLS);
-      model.setOption("webSearch", false);
 
-      expect(model.getState().submitValue?.options).toEqual({
-        webSearch: false,
-        sandbox_mode: "read-only",
-      });
+      expect(model.getState().featureResolution).toBe("pending");
+      expect(model.getState().submitValue?.featureValues).toEqual({ webSearch: true });
     });
 
-    it("draws the options the daemon resolved from the stored ones, then the edits", () => {
-      const model = openAgentProfileForm({
-        mode: "edit",
-        profile: { id: "p1", name: "Fast", provider: "codex", options: { service_tier: "fast" } },
-      });
-      model.applyProviderCatalog(ENTRIES);
-
-      // The request carries the stored options so the daemon can resolve the legacy tier.
-      expect(model.getState().controlsRequest?.providerOptions).toEqual({ service_tier: "fast" });
-
-      model.applyControls(model.getState().controlsRequestKey ?? "", {
-        controls: [
-          {
-            type: "select",
-            key: "service_tier",
-            label: "Speed",
-            defaultValue: "default",
-            choices: [
-              { value: "default", label: "Standard" },
-              { value: "priority", label: "Fast" },
-            ],
-          },
-        ],
-        options: { service_tier: "priority" },
-      });
-
-      expect(model.getState().controlOptions).toEqual({ service_tier: "priority" });
-      // Nothing was edited, so the stored value is saved as it was.
-      expect(model.getState().submitValue?.options).toEqual({ service_tier: "fast" });
-    });
-
-    it("sends an edit to the daemon with the stored options, and draws the answer", () => {
+    it("prunes stored values the provider no longer reports", () => {
       const model = openAgentProfileForm({
         mode: "edit",
         profile: {
           id: "p1",
-          name: "Fast",
-          provider: "codex",
-          options: { service_tier: "fast", sandbox_mode: "read-only" },
-        },
-      });
-      model.applyProviderCatalog(ENTRIES);
-      const speed = {
-        controls: [
-          {
-            type: "select" as const,
-            key: "service_tier",
-            label: "Speed",
-            defaultValue: "default",
-            choices: [
-              { value: "default", label: "Standard" },
-              { value: "priority", label: "Fast" },
-            ],
-          },
-        ],
-        options: { service_tier: "priority", sandbox_mode: "read-only" },
-      };
-      model.applyControls(model.getState().controlsRequestKey ?? "", speed);
-
-      model.setOption("service_tier", "default");
-
-      // The controls stay up while the daemon answers, with the toggle laid over the last answer.
-      expect(model.getState().controls).toHaveLength(1);
-      expect(model.getState().controlOptions).toMatchObject({ service_tier: "default" });
-      // The request carries everything the profile would save, so the daemon resolves it.
-      expect(model.getState().controlsRequest?.providerOptions).toEqual({
-        service_tier: "default",
-        sandbox_mode: "read-only",
-      });
-      expect(model.getState().controlsResolution).toBe("pending");
-
-      model.applyControls(model.getState().controlsRequestKey ?? "", {
-        ...speed,
-        options: { service_tier: "default", sandbox_mode: "read-only" },
-      });
-      expect(model.getState().controlsResolution).toBe("complete");
-      expect(model.getState().controlOptions).toEqual({
-        service_tier: "default",
-        sandbox_mode: "read-only",
-      });
-    });
-
-    it("draws no controls for the previous model while another model's answer is pending", () => {
-      const model = openWithCatalog({ mode: "create" });
-      selectClaude(model);
-      model.applyControls(model.getState().controlsRequestKey ?? "", WEB_SEARCH_CONTROLS);
-
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-
-      expect(model.getState().controls).toEqual([]);
-    });
-
-    it("does not save a toggle once the model that drew it is replaced by one without it", () => {
-      const model = toggledOnOpus();
-      expect(model.getState().submitValue?.options).toEqual({ fast_mode: true });
-
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", NO_CONTROLS);
-
-      expect(model.getState().submitValue?.options).toBeUndefined();
-      expect(model.getState().controlsRequest?.providerOptions).toBeUndefined();
-    });
-
-    it("saves a toggle again when the model that draws it returns", () => {
-      const model = toggledOnOpus();
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", NO_CONTROLS);
-
-      model.setModel("claude-opus-5", { label: "Opus 5" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", FAST);
-
-      expect(model.getState().submitValue?.options).toEqual({ fast_mode: true });
-    });
-
-    it("does not save a stored toggle profile either", () => {
-      const model = openAgentProfileForm({
-        mode: "edit",
-        profile: {
-          id: "p1",
-          name: "Fast",
+          name: "UI work",
           provider: "claude",
-          model: "claude-opus-5",
-          options: { fast_mode: true },
+          featureValues: { webSearch: true, retiredFlag: true },
         },
       });
       model.applyProviderCatalog(ENTRIES);
-      model.applyControls(model.getState().controlsRequestKey ?? "", FAST);
+      model.applyFeatures(model.getState().featureRequestKey ?? "", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
 
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", NO_CONTROLS);
-
-      expect(model.getState().submitValue?.options).toBeUndefined();
-    });
-
-    it("never drops an option no control has drawn", () => {
-      const model = openWithCatalog({ mode: "create" });
-      model.setName("Fast");
-      selectClaude(model);
-      model.applyControls(model.getState().controlsRequestKey ?? "", FAST);
-      model.setOption("token_budget", 8000);
-      model.setOption("fast_mode", true);
-
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", NO_CONTROLS);
-
-      expect(model.getState().submitValue?.options).toEqual({ token_budget: 8000 });
-    });
-
-    it("keeps a toggle when the daemon cannot list controls", () => {
-      const model = toggledOnOpus();
-
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-      model.applyControlsUnavailable(model.getState().controlsRequestKey ?? "");
-
-      expect(model.getState().submitValue?.options).toEqual({ fast_mode: true });
+      expect(model.getState().featureValues).toEqual({ webSearch: true });
     });
 
     it("resolves an unavailable feature listing without showing the field", () => {
       const model = openWithCatalog({ mode: "create" });
       selectClaude(model);
 
-      model.applyControlsUnavailable(model.getState().controlsRequestKey ?? "");
+      model.applyFeaturesUnavailable(model.getState().featureRequestKey ?? "");
 
-      expect(model.getState().controlsResolution).toBe("complete");
-      expect(model.getState().disclosure.showControlsField).toBe(false);
+      expect(model.getState().featureResolution).toBe("complete");
+      expect(model.getState().disclosure.showFeaturesField).toBe(false);
     });
   });
 
@@ -642,15 +464,15 @@ describe("openAgentProfileForm", () => {
   });
 });
 
-describe("buildControlsRequestKey", () => {
+describe("buildFeatureRequestKey", () => {
   it("is null without a provider", () => {
-    expect(buildControlsRequestKey(null)).toBeNull();
+    expect(buildFeatureRequestKey(null)).toBeNull();
   });
 
   it("separates the fields so a value cannot bleed across positions", () => {
-    expect(buildControlsRequestKey({ provider: "claude", model: "a|b" })).toBe("claude|a|b||");
-    expect(buildControlsRequestKey({ provider: "claude", modeId: "a" })).not.toBe(
-      buildControlsRequestKey({ provider: "claude", model: "a" }),
+    expect(buildFeatureRequestKey({ provider: "claude", model: "a|b" })).toBe("claude|a|b||");
+    expect(buildFeatureRequestKey({ provider: "claude", modeId: "a" })).not.toBe(
+      buildFeatureRequestKey({ provider: "claude", model: "a" }),
     );
   });
 });

packages/app/src/agent-profiles/internal/profile-form-model.ts

@@ -1,14 +1,13 @@
 import type {
-  AgentOptionControl,
-  ProviderOptions,
+  AgentFeature,
   AgentMode,
   AgentModelDefinition,
   AgentSelectOption,
   ProviderSnapshotEntry,
 } from "@getpaseo/protocol/agent-types";
 import type { AgentProfile } from "@getpaseo/protocol/messages";
-import { withoutLostControls } from "@/agent-controls/lost-controls";
 import { formatAgentModeLabel, formatThinkingOptionLabel } from "@/agent-controls/labels";
+import { applyFeatureValues, pruneFeatureValues } from "@/hooks/feature-preferences";
 import { filterSelectableModels } from "@/provider-selection/model-catalog";
 
 /**
@@ -58,15 +57,11 @@ export interface AgentProfileFormSnapshot {
 }
 
 /**
- * The inputs a controls listing needs. Controls are provider-scoped and change
- * with model/mode/thinking, so every one of those is part of the request. The
- * profile's own options ride along so the daemon can resolve them (a legacy
- * `service_tier: "fast"` is drawn as the model's Fast tier); they are the same
- * for the life of one provider, so they are not part of the key.
+ * The inputs a feature listing needs. Features are provider-scoped and change
+ * with model/mode/thinking, so every one of those is part of the request.
  */
-export interface AgentProfileControlsRequest {
+export interface AgentProfileFeatureRequest {
   provider: string;
-  providerOptions?: ProviderOptions;
   model?: string;
   modeId?: string;
   thinkingOptionId?: string;
@@ -78,7 +73,7 @@ export interface AgentProfileFormDisclosure {
   showModelField: boolean;
   showModeField: boolean;
   showThinkingField: boolean;
-  showControlsField: boolean;
+  showFeaturesField: boolean;
 }
 
 export interface AgentProfileFormState {
@@ -91,22 +86,13 @@ export interface AgentProfileFormState {
   modelId: string;
   modeId: string;
   thinkingOptionId: string;
-  /** The options the profile was opened with, including ones no control draws. */
-  options: ProviderOptions;
-  /** Changes made in this form, over `options`. */
-  optionEdits: ProviderOptions;
+  featureValues: Record<string, unknown>;
 
   providerOptions: AgentProfileFormOption[];
   modelOptions: AgentProfileFormOption[];
   modeOptions: AgentProfileFormOption[];
   thinkingOptions: AgentProfileFormOption[];
-  controls: AgentOptionControl[];
-  /** What the controls show: the options the daemon resolved from `options`, then the edits. */
-  controlOptions: ProviderOptions;
-  /** Every key an answer for this provider has drawn as a control. */
-  drawnControlKeys: ReadonlySet<string>;
-  /** The keys the latest answer draws as controls. */
-  answeredControlKeys: ReadonlySet<string>;
+  features: AgentFeature[];
 
   providerDisplay: AgentProfileFormDisplay | null;
   modelDisplay: AgentProfileFormDisplay | null;
@@ -114,9 +100,9 @@ export interface AgentProfileFormState {
   thinkingDisplay: AgentProfileFormDisplay | null;
 
   catalogResolution: AgentProfileResolutionStatus;
-  controlsResolution: AgentProfileResolutionStatus;
-  controlsRequest: AgentProfileControlsRequest | null;
-  controlsRequestKey: string | null;
+  featureResolution: AgentProfileResolutionStatus;
+  featureRequest: AgentProfileFeatureRequest | null;
+  featureRequestKey: string | null;
 
   disclosure: AgentProfileFormDisclosure;
   isSubmitting: boolean;
@@ -132,12 +118,9 @@ export interface AgentProfileFormModel {
   /** Late input: the host-scoped provider catalog. Never touches selections. */
   applyProviderCatalog: (entries: readonly ProviderSnapshotEntry[]) => void;
   /** Late input: the feature list for one request. Stale keys are ignored. */
-  applyControls: (
-    requestKey: string,
-    resolved: { controls: readonly AgentOptionControl[]; options: ProviderOptions },
-  ) => void;
+  applyFeatures: (requestKey: string, features: readonly AgentFeature[]) => void;
   /** Resolve a request that produced no usable features (provider error). */
-  applyControlsUnavailable: (requestKey: string) => void;
+  applyFeaturesUnavailable: (requestKey: string) => void;
   setName: (value: string) => void;
   setAppearance: (value: { icon: string; color: string }) => void;
   setNotes: (value: string) => void;
@@ -145,7 +128,7 @@ export interface AgentProfileFormModel {
   setModel: (modelId: string, display: AgentProfileFormDisplay | null) => void;
   setMode: (modeId: string, display: AgentProfileFormDisplay | null) => void;
   setThinking: (thinkingOptionId: string, display: AgentProfileFormDisplay | null) => void;
-  setOption: (key: string, value: unknown) => void;
+  setFeatureValue: (featureId: string, value: unknown) => void;
   setSubmitting: (value: boolean) => void;
   setSubmitError: (value: string | null) => void;
 }
@@ -329,39 +312,19 @@ function refineDisplay(
   return current ?? { label: selectedId };
 }
 
-function buildControlsRequest(state: AgentProfileFormState): AgentProfileControlsRequest | null {
+function buildFeatureRequest(state: AgentProfileFormState): AgentProfileFeatureRequest | null {
   if (!state.provider) {
     return null;
   }
-  const ownOptions = ownOptionsOf(state);
   return {
     provider: state.provider,
     ...(state.modelId ? { model: state.modelId } : {}),
     ...(state.modeId ? { modeId: state.modeId } : {}),
     ...(state.thinkingOptionId ? { thinkingOptionId: state.thinkingOptionId } : {}),
-    ...(Object.keys(ownOptions).length > 0 ? { providerOptions: ownOptions } : {}),
   };
 }
 
-/**
- * Everything the profile would save as its options; the daemon resolves them for the form. A
- * toggle the model in use does not draw is not saved (see `withoutLostControls`).
- */
-function ownOptionsOf(
-  state: Pick<
-    AgentProfileFormState,
-    "options" | "optionEdits" | "drawnControlKeys" | "answeredControlKeys"
-  >,
-): ProviderOptions {
-  return withoutLostControls(
-    { ...state.options, ...state.optionEdits },
-    state.drawnControlKeys,
-    state.answeredControlKeys,
-  );
-}
-
-/** The part of a request that decides which controls exist; options only change their values. */
-function buildControlsScopeKey(request: AgentProfileControlsRequest | null): string | null {
+export function buildFeatureRequestKey(request: AgentProfileFeatureRequest | null): string | null {
   if (!request) {
     return null;
   }
@@ -373,25 +336,12 @@ function buildControlsScopeKey(request: AgentProfileControlsRequest | null): str
   ].join("|");
 }
 
-export function buildControlsRequestKey(
-  request: AgentProfileControlsRequest | null,
-): string | null {
-  if (!request) {
-    return null;
-  }
-  const scope = buildControlsScopeKey(request);
-  return request.providerOptions
-    ? `${scope}|${JSON.stringify(Object.entries(request.providerOptions).sort(([a], [b]) => a.localeCompare(b)))}`
-    : scope;
-}
-
 function buildSubmitValue(state: AgentProfileFormState): AgentProfileValue | null {
   const name = state.name.trim();
   const notes = state.notes.trim();
   if (!name || !state.provider) {
     return null;
   }
-  const options = ownOptionsOf(state);
   return {
     name,
     ...(state.icon ? { icon: state.icon } : {}),
@@ -400,16 +350,16 @@ function buildSubmitValue(state: AgentProfileFormState): AgentProfileValue | nul
     ...(state.modelId ? { model: state.modelId } : {}),
     ...(state.modeId ? { modeId: state.modeId } : {}),
     ...(state.thinkingOptionId ? { thinkingOptionId: state.thinkingOptionId } : {}),
-    ...(Object.keys(options).length > 0 ? { options } : {}),
+    ...(Object.keys(state.featureValues).length > 0 ? { featureValues: state.featureValues } : {}),
     ...(notes ? { notes } : {}),
   };
 }
 
-function resolveControlsStatus(
-  controlsRequestKey: string | null,
+function resolveFeatureStatus(
+  featureRequestKey: string | null,
   featuresAreCurrent: boolean,
 ): AgentProfileResolutionStatus {
-  if (controlsRequestKey === null) {
+  if (featureRequestKey === null) {
     return "idle";
   }
   return featuresAreCurrent ? "complete" : "pending";
@@ -442,29 +392,25 @@ function buildInitialState(snapshot: AgentProfileFormSnapshot): AgentProfileForm
     modelId,
     modeId: profile.modeId ?? "",
     thinkingOptionId: profile.thinkingOptionId ?? "",
-    options: { ...profile.options },
-    optionEdits: {},
+    featureValues: { ...profile.featureValues },
     providerOptions: [],
     modelOptions: [],
     modeOptions: [],
     thinkingOptions: [],
-    controls: [],
-    controlOptions: {},
-    drawnControlKeys: new Set(),
-    answeredControlKeys: new Set(),
+    features: [],
     providerDisplay: seedDisplay(provider),
     modelDisplay: seedDisplay(modelId),
     modeDisplay: seedDisplay(profile.modeId),
     thinkingDisplay: seedDisplay(profile.thinkingOptionId),
     catalogResolution: "idle",
-    controlsResolution: "idle",
-    controlsRequest: null,
-    controlsRequestKey: null,
+    featureResolution: "idle",
+    featureRequest: null,
+    featureRequestKey: null,
     disclosure: {
       showModelField: false,
       showModeField: false,
       showThinkingField: false,
-      showControlsField: false,
+      showFeaturesField: false,
     },
     isSubmitting: false,
     submitError: null,
@@ -476,45 +422,28 @@ function buildInitialState(snapshot: AgentProfileFormSnapshot): AgentProfileForm
 export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentProfileFormModel {
   let entries: readonly ProviderSnapshotEntry[] = [];
   let catalogResolution: AgentProfileResolutionStatus = "idle";
-  let resolvedControlsKey: string | null = null;
-  let resolvedScopeKey: string | null = null;
-  let resolvedControls: AgentOptionControl[] = [];
-  let resolvedOptions: ProviderOptions = {};
-  let drawnKeys: ReadonlySet<string> = new Set();
-  let answeredKeys: ReadonlySet<string> = new Set();
+  let resolvedFeatureKey: string | null = null;
+  let resolvedFeatures: AgentFeature[] = [];
   let listeners = new Set<() => void>();
   let closed = false;
 
   function derive(incoming: AgentProfileFormState): AgentProfileFormState {
     const models = resolveModels(entries, incoming.provider);
     const modes = resolveModes(entries, incoming.provider);
-    const next: AgentProfileFormState = {
-      ...seedSelections(incoming, {
-        entry: findEntry(entries, incoming.provider),
-        models,
-        modes,
-      }),
-      drawnControlKeys: drawnKeys,
-      answeredControlKeys: answeredKeys,
-    };
+    const next = seedSelections(incoming, {
+      entry: findEntry(entries, incoming.provider),
+      models,
+      modes,
+    });
     const thinking = resolveThinkingOptions(entries, next.provider, next.modelId);
-    const controlsRequest = buildControlsRequest(next);
-    const controlsRequestKey = buildControlsRequestKey(controlsRequest);
-    const controlsScopeKey = buildControlsScopeKey(controlsRequest);
+    const featureRequest = buildFeatureRequest(next);
+    const featureRequestKey = buildFeatureRequestKey(featureRequest);
     const featuresAreCurrent =
-      controlsRequestKey !== null && controlsRequestKey === resolvedControlsKey;
-    // A toggle changes only the options, so the controls stay up while the daemon answers and the
-    // toggle shows over the last answer. A change of provider, model, mode or thinking draws none
-    // until its own answer arrives.
-    const controlsApply = controlsScopeKey !== null && controlsScopeKey === resolvedScopeKey;
-    const controls = controlsApply ? resolvedControls : [];
-    let controlOptions: ProviderOptions = next.options;
-    if (controlsApply) {
-      controlOptions = featuresAreCurrent
-        ? resolvedOptions
-        : { ...resolvedOptions, ...next.optionEdits };
-    }
-    const controlsResolution = resolveControlsStatus(controlsRequestKey, featuresAreCurrent);
+      featureRequestKey !== null && featureRequestKey === resolvedFeatureKey;
+    const features = featuresAreCurrent
+      ? applyFeatureValues(resolvedFeatures, next.featureValues)
+      : [];
+    const featureResolution = resolveFeatureStatus(featureRequestKey, featuresAreCurrent);
 
     const withOptions: AgentProfileFormState = {
       ...next,
@@ -522,8 +451,7 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       modelOptions: buildModelOptions(models),
       modeOptions: buildModeOptions(modes),
       thinkingOptions: buildThinkingOptions(thinking),
-      controls,
-      controlOptions,
+      features,
       providerDisplay: refineDisplay(
         next.providerDisplay,
         next.provider,
@@ -551,9 +479,9 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
         })(),
       ),
       catalogResolution,
-      controlsResolution,
-      controlsRequest,
-      controlsRequestKey,
+      featureResolution,
+      featureRequest,
+      featureRequestKey,
     };
 
     // A field appears once the catalog can populate it, and stays visible while
@@ -564,7 +492,7 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       showModeField: hasProvider && (modes.length > 0 || Boolean(withOptions.modeId)),
       showThinkingField:
         hasProvider && (thinking.length > 0 || Boolean(withOptions.thinkingOptionId)),
-      showControlsField: hasProvider && controls.length > 0,
+      showFeaturesField: hasProvider && features.length > 0,
     };
     const canSubmit =
       withOptions.name.trim().length > 0 &&
@@ -603,26 +531,23 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       catalogResolution = "complete";
       publish((current) => current);
     },
-    applyControls: (requestKey, resolved) => {
-      if (requestKey !== state.controlsRequestKey) {
+    applyFeatures: (requestKey, features) => {
+      if (requestKey !== state.featureRequestKey) {
         return;
       }
-      resolvedControlsKey = requestKey;
-      resolvedScopeKey = buildControlsScopeKey(state.controlsRequest);
-      resolvedControls = [...resolved.controls];
-      resolvedOptions = resolved.options;
-      answeredKeys = new Set(resolved.controls.map((control) => control.key));
-      drawnKeys = new Set([...drawnKeys, ...answeredKeys]);
-      publish((current) => current);
+      resolvedFeatureKey = requestKey;
+      resolvedFeatures = [...features];
+      publish((current) => ({
+        ...current,
+        featureValues: pruneFeatureValues(current.featureValues, resolvedFeatures),
+      }));
     },
-    applyControlsUnavailable: (requestKey) => {
-      if (requestKey !== state.controlsRequestKey) {
+    applyFeaturesUnavailable: (requestKey) => {
+      if (requestKey !== state.featureRequestKey) {
         return;
       }
-      resolvedControlsKey = requestKey;
-      resolvedScopeKey = buildControlsScopeKey(state.controlsRequest);
-      resolvedControls = [];
-      resolvedOptions = {};
+      resolvedFeatureKey = requestKey;
+      resolvedFeatures = [];
       publish((current) => current);
     },
     setName: (value) => publish((current) => ({ ...current, name: value })),
@@ -637,8 +562,6 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
         // Everything below the provider is provider-scoped: a model id, mode id,
         // thinking id or feature id from the old provider means nothing here.
         // Clearing them is enough — `derive` seeds the new provider's defaults.
-        drawnKeys = new Set();
-        answeredKeys = new Set();
         return {
           ...current,
           provider: providerId,
@@ -649,8 +572,7 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
           modeDisplay: null,
           thinkingOptionId: "",
           thinkingDisplay: null,
-          options: {},
-          optionEdits: {},
+          featureValues: {},
         };
       }),
     setModel: (modelId, display) =>
@@ -676,10 +598,10 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       publish((current) => ({ ...current, modeId, modeDisplay: display })),
     setThinking: (thinkingOptionId, display) =>
       publish((current) => ({ ...current, thinkingOptionId, thinkingDisplay: display })),
-    setOption: (key, value) =>
+    setFeatureValue: (featureId, value) =>
       publish((current) => ({
         ...current,
-        optionEdits: { ...current.optionEdits, [key]: value },
+        featureValues: { ...current.featureValues, [featureId]: value },
       })),
     setSubmitting: (value) => publish((current) => ({ ...current, isSubmitting: value })),
     setSubmitError: (value) => publish((current) => ({ ...current, submitError: value })),

packages/app/src/agent-profiles/internal/profile-summary.ts

@@ -47,7 +47,7 @@ export function buildAgentProfileTags(input: {
     tags.push({ id: "thinking", label: formatThinkingOptionLabel({ id: thinkingOptionId }) });
   }
 
-  const featureCount = Object.keys(input.profile.options ?? {}).length;
+  const featureCount = Object.keys(input.profile.featureValues ?? {}).length;
   if (featureCount > 0) {
     tags.push({ id: "features", label: input.formatFeatureCount(featureCount) });
   }

packages/app/src/agent-profiles/internal/use-agent-profile-picker.ts

@@ -117,7 +117,9 @@ export function useAgentProfilePicker(
           modelId: resolved.modelId,
           modeId: resolved.modeId,
           thinkingOptionId: resolved.thinkingOptionId,
-          ...(Object.keys(resolved.options).length > 0 ? { options: resolved.options } : {}),
+          ...(Object.keys(resolved.featureValues).length > 0
+            ? { featureValues: resolved.featureValues }
+            : {}),
         }),
       ).catch((error) => {
         console.warn("[useAgentProfilePicker] persist profile selection failed", error);

packages/app/src/agent-profiles/internal/use-profile-form-inputs.ts

@@ -27,7 +27,7 @@ export function useAgentProfileFormCatalog(input: {
   }, [entries, input.model]);
 }
 
-export function useAgentProfileFormControls(input: {
+export function useAgentProfileFormFeatures(input: {
   serverId: string;
   model: AgentProfileFormModel;
   state: AgentProfileFormState;
@@ -35,14 +35,14 @@ export function useAgentProfileFormControls(input: {
   const { t } = useTranslation();
   const client = useHostRuntimeClient(input.serverId);
   const isConnected = useHostRuntimeIsConnected(input.serverId);
-  const request = input.state.controlsRequest;
-  const requestKey = input.state.controlsRequestKey;
+  const request = input.state.featureRequest;
+  const requestKey = input.state.featureRequestKey;
 
   // `dataShape: "value"` and not `"list"`: a list shape keeps the previous
   // page's data while the next request is in flight, which would hand the
   // features of one provider/model combination to the key of another.
-  const controlsQuery = useFetchQuery({
-    queryKey: ["agentProfileControls", input.serverId, requestKey],
+  const featuresQuery = useFetchQuery({
+    queryKey: ["agentProfileFeatures", input.serverId, requestKey],
     dataShape: "value",
     staleTimeMs: 5 * 60 * 1000,
     enabled: Boolean(client && isConnected && request),
@@ -51,28 +51,28 @@ export function useAgentProfileFormControls(input: {
       if (!client || !request) {
         throw new Error(t("workspace.terminal.hostDisconnected"));
       }
-      const payload = await client.listProviderControls({ ...request, cwd: HOME_SCOPE_CWD });
+      const payload = await client.listProviderFeatures({ ...request, cwd: HOME_SCOPE_CWD });
       if (payload.error) {
         throw new Error(payload.error);
       }
-      return { controls: payload.controls ?? [], options: payload.options ?? {} };
+      return payload.features ?? [];
     },
   });
 
-  const { data, isError } = controlsQuery;
+  const { data, isError } = featuresQuery;
   const { model } = input;
 
   useEffect(() => {
     if (!requestKey || !data) {
       return;
     }
-    model.applyControls(requestKey, data);
+    model.applyFeatures(requestKey, data);
   }, [data, model, requestKey]);
 
   useEffect(() => {
     if (!requestKey || !isError) {
       return;
     }
-    model.applyControlsUnavailable(requestKey);
+    model.applyFeaturesUnavailable(requestKey);
   }, [isError, model, requestKey]);
 }

packages/app/src/agent-profiles/settings/agent-profile-edit-modal.tsx

@@ -2,8 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState, type ReactElement }
 import { Text, View } from "react-native";
 import { useTranslation } from "react-i18next";
 import { StyleSheet } from "react-native-unistyles";
-import type { AgentOptionControl, ProviderOptions } from "@getpaseo/protocol/agent-types";
-import { readSelectOption, readToggleOption } from "@/agent-controls/option-controls";
+import type { AgentFeature } from "@getpaseo/protocol/agent-types";
 import type { AgentProfile } from "@getpaseo/protocol/messages";
 import { AdaptiveModalSheet, type SheetHeader } from "@/components/adaptive-modal-sheet";
 import { Button } from "@/components/ui/button";
@@ -25,7 +24,7 @@ import type {
 } from "../internal/profile-form-model";
 import {
   useAgentProfileFormCatalog,
-  useAgentProfileFormControls,
+  useAgentProfileFormFeatures,
 } from "../internal/use-profile-form-inputs";
 import {
   useAgentProfileFormModel,
@@ -141,7 +140,7 @@ function OpenAgentProfileEditModal({
   const model = useAgentProfileFormModel(snapshot);
   const state = useAgentProfileFormState(model);
   useAgentProfileFormCatalog({ serverId, model });
-  useAgentProfileFormControls({ serverId, model, state });
+  useAgentProfileFormFeatures({ serverId, model, state });
 
   const sheetHeader = useMemo<SheetHeader>(
     () => ({
@@ -328,17 +327,16 @@ function OpenAgentProfileEditModal({
           />
         ) : null}
 
-        {state.disclosure.showControlsField ? (
+        {state.disclosure.showFeaturesField ? (
           <Field
             label={t("settings.host.agentProfiles.featuresLabel")}
             testID="agent-profile-features-field"
           >
             <View style={styles.featureCard} testID="agent-profile-features-card">
-              {state.controls.map((control, index) => (
-                <AgentProfileControlRow
-                  key={control.key}
-                  control={control}
-                  options={state.controlOptions}
+              {state.features.map((feature, index) => (
+                <AgentProfileFeatureRow
+                  key={feature.id}
+                  feature={feature}
                   isFirst={index === 0}
                   disabled={state.isSubmitting}
                   size={controlSize}
@@ -401,16 +399,14 @@ function OpenAgentProfileEditModal({
   );
 }
 
-function AgentProfileControlRow({
-  control,
-  options,
+function AgentProfileFeatureRow({
+  feature,
   isFirst,
   disabled,
   size,
   model,
 }: {
-  control: AgentOptionControl;
-  options: ProviderOptions;
+  feature: AgentFeature;
   isFirst: boolean;
   disabled: boolean;
   size: ControlSize;
@@ -421,75 +417,74 @@ function AgentProfileControlRow({
     [isFirst],
   );
   const handleToggle = useCallback(
-    (value: boolean) => model.setOption(control.key, value),
-    [control.key, model],
+    (value: boolean) => model.setFeatureValue(feature.id, value),
+    [feature.id, model],
   );
   const handleSelect = useCallback(
-    (value: string) => model.setOption(control.key, value),
-    [control.key, model],
+    (value: string) => model.setFeatureValue(feature.id, value),
+    [feature.id, model],
   );
   const selectOptions = useMemo<SelectFieldOption<string>[]>(
     () =>
-      control.type === "select"
-        ? control.choices.map((choice) => ({
-            id: choice.value,
-            value: choice.value,
-            label: choice.label,
-            ...(choice.description ? { description: choice.description } : {}),
-            testID: `agent-profile-feature-option-${control.key}-${choice.value}`,
+      feature.type === "select"
+        ? feature.options.map((option) => ({
+            id: option.id,
+            value: option.id,
+            label: option.label,
+            ...(option.description ? { description: option.description } : {}),
+            testID: `agent-profile-feature-option-${feature.id}-${option.id}`,
           }))
         : [],
-    [control],
+    [feature],
   );
-  const selectedValue = control.type === "select" ? readSelectOption(control, options) : null;
   const selectedDisplay = useMemo<SelectFieldDisplay | null>(() => {
-    if (control.type !== "select" || !selectedValue) {
+    if (feature.type !== "select" || !feature.value) {
       return null;
     }
-    const choice = control.choices.find((candidate) => candidate.value === selectedValue);
-    return { label: choice?.label ?? selectedValue };
-  }, [control, selectedValue]);
+    const option = feature.options.find((candidate) => candidate.id === feature.value);
+    return { label: option?.label ?? feature.value };
+  }, [feature]);
 
-  if (control.type === "select") {
+  if (feature.type === "select") {
     return (
-      <View style={rowStyle} testID={`agent-profile-feature-row-${control.key}`}>
+      <View style={rowStyle} testID={`agent-profile-feature-row-${feature.id}`}>
         <SelectField
-          label={control.label}
-          value={selectedValue}
+          label={feature.label}
+          value={feature.value}
           selectedDisplay={selectedDisplay}
           options={selectOptions}
           onChange={handleSelect}
-          placeholder={control.label}
-          emptyText={control.label}
+          placeholder={feature.label}
+          emptyText={feature.label}
           disabled={disabled}
-          {...(control.description ? { hint: control.description } : {})}
-          title={control.label}
+          {...(feature.description ? { hint: feature.description } : {})}
+          title={feature.label}
           size={size}
-          testID={`agent-profile-feature-field-${control.key}`}
-          triggerTestID={`agent-profile-feature-trigger-${control.key}`}
+          testID={`agent-profile-feature-field-${feature.id}`}
+          triggerTestID={`agent-profile-feature-trigger-${feature.id}`}
         />
       </View>
     );
   }
 
   return (
-    <View style={rowStyle} testID={`agent-profile-feature-row-${control.key}`}>
+    <View style={rowStyle} testID={`agent-profile-feature-row-${feature.id}`}>
       <View style={styles.featureMeta}>
         <Text style={styles.featureLabel} numberOfLines={1}>
-          {control.label}
+          {feature.label}
         </Text>
-        {control.description ? (
+        {feature.description ? (
           <Text style={styles.featureDescription} numberOfLines={2}>
-            {control.description}
+            {feature.description}
           </Text>
         ) : null}
       </View>
       <Switch
-        value={readToggleOption(control, options)}
+        value={feature.value === true}
         onValueChange={handleToggle}
         disabled={disabled}
-        accessibilityLabel={control.label}
-        testID={`agent-profile-feature-switch-${control.key}`}
+        accessibilityLabel={feature.label}
+        testID={`agent-profile-feature-switch-${feature.id}`}
       />
     </View>
   );

packages/app/src/agent-stream/bottom-anchor-controller.test.ts

@@ -263,7 +263,7 @@ describe("bottom anchor controller driver", () => {
 
     expect(harness.scrollAttempts).toHaveLength(0);
 
-    harness.driver.endUserScroll({ isNearBottom: true });
+    harness.driver.endUserScroll({ isAtEnd: true });
     harness.scheduler.flushAll();
 
     expect(harness.scrollAttempts).toHaveLength(1);
@@ -293,7 +293,7 @@ describe("bottom anchor controller driver", () => {
     });
     harness.context.authoritativeReady = true;
     harness.driver.notifyAuthoritativeHistoryMaybeChanged();
-    harness.driver.endUserScroll({ isNearBottom: true });
+    harness.driver.endUserScroll({ isAtEnd: true });
     harness.scheduler.flushAll();
 
     expect(harness.scrollAttempts).toHaveLength(1);
@@ -321,7 +321,7 @@ describe("bottom anchor controller driver", () => {
       nextIsNearBottom: false,
       scrollDelta: 48,
     });
-    harness.driver.endUserScroll({ isNearBottom: false });
+    harness.driver.endUserScroll({ isAtEnd: false });
     harness.context.authoritativeReady = true;
     harness.driver.notifyAuthoritativeHistoryMaybeChanged();
     harness.driver.reevaluate();
@@ -340,10 +340,7 @@ describe("bottom anchor controller driver", () => {
     const harness = createDriverHarness();
 
     harness.driver.detachByUser();
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 1200,
-      contentHeight: 1500,
-    });
+    harness.driver.handleContentSizeChange();
     harness.driver.handleViewportMetricsChange({
       previousViewportWidth: 800,
       viewportWidth: 640,
@@ -356,7 +353,9 @@ describe("bottom anchor controller driver", () => {
     expect(harness.scrollAttempts).toHaveLength(0);
   });
 
-  it("pauses sticky maintenance while a user scroll owns the viewport", () => {
+  // While following, the list keeps its end through every content change, so a drag that kept
+  // following would see each streamed line move the rows under the finger.
+  it("stops following while a user scroll owns the viewport", () => {
     const harness = createDriverHarness({
       transportBehavior: {
         verificationDelayFrames: 2,
@@ -364,12 +363,8 @@ describe("bottom anchor controller driver", () => {
       },
     });
 
-    harness.driver.prepareForStickyContentChange();
     harness.driver.beginUserScroll();
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 1200,
-      contentHeight: 1400,
-    });
+    harness.driver.handleContentSizeChange();
     harness.context.nearBottom = false;
     harness.driver.handleScrollNearBottomChange({
       nextIsNearBottom: false,
@@ -377,19 +372,29 @@ describe("bottom anchor controller driver", () => {
     });
     harness.scheduler.flushAll();
 
-    expect(harness.scrollAttempts).toHaveLength(1);
-    expect(harness.driver.getSnapshot()).toMatchObject({
-      mode: "sticky-bottom",
-      pendingRequest: null,
-      pendingVerification: null,
-    });
+    expect(harness.scrollAttempts).toHaveLength(0);
+    expect(harness.driver.getSnapshot().mode).toBe("detached");
 
-    harness.driver.endUserScroll({ isNearBottom: false });
+    harness.driver.endUserScroll({ isAtEnd: false });
 
     expect(harness.driver.getSnapshot().mode).toBe("detached");
   });
 
-  it("restores sticky maintenance when a user scroll returns to the bottom", () => {
+  // Resuming would scroll by the distance left to the end in one frame, right after the release.
+  it("stays detached when a user scroll ends near the end but short of it", () => {
+    const harness = createDriverHarness();
+
+    harness.driver.beginUserScroll();
+    harness.context.nearBottom = true;
+    harness.driver.handleContentSizeChange();
+    harness.driver.endUserScroll({ isAtEnd: false });
+    harness.scheduler.flushAll();
+
+    expect(harness.driver.getSnapshot().mode).toBe("detached");
+    expect(harness.scrollAttempts).toHaveLength(0);
+  });
+
+  it("resumes following when a user scroll ends at the end", () => {
     const harness = createDriverHarness({
       transportBehavior: {
         verificationDelayFrames: 2,
@@ -403,16 +408,13 @@ describe("bottom anchor controller driver", () => {
       nextIsNearBottom: false,
       scrollDelta: 48,
     });
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 1200,
-      contentHeight: 1400,
-    });
+    harness.driver.handleContentSizeChange();
     harness.context.nearBottom = true;
     harness.driver.handleScrollNearBottomChange({
       nextIsNearBottom: true,
       scrollDelta: -48,
     });
-    harness.driver.endUserScroll({ isNearBottom: true });
+    harness.driver.endUserScroll({ isAtEnd: true });
     harness.scheduler.flushAll();
 
     expect(harness.driver.getSnapshot()).toMatchObject({
@@ -420,7 +422,55 @@ describe("bottom anchor controller driver", () => {
       pendingRequest: null,
       pendingVerification: null,
     });
-    expect(harness.scrollAttempts).toHaveLength(1);
+    // Following stopped for the gesture, so content that arrived meanwhile left the end below it.
+    expect(harness.scrollAttempts).toEqual([false]);
+  });
+
+  it("holds a disclosure detached and resumes following when it is released at the end", () => {
+    const harness = createDriverHarness({
+      transportBehavior: {
+        verificationDelayFrames: 2,
+        verificationRetryMode: "recheck",
+      },
+    });
+
+    harness.driver.holdForDisclosure();
+    harness.driver.handleContentSizeChange();
+    harness.driver.handleScrollNearBottomChange({
+      nextIsNearBottom: true,
+      scrollDelta: -12,
+    });
+    harness.scheduler.flushAll();
+
+    expect(harness.driver.getSnapshot().mode).toBe("detached");
+    expect(harness.scrollAttempts).toHaveLength(0);
+
+    harness.driver.releaseDisclosure({ isAtEnd: true });
+    harness.scheduler.flushAll();
+
+    expect(harness.driver.getSnapshot().mode).toBe("sticky-bottom");
+  });
+
+  it("stays detached when a disclosure is released away from the end", () => {
+    const harness = createDriverHarness();
+
+    harness.driver.holdForDisclosure();
+    harness.driver.releaseDisclosure({ isAtEnd: false });
+    harness.scheduler.flushAll();
+
+    expect(harness.driver.getSnapshot().mode).toBe("detached");
+    expect(harness.scrollAttempts).toHaveLength(0);
+  });
+
+  it("leaves a disclosure release to a user scroll that owns the viewport", () => {
+    const harness = createDriverHarness();
+
+    harness.driver.holdForDisclosure();
+    harness.driver.beginUserScroll();
+    harness.driver.releaseDisclosure({ isAtEnd: true });
+    harness.scheduler.flushAll();
+
+    expect(harness.driver.getSnapshot().mode).toBe("detached");
   });
 
   it("switches back to sticky-bottom for explicit jump-to-bottom", () => {
@@ -441,7 +491,7 @@ describe("bottom anchor controller driver", () => {
     expect(harness.driver.getSnapshot().mode).toBe("sticky-bottom");
   });
 
-  it("schedules sticky maintenance on viewport and content growth", () => {
+  it("scrolls for a viewport resize while following", () => {
     const harness = createDriverHarness();
 
     harness.driver.handleViewportMetricsChange({
@@ -452,13 +502,44 @@ describe("bottom anchor controller driver", () => {
     });
     harness.scheduler.flushAll();
 
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 1200,
-      contentHeight: 1600,
+    expect(harness.scrollAttempts).toHaveLength(1);
+  });
+
+  it("never scrolls for a content change while following", () => {
+    const harness = createDriverHarness({
+      transportBehavior: {
+        verificationDelayFrames: 2,
+        verificationRetryMode: "recheck",
+      },
     });
+
+    harness.context.measurementState.contentHeight = 1600;
+    harness.driver.handleContentSizeChange();
+    harness.context.measurementState.contentHeight = 1250;
+    harness.driver.handleContentSizeChange();
     harness.scheduler.flushAll();
 
-    expect(harness.scrollAttempts).toHaveLength(2);
+    expect(harness.scrollAttempts).toHaveLength(0);
+    expect(harness.driver.getSnapshot()).toMatchObject({
+      mode: "sticky-bottom",
+      pendingRequest: null,
+      pendingVerification: null,
+    });
+  });
+
+  it("detaches when the user scrolls away after a content change", () => {
+    const harness = createDriverHarness();
+
+    harness.context.measurementState.contentHeight = 1600;
+    harness.driver.handleContentSizeChange();
+    harness.context.nearBottom = false;
+    harness.driver.handleScrollNearBottomChange({
+      nextIsNearBottom: false,
+      scrollDelta: 4,
+    });
+
+    expect(harness.driver.getSnapshot().mode).toBe("detached");
+    expect(harness.scrollAttempts).toHaveLength(0);
   });
 
   it("keeps a pending request blocked when stale container measurements arrive", () => {
@@ -556,10 +637,7 @@ describe("bottom anchor controller driver", () => {
 
     harness.context.measurementState.contentHeight = 14804;
     harness.context.nearBottom = false;
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 14322,
-      contentHeight: 14804,
-    });
+    harness.driver.handleContentSizeChange();
 
     harness.scheduler.flushFrame();
 
@@ -628,10 +706,7 @@ describe("bottom anchor controller driver", () => {
 
     harness.context.measurementState.contentHeight = 16230;
     harness.context.nearBottom = false;
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 14322,
-      contentHeight: 16230,
-    });
+    harness.driver.handleContentSizeChange();
 
     harness.scheduler.flushFrame();
     harness.scheduler.flushFrame();
@@ -685,136 +760,6 @@ describe("bottom anchor controller driver", () => {
 
     expect(harness.driver.getSnapshot().mode).toBe("detached");
   });
-
-  it("keeps sticky-bottom during streaming growth until bottom is re-verified", () => {
-    const harness = createDriverHarness();
-    harness.context.nearBottom = false;
-    harness.setScrollToBottomBehavior(() => {
-      harness.context.measurementState.offsetY = 900;
-    });
-
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 1200,
-      contentHeight: 1400,
-    });
-    harness.scheduler.flushAll();
-
-    expect(harness.scrollAttempts).toHaveLength(4);
-    expect(harness.driver.getSnapshot()).toMatchObject({
-      mode: "sticky-bottom",
-      pendingRequest: null,
-      pendingVerification: null,
-    });
-
-    harness.driver.handleScrollNearBottomChange({
-      nextIsNearBottom: false,
-      scrollDelta: 0,
-    });
-
-    expect(harness.driver.getSnapshot().mode).toBe("sticky-bottom");
-
-    harness.context.nearBottom = true;
-    harness.driver.handleScrollNearBottomChange({
-      nextIsNearBottom: true,
-      scrollDelta: 0,
-    });
-    harness.scheduler.flushAll();
-    harness.driver.handleScrollNearBottomChange({
-      nextIsNearBottom: false,
-      scrollDelta: 64,
-    });
-
-    expect(harness.driver.getSnapshot().mode).toBe("detached");
-  });
-
-  it("keeps initial native content growth anchored before layout scroll events arrive", () => {
-    const harness = createDriverHarness({
-      transportBehavior: {
-        verificationDelayFrames: 2,
-        verificationRetryMode: "recheck",
-      },
-      measurementState: createMeasurementState({
-        containerKey: "native-virtualized",
-        viewportWidth: 0,
-        viewportHeight: 0,
-        contentHeight: 0,
-        offsetY: 0,
-        viewportMeasuredForKey: null,
-        contentMeasuredForKey: null,
-      }),
-    });
-    harness.setScrollToBottomBehavior(() => {
-      harness.context.measurementState.offsetY = 0;
-    });
-
-    harness.context.measurementState.contentHeight = 1348;
-    harness.context.measurementState.contentMeasuredForKey = "native-virtualized";
-    harness.driver.handleContentSizeChange({
-      previousContentHeight: 0,
-      contentHeight: 1348,
-    });
-
-    expect(harness.scrollAttempts).toHaveLength(1);
-    expect(harness.driver.getSnapshot()).toMatchObject({
-      mode: "sticky-bottom",
-      pendingVerification: {
-        requestId: null,
-      },
-    });
-
-    harness.context.measurementState.viewportWidth = 390;
-    harness.context.measurementState.viewportHeight = 546;
-    harness.context.measurementState.viewportMeasuredForKey = "native-virtualized";
-    harness.context.measurementState.offsetY = 50;
-    harness.context.nearBottom = false;
-    harness.driver.handleScrollNearBottomChange({
-      nextIsNearBottom: false,
-      scrollDelta: 50,
-    });
-
-    expect(harness.driver.getSnapshot().mode).toBe("sticky-bottom");
-  });
-
-  it("keeps native sticky content changes anchored when measured height is unchanged", () => {
-    const harness = createDriverHarness({
-      transportBehavior: {
-        verificationDelayFrames: 2,
-        verificationRetryMode: "recheck",
-      },
-      measurementState: createMeasurementState({
-        containerKey: "native-virtualized",
-        viewportWidth: 390,
-        viewportHeight: 546,
-        contentHeight: 546,
-        offsetY: 0,
-        viewportMeasuredForKey: "native-virtualized",
-        contentMeasuredForKey: "native-virtualized",
-      }),
-    });
-    harness.setScrollToBottomBehavior(() => {
-      harness.context.measurementState.offsetY = 0;
-      harness.context.nearBottom = true;
-    });
-
-    harness.driver.prepareForStickyContentChange();
-
-    expect(harness.scrollAttempts).toHaveLength(1);
-    expect(harness.driver.getSnapshot()).toMatchObject({
-      mode: "sticky-bottom",
-      pendingVerification: {
-        requestId: null,
-      },
-    });
-
-    harness.context.measurementState.offsetY = 50;
-    harness.context.nearBottom = false;
-    harness.driver.handleScrollNearBottomChange({
-      nextIsNearBottom: false,
-      scrollDelta: 50,
-    });
-
-    expect(harness.driver.getSnapshot().mode).toBe("sticky-bottom");
-  });
 });
 
 describe("controller helper predicates", () => {
@@ -864,13 +809,6 @@ describe("controller helper predicates", () => {
   it("suppresses auto-anchor helpers while detached", () => {
     const mode: BottomAnchorMode = "detached";
 
-    expect(
-      __private__.shouldRestickOnContentChange({
-        mode,
-        previousContentHeight: 1000,
-        contentHeight: 1100,
-      }),
-    ).toBe(false);
     expect(
       __private__.shouldRestickOnViewportChange({
         mode,

packages/app/src/agent-stream/bottom-anchor-controller.ts

@@ -69,20 +69,18 @@ interface BottomAnchorControllerDriver {
   applyRouteRequest: (request: BottomAnchorRouteRequest | null) => void;
   requestLocalAnchor: (request: BottomAnchorLocalRequest) => void;
   beginUserScroll: () => void;
-  endUserScroll: (params: { isNearBottom: boolean }) => void;
+  endUserScroll: (params: { isAtEnd: boolean }) => void;
   detachByUser: () => void;
+  holdForDisclosure: () => void;
+  releaseDisclosure: (params: { isAtEnd: boolean }) => void;
   handleViewportMetricsChange: (params: {
     previousViewportWidth: number;
     viewportWidth: number;
     previousViewportHeight: number;
     viewportHeight: number;
   }) => void;
-  handleContentSizeChange: (params: {
-    previousContentHeight: number;
-    contentHeight: number;
-  }) => void;
+  handleContentSizeChange: () => void;
   prepareForStickyViewportChange: () => void;
-  prepareForStickyContentChange: () => void;
   handleScrollNearBottomChange: (params: {
     nextIsNearBottom: boolean;
     scrollDelta: number;
@@ -415,6 +413,7 @@ function createBottomAnchorControllerDriver(
       | "content_size_change"
       | "scroll_near_bottom_change"
       | "user_scroll_end"
+      | "disclosure_released"
       | "history_readiness_change"
       | "manual_reevaluate"
       | "retry_scroll",
@@ -505,13 +504,19 @@ function createBottomAnchorControllerDriver(
     requestLocalAnchor(request) {
       createRequest(request);
     },
+    // The gesture owns the viewport, so following stops until it ends: content growing at the end
+    // must not move the rows under the finger. The gesture's end decides whether following resumes.
     beginUserScroll() {
       isUserScrollActive = true;
       cancelPendingAttempt();
+      setModeInternal("detached");
     },
+    // Following resumes only for a gesture that ends at the end. Resuming from short of it would
+    // scroll the rows the finger just let go of, so a release above the end, or with output that
+    // arrived below it during the gesture, stays detached with the pill.
     endUserScroll(params) {
       isUserScrollActive = false;
-      if (params.isNearBottom) {
+      if (params.isAtEnd) {
         if (mode === "detached") {
           setModeInternal("sticky-bottom");
           pendingVerification = { requestId: null, retries: 0 };
@@ -533,9 +538,8 @@ function createBottomAnchorControllerDriver(
         markStickyMeasurementVerified();
         return;
       }
-      if (mode === "sticky-bottom") {
-        this.detachByUser();
-      }
+      cancelPendingRequest("user_scrolled_away");
+      setModeInternal("detached");
     },
     detachByUser() {
       if (mode === "detached") {
@@ -544,6 +548,21 @@ function createBottomAnchorControllerDriver(
       cancelPendingRequest("user_scrolled_away");
       setModeInternal("detached");
     },
+    // A disclosure keeps its trigger in place, so following output stops while it applies.
+    holdForDisclosure() {
+      cancelPendingRequest("disclosure");
+      setModeInternal("detached");
+    },
+    // Following resumes only if the applied change left the list at its end. Scroll events
+    // during the hold never re-stick: before the change lands the list is still at the end.
+    releaseDisclosure(params) {
+      if (isUserScrollActive || mode !== "detached" || !params.isAtEnd) {
+        return;
+      }
+      setModeInternal("sticky-bottom");
+      pendingVerification = { requestId: null, retries: 0 };
+      evaluate(false, "disclosure_released");
+    },
     handleViewportMetricsChange(params) {
       if (
         params.previousViewportWidth !== params.viewportWidth ||
@@ -568,30 +587,13 @@ function createBottomAnchorControllerDriver(
         evaluate(false, "viewport_change");
       }
     },
-    handleContentSizeChange(params) {
-      if (params.previousContentHeight !== params.contentHeight) {
-        markStickyMeasurementChanged();
-      }
-      if (isUserScrollActive) {
+    // The list keeps its own end through content changes while following, so a change in content
+    // height never scrolls from here. It only gives a pending jump another look at the new geometry.
+    handleContentSizeChange() {
+      if (isUserScrollActive || !pendingRequest) {
         return;
       }
-      const shouldRestick = __private__.shouldRestickOnContentChange({
-        mode,
-        previousContentHeight: params.previousContentHeight,
-        contentHeight: params.contentHeight,
-      });
-      if (shouldRestick && !pendingRequest) {
-        pendingVerification = { requestId: null, retries: 0 };
-        if (attemptHandle) {
-          input.cancelFrame(attemptHandle);
-          attemptHandle = null;
-        }
-        runAttempt(false);
-        return;
-      }
-      if (shouldRestick || pendingRequest) {
-        evaluate(false, "content_size_change");
-      }
+      evaluate(false, "content_size_change");
     },
     prepareForStickyViewportChange() {
       if (mode !== "sticky-bottom") {
@@ -599,25 +601,6 @@ function createBottomAnchorControllerDriver(
       }
       markStickyMeasurementChanged();
     },
-    prepareForStickyContentChange() {
-      if (mode !== "sticky-bottom") {
-        return;
-      }
-      markStickyMeasurementChanged();
-      if (isUserScrollActive) {
-        return;
-      }
-      if (!pendingRequest) {
-        pendingVerification = { requestId: null, retries: 0 };
-        if (attemptHandle) {
-          input.cancelFrame(attemptHandle);
-          attemptHandle = null;
-        }
-        runAttempt(false);
-        return;
-      }
-      evaluate(false, "content_size_change");
-    },
     handleScrollNearBottomChange(params) {
       const { nextIsNearBottom, scrollDelta } = params;
       if (isUserScrollActive) {
@@ -695,13 +678,6 @@ export const __private__ = {
           input.previousViewportWidth !== input.viewportWidth))
     );
   },
-  shouldRestickOnContentChange(input: {
-    mode: BottomAnchorMode;
-    previousContentHeight: number;
-    contentHeight: number;
-  }): boolean {
-    return input.mode === "sticky-bottom" && input.contentHeight > input.previousContentHeight;
-  },
   shouldDetachFromScrollAway(input: {
     mode: BottomAnchorMode;
     nextIsNearBottom: boolean;
@@ -792,12 +768,18 @@ export function useBottomAnchorController(input: {
     beginUserScroll() {
       driverRef.current?.beginUserScroll();
     },
-    endUserScroll(params: { isNearBottom: boolean }) {
+    endUserScroll(params: { isAtEnd: boolean }) {
       driverRef.current?.endUserScroll(params);
     },
     detachByUser() {
       driverRef.current?.detachByUser();
     },
+    holdForDisclosure() {
+      driverRef.current?.holdForDisclosure();
+    },
+    releaseDisclosure(params: { isAtEnd: boolean }) {
+      driverRef.current?.releaseDisclosure(params);
+    },
     handleViewportLayout() {},
     handleViewportMetricsChange(params: {
       previousViewportWidth: number;
@@ -807,15 +789,12 @@ export function useBottomAnchorController(input: {
     }) {
       driverRef.current?.handleViewportMetricsChange(params);
     },
-    handleContentSizeChange(params: { previousContentHeight: number; contentHeight: number }) {
-      driverRef.current?.handleContentSizeChange(params);
+    handleContentSizeChange() {
+      driverRef.current?.handleContentSizeChange();
     },
     prepareForStickyViewportChange() {
       driverRef.current?.prepareForStickyViewportChange();
     },
-    prepareForStickyContentChange() {
-      driverRef.current?.prepareForStickyContentChange();
-    },
     handleScrollNearBottomChange(params: { nextIsNearBottom: boolean; scrollDelta: number }) {
       driverRef.current?.handleScrollNearBottomChange(params);
     },

packages/app/src/agent-stream/chat-find/viewport.browser.test.ts

@@ -24,7 +24,9 @@ function viewport(root: HTMLElement, capture: Capture) {
   const handle: StreamViewportHandle = {
     scrollToBottom() {},
     prepareForViewportChange() {},
-    holdReadingPosition() {},
+    holdRow(_rowId, apply) {
+      apply();
+    },
     scrollToMessage(_messageId, occurrence) {
       if (occurrence) capture.occurrence = occurrence;
     },

packages/app/src/agent-stream/chat-outline/use-chat-outline.test.tsx

@@ -265,7 +265,7 @@ describe("useChatOutline", () => {
     const viewport: StreamViewportHandle = {
       scrollToBottom: vi.fn(),
       prepareForViewportChange: vi.fn(),
-      holdReadingPosition: vi.fn(),
+      holdRow: vi.fn(),
       scrollToMessage,
     };
     const viewportRef = { current: viewport };
@@ -317,7 +317,7 @@ describe("useChatOutline", () => {
       current: {
         scrollToBottom: vi.fn(),
         prepareForViewportChange: vi.fn(),
-        holdReadingPosition: vi.fn(),
+        holdRow: vi.fn(),
         scrollToMessage,
       },
     };
@@ -373,7 +373,7 @@ describe("useChatOutline", () => {
     const viewport: StreamViewportHandle = {
       scrollToBottom: vi.fn(),
       prepareForViewportChange: vi.fn(),
-      holdReadingPosition: vi.fn(),
+      holdRow: vi.fn(),
       scrollToMessage,
     };
     const livePrompt = {

packages/app/src/agent-stream/disclosure.tsx

@@ -0,0 +1,40 @@
+import { createContext, useContext, useMemo, type ReactNode, type RefObject } from "react";
+import type { StreamViewportHandle } from "./strategy";
+
+/**
+ * Runs a disclosure's state change. Inside a timeline row, the row that owns the
+ * trigger keeps its screen position through the change; elsewhere `apply` runs as is.
+ */
+export type DisclosureHold = (apply: () => void) => void;
+
+const applyInPlace: DisclosureHold = (apply) => apply();
+
+const DisclosureHoldContext = createContext<DisclosureHold>(applyInPlace);
+
+export function DisclosureRow({
+  rowId,
+  viewportRef,
+  children,
+}: {
+  rowId: string;
+  viewportRef: RefObject<StreamViewportHandle | null>;
+  children: ReactNode;
+}) {
+  const hold = useMemo<DisclosureHold>(
+    () => (apply) => {
+      const viewport = viewportRef.current;
+      if (viewport) {
+        viewport.holdRow(rowId, apply);
+      } else {
+        apply();
+      }
+    },
+    [rowId, viewportRef],
+  );
+  return <DisclosureHoldContext.Provider value={hold}>{children}</DisclosureHoldContext.Provider>;
+}
+
+/** Call with the toggle's state change: `hold(() => setExpanded(!expanded))`. */
+export function useDisclosureHold(): DisclosureHold {
+  return useContext(DisclosureHoldContext);
+}

packages/app/src/agent-stream/footer-spacing.test.ts

@@ -3,32 +3,13 @@ import type { TurnTiming } from "@/timeline/turn-time";
 import type { StreamItem } from "@/types/stream";
 import { layoutStream } from "./layout";
 import type { StreamStrategy } from "./strategy";
+import { resolveStreamRenderStrategy } from "./strategy-resolver";
 
 function strategyFor(platform: "web" | "native"): StreamStrategy {
-  const inverted = platform === "native";
-  const neighborStep = inverted ? 1 : -1;
-  const getHistoryBoundaryIndex = (items: StreamItem[]) => {
-    if (items.length === 0) return null;
-    return inverted ? 0 : items.length - 1;
-  };
-  const getLiveHeadBoundaryIndex = (items: StreamItem[]) => {
-    if (items.length === 0) return null;
-    return inverted ? items.length - 1 : 0;
-  };
-  return {
-    orderTail: (items) => (inverted ? [...items].toReversed() : items),
-    orderHead: (items) => (inverted ? [...items].toReversed() : items),
-    getNeighborIndex: (index, relation) =>
-      relation === "above" ? index + neighborStep : index - neighborStep,
-    getNeighborItem: (items, index, relation) => {
-      const neighborIndex = relation === "above" ? index + neighborStep : index - neighborStep;
-      return items[neighborIndex];
-    },
-    getHistoryLiveBoundaryIndex: getHistoryBoundaryIndex,
-    getLiveHeadHistoryBoundaryIndex: getLiveHeadBoundaryIndex,
-    getLatestItemIndex: getHistoryBoundaryIndex,
-    getFrameChildOrder: () => (inverted ? "footer-then-content" : "content-then-footer"),
-  } as StreamStrategy;
+  return resolveStreamRenderStrategy({
+    platform: platform === "native" ? "android" : "web",
+    isMobileBreakpoint: false,
+  });
 }
 
 function userMessage(id: string): Extract<StreamItem, { kind: "user_message" }> {

packages/app/src/agent-stream/layout.test.ts

@@ -289,7 +289,7 @@ describe("layoutStream", () => {
     expect(layout.auxiliaryTurnFooter).toBeNull();
     expect(assistantRow.completedFooter?.itemId).toBe(assistant.id);
     expect(assistantRow.belowItem?.id).toBe("u2");
-    expect(assistantRow.frameOrder).toBe("footer-then-content");
+    expect(assistantRow.frameOrder).toBe("content-then-footer");
   });
 
   it("keeps an accepted steer inline while its canonical turn is active", () => {

packages/app/src/agent-stream/legend-list-held-row.browser.test.tsx

@@ -0,0 +1,171 @@
+import { LegendList, type LegendListRef } from "@legendapp/list/react-native";
+import React, { act, useSyncExternalStore } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { View } from "react-native";
+import { afterEach, beforeEach, expect, it } from "vitest";
+
+// The native chat timeline runs on the patched LegendList (patches/@legendapp+list+3.7.1.patch).
+// A disclosure hold keeps only the held row in place: `shouldRestorePosition` accepts no other row.
+// The native build applies its scroll adjustments through native scroll props that
+// react-native-web ignores, so these tests read the offset LegendList holds, not the DOM's.
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+
+const VIEWPORT_HEIGHT = 100;
+
+interface Row {
+  id: string;
+  height: number;
+}
+
+let root: Root;
+let host: HTMLDivElement;
+
+beforeEach(() => {
+  host = document.createElement("div");
+  host.style.cssText = `display:flex;flex-direction:column;width:300px;height:${VIEWPORT_HEIGHT}px`;
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  grownHeights.clear();
+  host.remove();
+});
+
+function wait(ms: number): Promise<void> {
+  return act(() => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+}
+
+const LIST_STYLE = { flex: 1 };
+const rowStyles = new Map<number, { height: number }>();
+
+function rowStyle(height: number) {
+  let style = rowStyles.get(height);
+  if (!style) {
+    style = { height };
+    rowStyles.set(height, style);
+  }
+  return style;
+}
+
+// A row that changes its own height without a data change, like a todo card toggling its details.
+const grownHeights = new Map<string, number>();
+const heightListeners = new Set<() => void>();
+
+function subscribeToHeights(listener: () => void) {
+  heightListeners.add(listener);
+  return () => heightListeners.delete(listener);
+}
+
+function growRow(id: string, height: number) {
+  grownHeights.set(id, height);
+  for (const listener of heightListeners) listener();
+}
+
+function RowView({ row }: { row: Row }) {
+  const height = useSyncExternalStore(
+    subscribeToHeights,
+    () => grownHeights.get(row.id) ?? row.height,
+  );
+  return <View style={rowStyle(height)} />;
+}
+
+function renderRow({ item }: { item: Row }) {
+  return <RowView row={item} />;
+}
+
+function holdOnly(heldRowId: string) {
+  return {
+    data: true,
+    size: true,
+    shouldRestorePosition: (item: Row) => item.id === heldRowId,
+  };
+}
+
+function keyExtractor(item: Row) {
+  return item.id;
+}
+
+function mountList(heldRowId: string) {
+  const listRef = React.createRef<LegendListRef>();
+  const maintainVisibleContentPosition = holdOnly(heldRowId);
+  const render = (data: Row[]) =>
+    act(() =>
+      root.render(
+        <LegendList
+          ref={listRef}
+          data={data}
+          renderItem={renderRow}
+          keyExtractor={keyExtractor}
+          estimatedItemSize={40}
+          recycleItems={false}
+          scrollEventThrottle={16}
+          maintainVisibleContentPosition={maintainVisibleContentPosition}
+          style={LIST_STYLE}
+        />,
+      ),
+    );
+  const scrollElement = () => {
+    const scroller = [...host.querySelectorAll<HTMLElement>("div")].find(
+      (element) => element.scrollHeight > element.clientHeight + 1,
+    );
+    if (!scroller) throw new Error("The list has no scroll element");
+    return scroller;
+  };
+  // Small steps: a large jump suspends LegendList's anchoring until the rows re-measure.
+  const scrollTo = async (offset: number) => {
+    for (let step = 20; step <= offset; step += 20) {
+      scrollElement().scrollTop = step;
+      await wait(150);
+    }
+  };
+  const heldRowTop = () => {
+    const state = listRef.current?.getState();
+    const position = state?.positionByKey(heldRowId);
+    if (state === undefined || position === undefined) {
+      throw new Error("The held row is not laid out");
+    }
+    return position - state.scroll;
+  };
+  return { render, scrollTo, heldRowTop };
+}
+
+it("anchors a data change on a held row whose top is above the viewport", async () => {
+  // The held row is a turn host whose prompt bubble is cut off at the top of the viewport, with a
+  // fully visible row below it. LegendList's ids in view start at that fully visible row.
+  const rows: Row[] = Array.from({ length: 10 }, (_, index) => ({
+    id: `row-${index}`,
+    height: index === 3 ? 60 : 40,
+  }));
+  const list = mountList("row-3");
+  list.render(rows);
+  await wait(150);
+  await list.scrollTo(140);
+  expect(list.heldRowTop()).toBe(-20);
+
+  const inserted: Row = { id: "inserted", height: 30 };
+  list.render([...rows.slice(0, 2), inserted, ...rows.slice(2)]);
+  await wait(150);
+
+  expect(list.heldRowTop()).toBe(-20);
+});
+
+it("anchors a size change on a held row whose top is above the viewport", async () => {
+  // The same cut-off row grows from its own state, so LegendList sees a size change only.
+  const rows: Row[] = Array.from({ length: 10 }, (_, index) => ({
+    id: `row-${index}`,
+    height: index === 3 ? 60 : 40,
+  }));
+  const list = mountList("row-3");
+  list.render(rows);
+  await wait(150);
+  await list.scrollTo(140);
+  expect(list.heldRowTop()).toBe(-20);
+
+  act(() => growRow("row-3", 260));
+  await wait(150);
+
+  expect(list.heldRowTop()).toBe(-20);
+});

packages/app/src/agent-stream/model.test.ts

@@ -47,7 +47,7 @@ describe("buildAgentStreamRenderModel", () => {
       historyStart: 2,
     });
 
-    expect(model.history.map((item) => item.id)).toEqual(["a3", "u3", "a2", "u2"]);
+    expect(model.history.map((item) => item.id)).toEqual(["u2", "a2", "u3", "a3"]);
     expect(model.segments.historyVirtualized).toHaveLength(0);
   });
 
@@ -98,7 +98,7 @@ describe("buildAgentStreamRenderModel", () => {
       historyStart,
     });
 
-    expect(model.history.map((item) => item.id)).toEqual(["visible-a", "visible-u"]);
+    expect(model.history.map((item) => item.id)).toEqual(["visible-u", "visible-a"]);
   });
 
   it("keeps head separate from committed history on desktop web", () => {
@@ -207,7 +207,7 @@ describe("buildAgentStreamRenderModel", () => {
     });
   });
 
-  it("derives the same timing for native inverted rendering", () => {
+  it("derives the same timing on native", () => {
     const tail = [userMessage("u1", 1), assistantMessage("a1", 4)];
 
     const model = buildAgentStreamRenderModel({
@@ -219,7 +219,7 @@ describe("buildAgentStreamRenderModel", () => {
       isMobileBreakpoint: false,
     });
 
-    expect(model.segments.historyMounted.map((item) => item.id)).toEqual(["a1", "u1"]);
+    expect(model.segments.historyMounted.map((item) => item.id)).toEqual(["u1", "a1"]);
     expect(model.turnTiming.byItemId.get("a1")).toEqual({
       completedAt: tail[1]?.timestamp,
       durationMs: 3000,

packages/app/src/agent-stream/native-disclosure-hold.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { createNativeDisclosureHold } from "./native-disclosure-hold";
+
+function createFrames() {
+  let nextId = 1;
+  const pending = new Map<number, () => void>();
+  return {
+    requestFrame: (callback: () => void) => {
+      const id = nextId++;
+      pending.set(id, callback);
+      return id;
+    },
+    cancelFrame: (id: number) => {
+      pending.delete(id);
+    },
+    runFrame: () => {
+      const callbacks = [...pending.values()];
+      pending.clear();
+      for (const callback of callbacks) {
+        callback();
+      }
+    },
+  };
+}
+
+function createHarness() {
+  const frames = createFrames();
+  const releases: string[] = [];
+  const hold = createNativeDisclosureHold({
+    quietFrames: 2,
+    requestFrame: frames.requestFrame,
+    cancelFrame: frames.cancelFrame,
+    onRelease: () => releases.push("released"),
+  });
+  return { frames, hold, releases };
+}
+
+describe("native disclosure hold", () => {
+  it("holds the row until two frames pass without an item size change", () => {
+    const { frames, hold, releases } = createHarness();
+
+    hold.hold("turn-1");
+    frames.runFrame();
+
+    expect(hold.heldRowId()).toBe("turn-1");
+    expect(releases).toEqual([]);
+
+    frames.runFrame();
+
+    expect(hold.heldRowId()).toBeNull();
+    expect(releases).toEqual(["released"]);
+  });
+
+  it("restarts the quiet frames on every item size change", () => {
+    const { frames, hold, releases } = createHarness();
+
+    hold.hold("turn-1");
+    frames.runFrame();
+    hold.noteItemSizeChanged();
+    frames.runFrame();
+
+    expect(releases).toEqual([]);
+
+    frames.runFrame();
+
+    expect(releases).toEqual(["released"]);
+  });
+
+  it("ignores item size changes outside a hold", () => {
+    const { frames, hold, releases } = createHarness();
+
+    hold.noteItemSizeChanged();
+    frames.runFrame();
+    frames.runFrame();
+
+    expect(releases).toEqual([]);
+  });
+
+  it("moves the hold to the latest toggled row and releases once", () => {
+    const { frames, hold, releases } = createHarness();
+
+    hold.hold("turn-1");
+    frames.runFrame();
+    hold.hold("turn-2");
+
+    expect(hold.heldRowId()).toBe("turn-2");
+
+    frames.runFrame();
+    frames.runFrame();
+
+    expect(releases).toEqual(["released"]);
+  });
+
+  it("drops the hold without releasing when cancelled", () => {
+    const { frames, hold, releases } = createHarness();
+
+    hold.hold("turn-1");
+    hold.cancel();
+    frames.runFrame();
+    frames.runFrame();
+
+    expect(hold.heldRowId()).toBeNull();
+    expect(releases).toEqual([]);
+  });
+});

packages/app/src/agent-stream/native-disclosure-hold.ts

@@ -0,0 +1,64 @@
+/**
+ * The native viewport's disclosure hold. While a row is held, it is the only row the list may
+ * anchor on. The hold ends once item sizes stop changing for `quietFrames` frames: the list
+ * measures the toggled row and any rows it inserted over one or more frames, and end following
+ * must not resume between the change and the list's last layout correction.
+ */
+export interface NativeDisclosureHold {
+  heldRowId(): string | null;
+  hold(rowId: string): void;
+  noteItemSizeChanged(): void;
+  cancel(): void;
+}
+
+export function createNativeDisclosureHold(input: {
+  quietFrames: number;
+  requestFrame: (callback: () => void) => number;
+  cancelFrame: (id: number) => void;
+  onRelease: () => void;
+}): NativeDisclosureHold {
+  let heldRowId: string | null = null;
+  let frameId: number | null = null;
+  let remainingFrames = 0;
+
+  const stopCountdown = () => {
+    if (frameId !== null) {
+      input.cancelFrame(frameId);
+      frameId = null;
+    }
+  };
+
+  const tick = () => {
+    remainingFrames -= 1;
+    if (remainingFrames > 0) {
+      frameId = input.requestFrame(tick);
+      return;
+    }
+    frameId = null;
+    heldRowId = null;
+    input.onRelease();
+  };
+
+  const restartCountdown = () => {
+    stopCountdown();
+    remainingFrames = input.quietFrames;
+    frameId = input.requestFrame(tick);
+  };
+
+  return {
+    heldRowId: () => heldRowId,
+    hold(rowId) {
+      heldRowId = rowId;
+      restartCountdown();
+    },
+    noteItemSizeChanged() {
+      if (heldRowId !== null) {
+        restartCountdown();
+      }
+    },
+    cancel() {
+      stopCountdown();
+      heldRowId = null;
+    },
+  };
+}

packages/app/src/agent-stream/native-end-pin.tsx

@@ -0,0 +1,61 @@
+import { forwardRef, type ReactNode } from "react";
+import {
+  Animated,
+  type ScrollView,
+  type ScrollViewProps,
+  View,
+  type ViewStyle,
+} from "react-native";
+
+// While the stream follows its end, React Native's native content-position keeping holds a
+// zero-height view at the bottom of the content still. It runs on the UI thread around each mount,
+// so a row that grows or lands at the end scrolls in the same frame it lays out. LegendList's
+// `maintainScrollAtEnd` scrolls from JS after the mount, which paints the growth below the viewport
+// for a frame or more first.
+//
+// The anchor has to be the content's first native child: content-position keeping anchors on the
+// first child at or after `minIndexForVisible` that reaches into the viewport, and every child
+// LegendList renders can be flattened away. Absolute positioning keeps it out of the flow.
+//
+// A drag owns the offset from the frame it begins, but the pin stays until JS stops following a
+// round trip later. The scroll view subclasses in `modules/paseo-scroll` recognise the pin by its
+// native ID and skip its correction while the user drags, so a line mounting in those frames grows
+// below the rows under the finger.
+const END_PIN_NATIVE_ID = "paseo-end-pin";
+const END_ANCHOR_STYLE: ViewStyle = {
+  position: "absolute",
+  bottom: 0,
+  left: 0,
+  height: 0,
+  width: 0,
+};
+const END_ANCHOR_POSITION = { minIndexForVisible: 0 };
+
+interface EndPinnedScrollViewProps extends ScrollViewProps {
+  pinEnd: boolean;
+  children?: ReactNode;
+}
+
+export const EndPinnedScrollView = forwardRef<ScrollView, EndPinnedScrollViewProps>(
+  function EndPinnedScrollView({ pinEnd, children, maintainVisibleContentPosition, ...rest }, ref) {
+    return (
+      <Animated.ScrollView
+        {...rest}
+        ref={ref}
+        maintainVisibleContentPosition={
+          pinEnd ? END_ANCHOR_POSITION : maintainVisibleContentPosition
+        }
+      >
+        {pinEnd ? (
+          <View
+            collapsable={false}
+            nativeID={END_PIN_NATIVE_ID}
+            pointerEvents="none"
+            style={END_ANCHOR_STYLE}
+          />
+        ) : null}
+        {children}
+      </Animated.ScrollView>
+    );
+  },
+);

packages/app/src/agent-stream/native-scroll-animation.test.ts

@@ -4,31 +4,48 @@ import { shouldAnimateNativeScrollToBottom } from "./native-scroll-animation";
 describe("native scroll-to-bottom animation", () => {
   it("jumps across unmounted history instead of animating through blank rows", () => {
     expect(
-      shouldAnimateNativeScrollToBottom({ offsetY: 60_000, viewportHeight: 600, windowSize: 10 }),
+      shouldAnimateNativeScrollToBottom({
+        distanceFromEnd: 60_000,
+        viewportHeight: 600,
+        drawDistance: 2000,
+      }),
     ).toBe(false);
   });
 
-  it("keeps near-bottom movement eligible for animation", () => {
+  it("keeps near-end movement eligible for animation", () => {
     expect(
-      shouldAnimateNativeScrollToBottom({ offsetY: 300, viewportHeight: 600, windowSize: 10 }),
+      shouldAnimateNativeScrollToBottom({
+        distanceFromEnd: 300,
+        viewportHeight: 600,
+        drawDistance: 2000,
+      }),
     ).toBe(true);
   });
 
-  it("bounds travel by the bottom-side overscan, not the whole window", () => {
+  it("bounds travel by the rows mounted below the viewport", () => {
     expect(
-      shouldAnimateNativeScrollToBottom({ offsetY: 2700, viewportHeight: 600, windowSize: 10 }),
+      shouldAnimateNativeScrollToBottom({
+        distanceFromEnd: 1000,
+        viewportHeight: 600,
+        drawDistance: 2000,
+      }),
     ).toBe(true);
     expect(
-      shouldAnimateNativeScrollToBottom({ offsetY: 2701, viewportHeight: 600, windowSize: 10 }),
-    ).toBe(false);
-    expect(
-      shouldAnimateNativeScrollToBottom({ offsetY: 1500, viewportHeight: 600, windowSize: 5 }),
+      shouldAnimateNativeScrollToBottom({
+        distanceFromEnd: 1001,
+        viewportHeight: 600,
+        drawDistance: 2000,
+      }),
     ).toBe(false);
   });
 
   it("does not animate before the viewport has been measured", () => {
     expect(
-      shouldAnimateNativeScrollToBottom({ offsetY: 0, viewportHeight: 0, windowSize: 10 }),
+      shouldAnimateNativeScrollToBottom({
+        distanceFromEnd: 0,
+        viewportHeight: 0,
+        drawDistance: 2000,
+      }),
     ).toBe(false);
   });
 });

packages/app/src/agent-stream/native-scroll-animation.ts

@@ -1,10 +1,10 @@
 export function shouldAnimateNativeScrollToBottom(input: {
-  offsetY: number;
+  distanceFromEnd: number;
   viewportHeight: number;
-  windowSize: number;
+  drawDistance: number;
 }): boolean {
-  // VirtualizedList splits the extra window around the viewport. An animated
-  // jump farther than the bottom-side overscan crosses unmounted history.
-  const bottomOverscanHeight = ((input.windowSize - 1) / 2) * input.viewportHeight;
-  return input.viewportHeight > 0 && input.offsetY <= bottomOverscanHeight;
+  // Scrolled away from the end, LegendList keeps half its draw distance mounted below the
+  // viewport. An animated jump farther than that crosses rows it has not rendered.
+  const mountedBelowViewport = input.drawDistance / 2;
+  return input.viewportHeight > 0 && input.distanceFromEnd <= mountedBelowViewport;
 }

packages/app/src/agent-stream/near-bottom.ts

@@ -0,0 +1,44 @@
+import { useState, useSyncExternalStore } from "react";
+
+/**
+ * Whether the reader is at the end of the timeline. The viewport writes it and only the
+ * scroll-to-bottom button reads it, so detaching from the end (a scroll, or a disclosure
+ * that opens below its trigger) re-renders the button and not the timeline.
+ */
+export interface NearBottom {
+  set: (value: boolean) => void;
+  subscribe: (listener: () => void) => () => void;
+  get: () => boolean;
+}
+
+function createNearBottom(): NearBottom {
+  let value = true;
+  const listeners = new Set<() => void>();
+  return {
+    set: (next) => {
+      if (next === value) return;
+      value = next;
+      for (const listener of listeners) listener();
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    get: () => value,
+  };
+}
+
+/** One per viewed agent; a newly viewed agent starts at the end. */
+export function useNearBottom(agentId: string): NearBottom {
+  const [owner, setOwner] = useState(() => ({ agentId, nearBottom: createNearBottom() }));
+  if (owner.agentId === agentId) return owner.nearBottom;
+  const next = { agentId, nearBottom: createNearBottom() };
+  setOwner(next);
+  return next.nearBottom;
+}
+
+export function useIsNearBottom(nearBottom: NearBottom): boolean {
+  return useSyncExternalStore(nearBottom.subscribe, nearBottom.get, nearBottom.get);
+}

packages/app/src/agent-stream/new-row-estimates.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { createNewRowEstimates } from "./new-row-estimates";
+
+interface Row {
+  id: string;
+  kind: string;
+}
+
+function row(id: string, kind = "assistant_message"): Row {
+  return { id, kind };
+}
+
+describe("new row estimates", () => {
+  it("leaves rows of the first list to the list's averages", () => {
+    const estimates = createNewRowEstimates<Row>();
+    const first = row("a");
+
+    estimates.noteRows([first]);
+
+    expect(estimates.estimate(first)).toBeUndefined();
+  });
+
+  it("estimates a new row at the first measured size of the last new row of its kind", () => {
+    const estimates = createNewRowEstimates<Row>();
+    estimates.noteRows([row("a")]);
+    const second = row("b");
+    estimates.noteRows([row("a"), second]);
+
+    expect(estimates.estimate(second)).toBeUndefined();
+
+    estimates.noteMeasured(second, 34);
+    estimates.noteMeasured(second, 56);
+    const third = row("c");
+    estimates.noteRows([row("a"), second, third]);
+
+    expect(estimates.estimate(third)).toBe(34);
+  });
+
+  it("keeps sizes per kind", () => {
+    const estimates = createNewRowEstimates<Row>();
+    estimates.noteRows([]);
+    const text = row("a");
+    const tool = row("b", "tool_call");
+    estimates.noteRows([text, tool]);
+    estimates.noteMeasured(text, 34);
+    estimates.noteMeasured(tool, 36);
+    const nextTool = row("c", "tool_call");
+    const nextText = row("d");
+    estimates.noteRows([text, tool, nextTool, nextText]);
+
+    expect(estimates.estimate(nextTool)).toBe(36);
+    expect(estimates.estimate(nextText)).toBe(34);
+  });
+
+  it("records the kind a row has when it is measured", () => {
+    const estimates = createNewRowEstimates<Row>();
+    estimates.noteRows([]);
+    estimates.noteRows([row("a", "thought")]);
+    estimates.noteMeasured(row("a", "tool_call"), 36);
+    const thought = row("b", "thought");
+    const tool = row("c", "tool_call");
+    estimates.noteRows([row("a", "tool_call"), thought, tool]);
+
+    expect(estimates.estimate(thought)).toBeUndefined();
+    expect(estimates.estimate(tool)).toBe(36);
+  });
+
+  it("estimates new rows anywhere in the list", () => {
+    const estimates = createNewRowEstimates<Row>();
+    estimates.noteRows([row("b"), row("d")]);
+    const appendedTool = row("e", "tool_call");
+    estimates.noteRows([row("b"), row("d"), appendedTool]);
+    estimates.noteMeasured(appendedTool, 36);
+    const older = row("a", "tool_call");
+    const revealed = row("c", "tool_call");
+    estimates.noteRows([older, row("b"), revealed, row("d"), appendedTool]);
+
+    expect(estimates.estimate(older)).toBe(36);
+    expect(estimates.estimate(revealed)).toBe(36);
+    expect(estimates.estimate(row("b", "tool_call"))).toBeUndefined();
+  });
+
+  it("stops estimating a measured row", () => {
+    const estimates = createNewRowEstimates<Row>();
+    estimates.noteRows([]);
+    const first = row("a");
+    estimates.noteRows([first]);
+    estimates.noteMeasured(first, 34);
+
+    expect(estimates.estimate(first)).toBeUndefined();
+  });
+});

packages/app/src/agent-stream/new-row-estimates.ts

@@ -0,0 +1,47 @@
+interface EstimatedRow {
+  id: string;
+  kind: string;
+}
+
+export interface NewRowEstimates<Row extends EstimatedRow> {
+  /** Called with every row list; a row whose id the previous list did not have is new. */
+  noteRows: (rows: readonly Row[]) => void;
+  /** Estimated size of an unmeasured new row, or undefined to use the list's average for its type. */
+  estimate: (row: Row) => number | undefined;
+  /** A row can change kind under the same id (a thought becomes a tool call); its current kind counts. */
+  noteMeasured: (row: Row, size: number) => void;
+}
+
+// A row that enters the list is a streamed row at the end, a tool call an expanded summary reveals,
+// or an older row loaded at the start. Its first measured size is close to constant per kind: one
+// line of text, a tool call header, a thought line. So a new row is estimated at the first measured
+// size of the last new row of its kind, and is laid out near its real size before it is measured.
+// The list's average for a type is the size of whole turns and is far off for any of these. Rows of
+// the first list are not new; they keep the average until measured.
+export function createNewRowEstimates<Row extends EstimatedRow>(): NewRowEstimates<Row> {
+  let previousRowIds: ReadonlySet<string> | null = null;
+  const unmeasuredRowIds = new Set<string>();
+  const firstSizeByKind = new Map<string, number>();
+
+  return {
+    noteRows(rows) {
+      const rowIds = new Set(rows.map((row) => row.id));
+      if (previousRowIds) {
+        for (const row of rows) {
+          if (!previousRowIds.has(row.id)) unmeasuredRowIds.add(row.id);
+        }
+      }
+      for (const rowId of unmeasuredRowIds) {
+        if (!rowIds.has(rowId)) unmeasuredRowIds.delete(rowId);
+      }
+      previousRowIds = rowIds;
+    },
+    estimate(row) {
+      return unmeasuredRowIds.has(row.id) ? firstSizeByKind.get(row.kind) : undefined;
+    },
+    noteMeasured(row, size) {
+      if (!unmeasuredRowIds.delete(row.id)) return;
+      firstSizeByKind.set(row.kind, size);
+    },
+  };
+}

packages/app/src/agent-stream/presentation.ts

@@ -50,6 +50,7 @@ const NO_COLLAPSED_TURNS: StreamPresentation["turns"] = collapseTurns({
   isLatestTurnOpen: false,
   expandedHostIds: new Set(),
   getGroupedCalls: () => undefined,
+  previousTurnsByHostId: new Map(),
 });
 
 /** Source messages reach plugins before display projection. */
@@ -134,6 +135,7 @@ export function createStreamPresentation() {
         isLatestTurnOpen,
         expandedHostIds: input.expandedTurnHostIds,
         getGroupedCalls: (itemId) => projection.groupsByHostId.get(itemId)?.run.calls,
+        previousTurnsByHostId: collapsed?.turnsByHostId ?? NO_COLLAPSED_TURNS.turnsByHostId,
       });
       collapsedSource = projection.tail;
       collapsedIsLatestTurnOpen = isLatestTurnOpen;

packages/app/src/agent-stream/reading-anchor.test.ts

@@ -56,6 +56,16 @@ describe("reading anchor", () => {
     ).toBe(1100);
   });
 
+  it("keeps a pinned row in place instead of the row under the reading line", () => {
+    const anchor = createReadingAnchor();
+    anchor.reconcile(600, rows);
+    anchor.pin(rows[2]!);
+    // The row being read grows; only the pinned row below it holds its position.
+    expect(
+      anchor.reconcile(600, [rows[0]!, { ...rows[1]!, height: 800 }, { ...rows[2]!, top: 1300 }]),
+    ).toBe(900);
+  });
+
   it("leaves expansion of the row being read in place", () => {
     const anchor = createReadingAnchor();
     anchor.reconcile(600, rows);

packages/app/src/agent-stream/reading-anchor.ts

@@ -33,6 +33,11 @@ export function createReadingAnchor() {
     reset() {
       anchor = null;
     },
+    // A disclosure names the row that owns its trigger. That row keeps its top
+    // through the toggle, even when another row sits under the reading line.
+    pin(row: Pick<RowGeometry, "id" | "top">) {
+      anchor = { id: row.id, top: row.top };
+    },
     scroll(scrollTop: number) {
       const next = readingRow(scrollTop);
       anchor = next ? { id: next.id, top: next.top } : null;

packages/app/src/agent-stream/render-strategy.test.ts

@@ -12,7 +12,6 @@ import {
   isNearBottomForStreamRenderStrategy,
   orderHeadForStreamRenderStrategy,
   orderTailForStreamRenderStrategy,
-  resolveBottomAnchorTransportBehavior,
 } from "./strategy";
 import { resolveStreamRenderStrategy } from "./strategy-resolver";
 
@@ -64,8 +63,6 @@ describe("resolveStreamRenderStrategy", () => {
     });
 
     expect(strategy.shouldUseVirtualizedList()).toBe(false);
-    expect(strategy.getFlatListInverted()).toBe(false);
-    expect(strategy.getOverlayScrollbarInverted()).toBe(false);
     expect(strategy.shouldAnchorBottomOnContentSizeChange()).toBe(true);
     expect(strategy.getBottomAnchorTransportBehavior()).toEqual({
       verificationDelayFrames: 0,
@@ -73,57 +70,27 @@ describe("resolveStreamRenderStrategy", () => {
     });
   });
 
-  it("uses inverted_stream on native", () => {
+  it("uses a virtualized forward stream on native", () => {
     const strategy = resolveStreamRenderStrategy({
       platform: "ios",
       isMobileBreakpoint: false,
     });
 
     expect(strategy.shouldUseVirtualizedList()).toBe(true);
-    expect(strategy.getFlatListInverted()).toBe(true);
-    expect(strategy.getOverlayScrollbarInverted()).toBe(true);
     expect(strategy.shouldAnchorBottomOnContentSizeChange()).toBe(false);
     expect(strategy.getBottomAnchorTransportBehavior()).toEqual({
       verificationDelayFrames: 2,
       verificationRetryMode: "recheck",
     });
   });
-
-  it("delays native verification while viewport settling is in flight", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "ios",
-      isMobileBreakpoint: false,
-    });
-
-    expect(
-      resolveBottomAnchorTransportBehavior({
-        strategy,
-        isViewportSettling: true,
-      }),
-    ).toEqual({
-      verificationDelayFrames: 4,
-      verificationRetryMode: "recheck",
-    });
-  });
-
-  it("does not inflate forward-stream verification delays during web resize", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-
-    expect(
-      resolveBottomAnchorTransportBehavior({
-        strategy,
-        isViewportSettling: true,
-      }),
-    ).toEqual({
-      verificationDelayFrames: 0,
-      verificationRetryMode: "rescroll",
-    });
-  });
 });
 
+const PLATFORMS = ["web", "ios", "android"] as const;
+
+function strategyFor(platform: (typeof PLATFORMS)[number]) {
+  return resolveStreamRenderStrategy({ platform, isMobileBreakpoint: false });
+}
+
 describe("stream ordering", () => {
   const streamItems: StreamItem[] = [
     userMessage("u1", "user-1", 1),
@@ -131,11 +98,8 @@ describe("stream ordering", () => {
     assistantMessage("a2", "assistant-2", 3),
   ];
 
-  it("keeps forward_stream order unchanged for tail and head", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
+  it.each(PLATFORMS)("keeps oldest-to-newest order for tail and head on %s", (platform) => {
+    const strategy = strategyFor(platform);
 
     const tail = orderTailForStreamRenderStrategy({ strategy, streamItems });
     const head = orderHeadForStreamRenderStrategy({ strategy, streamHead: streamItems });
@@ -143,73 +107,31 @@ describe("stream ordering", () => {
     expect(tail.map((item) => item.id)).toEqual(["u1", "a1", "a2"]);
     expect(head.map((item) => item.id)).toEqual(["u1", "a1", "a2"]);
   });
-
-  it("reverses inverted_stream order for tail and head", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "android",
-      isMobileBreakpoint: false,
-    });
-
-    const tail = orderTailForStreamRenderStrategy({ strategy, streamItems });
-    const head = orderHeadForStreamRenderStrategy({ strategy, streamHead: streamItems });
-
-    expect(tail.map((item) => item.id)).toEqual(["a2", "a1", "u1"]);
-    expect(head.map((item) => item.id)).toEqual(["a2", "a1", "u1"]);
-  });
 });
 
 describe("neighbor and traversal semantics", () => {
-  it("maps above/below indices for forward and inverted streams", () => {
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-    const inverted = resolveStreamRenderStrategy({
-      platform: "ios",
-      isMobileBreakpoint: false,
-    });
+  it.each(PLATFORMS)("maps above/below indices on %s", (platform) => {
+    const strategy = strategyFor(platform);
 
-    expect(getStreamNeighborIndex({ strategy: forward, index: 3, relation: "above" })).toBe(2);
-    expect(getStreamNeighborIndex({ strategy: forward, index: 3, relation: "below" })).toBe(4);
-    expect(getStreamNeighborIndex({ strategy: inverted, index: 3, relation: "above" })).toBe(4);
-    expect(getStreamNeighborIndex({ strategy: inverted, index: 3, relation: "below" })).toBe(2);
+    expect(getStreamNeighborIndex({ strategy, index: 3, relation: "above" })).toBe(2);
+    expect(getStreamNeighborIndex({ strategy, index: 3, relation: "below" })).toBe(4);
   });
 
-  it("collects assistant response content with strategy traversal direction", () => {
+  it.each(PLATFORMS)("collects assistant response content on %s", (platform) => {
     const chronological: StreamItem[] = [
       userMessage("u1", "user-1", 1),
       assistantMessage("a1", "assistant-1", 2),
       assistantMessage("a2", "assistant-2", 3),
       userMessage("u2", "user-2", 4),
     ];
+    const strategy = strategyFor(platform);
+    const items = orderTailForStreamRenderStrategy({ strategy, streamItems: chronological });
 
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-    const forwardStartIndex = chronological.findIndex((item) => item.id === "a2");
     expect(
       collectAssistantResponseContentForStreamRenderStrategy({
-        strategy: forward,
-        items: chronological,
-        startIndex: forwardStartIndex,
-      }),
-    ).toBe("assistant-1\n\nassistant-2");
-
-    const inverted = resolveStreamRenderStrategy({
-      platform: "android",
-      isMobileBreakpoint: false,
-    });
-    const invertedItems = orderTailForStreamRenderStrategy({
-      strategy: inverted,
-      streamItems: chronological,
-    });
-    const invertedStartIndex = invertedItems.findIndex((item) => item.id === "a2");
-    expect(
-      collectAssistantResponseContentForStreamRenderStrategy({
-        strategy: inverted,
-        items: invertedItems,
-        startIndex: invertedStartIndex,
+        strategy,
+        items,
+        startIndex: items.findIndex((item) => item.id === "a2"),
       }),
     ).toBe("assistant-1\n\nassistant-2");
   });
@@ -220,7 +142,7 @@ describe("neighbor and traversal semantics", () => {
       { ...toolCall("tool", 2), turnId: "turn-2" },
       { ...assistantMessage("a2", "second turn", 3), turnId: "turn-2" },
     ];
-    const strategy = resolveStreamRenderStrategy({ platform: "web", isMobileBreakpoint: false });
+    const strategy = strategyFor("web");
 
     expect(
       collectAssistantResponseContentForStreamRenderStrategy({
@@ -232,37 +154,17 @@ describe("neighbor and traversal semantics", () => {
   });
 
   it("returns undefined neighbor when index would be out of bounds", () => {
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
+    const strategy = strategyFor("web");
     const items: StreamItem[] = [userMessage("u1", "user-1", 1)];
 
-    expect(
-      getStreamNeighborItem({
-        strategy: forward,
-        items,
-        index: 0,
-        relation: "above",
-      }),
-    ).toBeUndefined();
-    expect(
-      getStreamNeighborItem({
-        strategy: forward,
-        items,
-        index: 0,
-        relation: "below",
-      }),
-    ).toBeUndefined();
+    expect(getStreamNeighborItem({ strategy, items, index: 0, relation: "above" })).toBeUndefined();
+    expect(getStreamNeighborItem({ strategy, items, index: 0, relation: "below" })).toBeUndefined();
   });
 });
 
 describe("scroll/bottom calculations", () => {
-  it("computes near-bottom using forward_stream distance-from-bottom math", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
+  it.each(PLATFORMS)("computes near-bottom from the distance to the end on %s", (platform) => {
+    const strategy = strategyFor(platform);
 
     expect(
       isNearBottomForStreamRenderStrategy({
@@ -284,48 +186,10 @@ describe("scroll/bottom calculations", () => {
     ).toBe(false);
   });
 
-  it("computes near-bottom and scroll-to-bottom offset for inverted_stream", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "ios",
-      isMobileBreakpoint: false,
-    });
-
-    expect(
-      isNearBottomForStreamRenderStrategy({
-        strategy,
-        offsetY: 12,
-        viewportHeight: 300,
-        contentHeight: 1000,
-        threshold: 24,
-      }),
-    ).toBe(true);
-    expect(
-      isNearBottomForStreamRenderStrategy({
-        strategy,
-        offsetY: 40,
-        viewportHeight: 300,
-        contentHeight: 1000,
-        threshold: 24,
-      }),
-    ).toBe(false);
+  it.each(PLATFORMS)("maps scroll-to-bottom to the max offset on %s", (platform) => {
     expect(
       getBottomOffsetForStreamRenderStrategy({
-        strategy,
-        viewportHeight: 300,
-        contentHeight: 1000,
-      }),
-    ).toBe(0);
-  });
-
-  it("maps scroll-to-bottom to max offset for forward_stream", () => {
-    const strategy = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-
-    expect(
-      getBottomOffsetForStreamRenderStrategy({
-        strategy,
+        strategy: strategyFor(platform),
         viewportHeight: 320,
         contentHeight: 1000,
       }),
@@ -334,36 +198,15 @@ describe("scroll/bottom calculations", () => {
 });
 
 describe("edge slot semantics", () => {
-  it("uses footer slot for forward_stream and header slot for inverted_stream", () => {
+  it.each(PLATFORMS)("uses the footer slot on %s", (platform) => {
     const EdgeSlot = () => null;
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-    const inverted = resolveStreamRenderStrategy({
-      platform: "android",
-      isMobileBreakpoint: false,
-    });
 
-    const forwardProps = getStreamEdgeSlotProps({
-      strategy: forward,
-      component: EdgeSlot,
-      gapSize: 4,
-    });
-    const invertedProps = getStreamEdgeSlotProps({
-      strategy: inverted,
-      component: EdgeSlot,
-      gapSize: 4,
-    });
-
-    expect(forwardProps).toEqual({
+    expect(
+      getStreamEdgeSlotProps({ strategy: strategyFor(platform), component: EdgeSlot, gapSize: 4 }),
+    ).toEqual({
       ListFooterComponent: EdgeSlot,
       ListFooterComponentStyle: { marginTop: 4 },
     });
-    expect(invertedProps).toEqual({
-      ListHeaderComponent: EdgeSlot,
-      ListHeaderComponentStyle: { marginBottom: 4 },
-    });
   });
 });
 
@@ -373,81 +216,31 @@ describe("layout strategy edges", () => {
     assistantMessage("a1", "assistant-1", 2),
   ];
 
-  it("uses the newest history edge as the history/live boundary", () => {
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-    const inverted = resolveStreamRenderStrategy({
-      platform: "android",
-      isMobileBreakpoint: false,
-    });
+  it.each(PLATFORMS)(
+    "uses the newest history edge as the history/live boundary on %s",
+    (platform) => {
+      const strategy = strategyFor(platform);
+      const history = orderTailForStreamRenderStrategy({ strategy, streamItems });
 
-    const forwardHistory = orderTailForStreamRenderStrategy({ strategy: forward, streamItems });
-    const invertedHistory = orderTailForStreamRenderStrategy({ strategy: inverted, streamItems });
+      expect(getHistoryLiveBoundaryIndexForStreamRenderStrategy({ strategy, history })).toBe(1);
+    },
+  );
 
-    expect(
-      getHistoryLiveBoundaryIndexForStreamRenderStrategy({
-        strategy: forward,
-        history: forwardHistory,
-      }),
-    ).toBe(1);
-    expect(
-      getHistoryLiveBoundaryIndexForStreamRenderStrategy({
-        strategy: inverted,
-        history: invertedHistory,
-      }),
-    ).toBe(0);
-  });
+  it.each(PLATFORMS)(
+    "uses the oldest live-head edge as the live-head/history boundary on %s",
+    (platform) => {
+      const strategy = strategyFor(platform);
+      const liveHead = orderHeadForStreamRenderStrategy({ strategy, streamHead: streamItems });
 
-  it("uses the oldest live-head edge as the live-head/history boundary", () => {
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-    const inverted = resolveStreamRenderStrategy({
-      platform: "ios",
-      isMobileBreakpoint: false,
-    });
+      expect(getLiveHeadHistoryBoundaryIndexForStreamRenderStrategy({ strategy, liveHead })).toBe(
+        0,
+      );
+    },
+  );
 
-    const forwardHead = orderHeadForStreamRenderStrategy({
-      strategy: forward,
-      streamHead: streamItems,
-    });
-    const invertedHead = orderHeadForStreamRenderStrategy({
-      strategy: inverted,
-      streamHead: streamItems,
-    });
-
-    expect(
-      getLiveHeadHistoryBoundaryIndexForStreamRenderStrategy({
-        strategy: forward,
-        liveHead: forwardHead,
-      }),
-    ).toBe(0);
-    expect(
-      getLiveHeadHistoryBoundaryIndexForStreamRenderStrategy({
-        strategy: inverted,
-        liveHead: invertedHead,
-      }),
-    ).toBe(1);
-  });
-
-  it("names the frame child order needed by native inverted cells", () => {
-    const forward = resolveStreamRenderStrategy({
-      platform: "web",
-      isMobileBreakpoint: false,
-    });
-    const inverted = resolveStreamRenderStrategy({
-      platform: "android",
-      isMobileBreakpoint: false,
-    });
-
-    expect(getFrameChildOrderForStreamRenderStrategy({ strategy: forward })).toBe(
+  it.each(PLATFORMS)("renders a cell's content before its footer on %s", (platform) => {
+    expect(getFrameChildOrderForStreamRenderStrategy({ strategy: strategyFor(platform) })).toBe(
       "content-then-footer",
     );
-    expect(getFrameChildOrderForStreamRenderStrategy({ strategy: inverted })).toBe(
-      "footer-then-content",
-    );
   });
 });

packages/app/src/agent-stream/scroll-keyboard-dismiss/model.test.ts

@@ -41,23 +41,23 @@ describe("scroll keyboard dismissal", () => {
       shouldDismiss(
         { ts: 1000, y: 0 },
         [
-          { ts: 1040, y: 8 },
-          { ts: 1080, y: 16 },
-          { ts: 1120, y: 24 },
+          { ts: 1040, y: -8 },
+          { ts: 1080, y: -16 },
+          { ts: 1120, y: -24 },
         ],
-        { ts: 1160, y: 32 },
+        { ts: 1160, y: -32 },
       ),
     ).toBe(false);
   });
 
-  it("dismisses for an upward flick", () => {
-    expect(shouldDismiss({ ts: 1000, y: 0 }, [{ ts: 1040, y: 120 }], { ts: 1080, y: 240 })).toBe(
+  it("dismisses for a flick toward older messages", () => {
+    expect(shouldDismiss({ ts: 1000, y: 0 }, [{ ts: 1040, y: -120 }], { ts: 1080, y: -240 })).toBe(
       true,
     );
   });
 
-  it("keeps the keyboard up when the inverted list moves toward newer messages", () => {
-    expect(shouldDismiss({ ts: 1000, y: 0 }, [{ ts: 1040, y: -120 }], { ts: 1080, y: -240 })).toBe(
+  it("keeps the keyboard up when the list moves toward newer messages", () => {
+    expect(shouldDismiss({ ts: 1000, y: 0 }, [{ ts: 1040, y: 120 }], { ts: 1080, y: 240 })).toBe(
       false,
     );
   });
@@ -67,17 +67,17 @@ describe("scroll keyboard dismissal", () => {
       shouldDismiss(
         { ts: 1000, y: 0 },
         [
-          { ts: 1100, y: 500 },
-          { ts: 1200, y: 590 },
-          { ts: 1270, y: 598 },
+          { ts: 1100, y: -500 },
+          { ts: 1200, y: -590 },
+          { ts: 1270, y: -598 },
         ],
-        { ts: 1300, y: 600 },
+        { ts: 1300, y: -600 },
       ),
     ).toBe(false);
   });
 
   it("uses the whole drag when the gesture is too short to sample", () => {
-    expect(shouldDismiss({ ts: 1000, y: 0 }, [], { ts: 1020, y: 60 })).toBe(true);
+    expect(shouldDismiss({ ts: 1000, y: 0 }, [], { ts: 1020, y: -60 })).toBe(true);
   });
 
   it("steps back a sample when release lands immediately after one", () => {
@@ -85,22 +85,22 @@ describe("scroll keyboard dismissal", () => {
       shouldDismiss(
         { ts: 1000, y: 0 },
         [
-          { ts: 1040, y: 120 },
-          { ts: 1075, y: 225 },
+          { ts: 1040, y: -120 },
+          { ts: 1075, y: -225 },
         ],
-        { ts: 1080, y: 240 },
+        { ts: 1080, y: -240 },
       ),
     ).toBe(true);
   });
 
   it("keeps the keyboard up when release has no measurable time span", () => {
-    expect(shouldDismiss({ ts: 1000, y: 0 }, [], { ts: 1000, y: 90 })).toBe(false);
+    expect(shouldDismiss({ ts: 1000, y: 0 }, [], { ts: 1000, y: -90 })).toBe(false);
   });
 
   it("ignores scroll events that arrive before the minimum sample span", () => {
-    expect(shouldDismiss({ ts: 1000, y: 0 }, [{ ts: 1029, y: 1000 }], { ts: 1060, y: 1000 })).toBe(
-      true,
-    );
+    expect(
+      shouldDismiss({ ts: 1000, y: 0 }, [{ ts: 1029, y: -1000 }], { ts: 1060, y: -1000 }),
+    ).toBe(true);
   });
 
   it("uses native gesture time when delayed callbacks arrive in a burst", () => {
@@ -108,32 +108,32 @@ describe("scroll keyboard dismissal", () => {
       shouldDismiss(
         { ts: 5000, nativeTs: 1000, y: 0 },
         [
-          { ts: 5001, nativeTs: 1200, y: 40 },
-          { ts: 5002, nativeTs: 1400, y: 80 },
+          { ts: 5001, nativeTs: 1200, y: -40 },
+          { ts: 5002, nativeTs: 1400, y: -80 },
         ],
-        { ts: 5003, nativeTs: 1600, y: 120 },
+        { ts: 5003, nativeTs: 1600, y: -120 },
       ),
     ).toBe(false);
   });
 
   it("falls back to synthetic event time when native time is absent", () => {
     expect(
-      shouldDismiss({ ts: 1000, nativeTs: null, y: 0 }, [{ ts: 1040, nativeTs: null, y: 120 }], {
+      shouldDismiss({ ts: 1000, nativeTs: null, y: 0 }, [{ ts: 1040, nativeTs: null, y: -120 }], {
         ts: 1080,
         nativeTs: null,
-        y: 240,
+        y: -240,
       }),
     ).toBe(true);
   });
 
   it("ignores scroll and release events without a matching drag", () => {
-    const idle = recordScroll(IDLE_SCROLL_KEYBOARD_DISMISS_GESTURE, event({ ts: 1000, y: 200 }));
+    const idle = recordScroll(IDLE_SCROLL_KEYBOARD_DISMISS_GESTURE, event({ ts: 1000, y: -200 }));
     expect(idle).toBe(IDLE_SCROLL_KEYBOARD_DISMISS_GESTURE);
-    expect(releaseDrag(idle, event({ ts: 1010, y: 300 })).shouldDismiss).toBe(false);
+    expect(releaseDrag(idle, event({ ts: 1010, y: -300 })).shouldDismiss).toBe(false);
   });
 
   it("returns to idle after release", () => {
-    const release = releaseDrag(beginDrag(event({ ts: 1000, y: 0 })), event({ ts: 1020, y: 60 }));
+    const release = releaseDrag(beginDrag(event({ ts: 1000, y: 0 })), event({ ts: 1020, y: -60 }));
     expect(release.gesture).toBe(IDLE_SCROLL_KEYBOARD_DISMISS_GESTURE);
   });
 });

packages/app/src/agent-stream/scroll-keyboard-dismiss/model.ts

@@ -2,8 +2,7 @@
  * Pure state machine for the chat history's flick-to-dismiss gesture.
  *
  * Native keyboardDismissMode cannot express this interaction: "on-drag"
- * dismisses on the first pixel, while "interactive" behaves incorrectly on an
- * inverted list. We therefore classify the list's existing scroll gesture at
+ * dismisses on the first pixel, while "interactive" is iOS-only. We therefore classify the list's existing scroll gesture at
  * release instead of introducing a competing pan recognizer.
  */
 
@@ -114,11 +113,12 @@ export function releaseDrag(
     spanStartY = samples.previousSampleY;
   }
 
+  // The list runs oldest to newest, so moving toward older messages lowers the offset.
   const spanDurationMs = releaseTs - spanStartTs;
-  const releaseVelocity = spanDurationMs > 0 ? (releaseY - spanStartY) / spanDurationMs : 0;
+  const towardOlderVelocity = spanDurationMs > 0 ? (spanStartY - releaseY) / spanDurationMs : 0;
 
   return {
     gesture: IDLE_SCROLL_KEYBOARD_DISMISS_GESTURE,
-    shouldDismiss: releaseVelocity > DISMISS_VELOCITY_POINTS_PER_MS,
+    shouldDismiss: towardOlderVelocity > DISMISS_VELOCITY_POINTS_PER_MS,
   };
 }

packages/app/src/agent-stream/scroll-keyboard-dismiss/use-scroll-keyboard-dismiss.ts

@@ -18,7 +18,7 @@ type ScrollEvent = NativeSyntheticEvent<NativeScrollEvent>;
 
 /**
  * Owns the chat history's flick-to-dismiss behavior. The native stream only
- * forwards the FlatList scroll lifecycle; removing this hook and those three
+ * forwards the LegendList scroll lifecycle; removing this hook and those three
  * calls removes the feature completely.
  */
 export function useScrollKeyboardDismiss() {

packages/app/src/agent-stream/strategy-native.tsx

@@ -1,38 +1,42 @@
 import {
-  Fragment,
   type ReactElement,
+  type ReactNode,
   useCallback,
   useEffect,
+  useLayoutEffect,
   useMemo,
   useRef,
   useState,
 } from "react";
 import {
-  FlatList,
-  Platform,
   View,
   type LayoutChangeEvent,
-  type ListRenderItemInfo,
   type NativeScrollEvent,
   type NativeSyntheticEvent,
+  type ScrollView,
+  type ScrollViewProps,
   type ViewStyle,
 } from "react-native";
+import {
+  LegendList,
+  type LegendListRef,
+  type LegendListRenderItemProps,
+  useSyncLayout,
+} from "@legendapp/list/react-native";
 import { withUnistyles } from "react-native-unistyles";
 import { LoadingSpinner } from "@/components/ui/loading-spinner";
 import type { StreamItem } from "@/types/stream";
 import type { Theme } from "@/styles/theme";
 import { useStableEvent } from "@/hooks/use-stable-event";
-import { useKeyboardStreamInset } from "@/keyboard/shift";
 import { shouldAnimateNativeScrollToBottom } from "./native-scroll-animation";
 import { useRevisedHistoryRows } from "./history-row-revision";
 import { useBottomAnchorController } from "./bottom-anchor-controller";
 import { useScrollKeyboardDismiss } from "./scroll-keyboard-dismiss/use-scroll-keyboard-dismiss";
+import { createNativeDisclosureHold } from "./native-disclosure-hold";
+import { EndPinnedScrollView } from "./native-end-pin";
+import { createNewRowEstimates } from "./new-row-estimates";
 import type { StreamRenderInput, StreamStrategy, StreamViewportHandle } from "./strategy";
-import {
-  createStreamStrategy,
-  isNearBottomForStreamRenderStrategy,
-  resolveBottomAnchorTransportBehavior,
-} from "./strategy";
+import { createStreamStrategy, isNearBottomForStreamRenderStrategy } from "./strategy";
 import {
   abandonHistoryStartPaginationRequest,
   createHistoryStartPaginationState,
@@ -49,11 +53,6 @@ import {
   type HistoryStartSettleScheduler,
 } from "./history-start-settle-scheduler";
 
-const DEFAULT_MAINTAIN_VISIBLE_CONTENT_POSITION = Object.freeze({
-  minIndexForVisible: 0,
-  autoscrollToTopThreshold: 0,
-});
-
 const ThemedLoadingSpinner = withUnistyles(LoadingSpinner);
 const foregroundMutedColorMapping = (theme: Theme) => ({
   color: theme.colors.foregroundMuted,
@@ -65,7 +64,50 @@ const historyStartSlotStyle: ViewStyle = {
   flexShrink: 0,
 };
 const HISTORY_START_SETTLE_FRAMES = 2;
-const NATIVE_STREAM_WINDOW_SIZE = 10;
+// Rendered distance on each side of the viewport. Smaller values blank the viewport while a fling
+// crosses rows that were never measured (docs/agent-stream-disclosure.md).
+const NATIVE_STREAM_DRAW_DISTANCE = 2000;
+// Following resumes after a disclosure or a user scroll only from the end, so resuming never moves
+// the rows the user is looking at. Web resumes within the same distance (strategy-web.tsx).
+const AT_END_OFFSET_PX = 1;
+// A disclosure settles after this many frames without an item size change.
+const DISCLOSURE_QUIET_FRAMES = 2;
+const BOTTOM_ANCHOR_TRANSPORT_BEHAVIOR = Object.freeze({
+  verificationDelayFrames: 2,
+  verificationRetryMode: "recheck" as const,
+});
+
+type RowLayoutSyncRegistry = Map<string, () => void>;
+
+// A disclosure toggle changes a row from the row's own state, so LegendList's container does not
+// re-render and would learn the new height from onLayout a task later, a frame after the change
+// painted. The row's measurement trigger, called next to the toggle, batches the measurement and
+// the corrected positions into the toggle's own commit.
+function RowLayoutSync(props: {
+  rowId: string;
+  registry: RowLayoutSyncRegistry;
+  children: ReactNode;
+}) {
+  const { rowId, registry } = props;
+  const syncLayout = useSyncLayout();
+  useLayoutEffect(() => {
+    registry.set(rowId, syncLayout);
+    return () => {
+      if (registry.get(rowId) === syncLayout) {
+        registry.delete(rowId);
+      }
+    };
+  }, [registry, rowId, syncLayout]);
+  return props.children;
+}
+
+function distanceFromEnd(input: {
+  offsetY: number;
+  contentHeight: number;
+  viewportHeight: number;
+}): number {
+  return Math.max(0, input.contentHeight - input.viewportHeight - input.offsetY);
+}
 
 function keyExtractor(item: { id: string }): string {
   return item.id;
@@ -94,7 +136,12 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     strategy,
   } = props;
   const { renderHistoryMountedRow, renderLiveHeadRow, renderLiveAuxiliary } = renderers;
-  const flatListRef = useRef<FlatList<StreamItem>>(null);
+  const listRef = useRef<LegendListRef>(null);
+  // LegendList places the rows of each agent once, behind a hidden reveal (`dataKey`).
+  const [placedAgentId, setPlacedAgentId] = useState<string | null>(null);
+  const isListPlaced = placedAgentId === agentId;
+  const isListPlacedRef = useRef(isListPlaced);
+  isListPlacedRef.current = isListPlaced;
   const streamViewportMetricsRef = useRef({
     containerKey: "native-virtualized",
     contentHeight: 0,
@@ -107,11 +154,9 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
   const scrollOffsetYRef = useRef(0);
   const isUserScrollActiveRef = useRef(false);
   const scrollKeyboardDismiss = useScrollKeyboardDismiss();
-  const streamKeyboardInset = useKeyboardStreamInset();
   const userScrollEndFrameIdRef = useRef<number | null>(null);
+  const isReleasedAtEndRef = useRef(false);
   const programmaticScrollEventBudgetRef = useRef(0);
-  const isNativeViewportSettlingRef = useRef(false);
-  const nativeViewportSettlingFrameIdRef = useRef<number | null>(null);
   const historyStartReadyRef = useRef(false);
   const [historyStartPaginationState, setHistoryStartPaginationState] = useState(
     createHistoryStartPaginationState,
@@ -126,13 +171,28 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     return [...segments.historyVirtualized, ...segments.historyMounted];
   }, [segments.historyMounted, segments.historyVirtualized]);
   const historyRows = useRevisedHistoryRows(historyItems, historyRowRevision);
+  // Live rows are the tail of the list, so a row that finishes keeps its id, container and measured
+  // size when it moves into history. A fresh identity per live-head change re-renders every live
+  // row, which is how they pick up neighbour and expansion changes (`liveHeadRowRevision`).
+  const liveRows = useMemo(() => {
+    void liveHeadRowRevision;
+    return segments.liveHead.map((item) => ({ ...item }));
+  }, [segments.liveHead, liveHeadRowRevision]);
+  const liveRowIds = useMemo(() => new Set(liveRows.map((item) => item.id)), [liveRows]);
+  const [newRowEstimates] = useState(() => createNewRowEstimates<StreamItem>());
+  const rows = useMemo(() => {
+    const nextRows = [...historyRows, ...liveRows];
+    newRowEstimates.noteRows(nextRows);
+    return nextRows;
+  }, [newRowEstimates, historyRows, liveRows]);
+  const getEstimatedItemSize = useStableEvent((item: StreamItem) => newRowEstimates.estimate(item));
   const getHistoryStartPaginationInput = useStableEvent((): HistoryStartPaginationInput => {
     const metrics = streamViewportMetricsRef.current;
     const hasMeasuredViewport =
       metrics.viewportMeasuredForKey === metrics.containerKey &&
       metrics.contentMeasuredForKey === metrics.containerKey;
     return {
-      distanceFromHistoryStart: metrics.contentHeight - metrics.viewportHeight - metrics.offsetY,
+      distanceFromHistoryStart: metrics.offsetY,
       hasOlderHistory,
       isLoadingOlderHistory,
       isReady: historyStartReadyRef.current && hasMeasuredViewport,
@@ -196,13 +256,6 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     scheduler.schedule();
   });
 
-  const clearNativeViewportSettling = useCallback(() => {
-    if (nativeViewportSettlingFrameIdRef.current !== null) {
-      cancelAnimationFrame(nativeViewportSettlingFrameIdRef.current);
-      nativeViewportSettlingFrameIdRef.current = null;
-    }
-  }, []);
-
   const clearPendingUserScrollEnd = useCallback(() => {
     if (userScrollEndFrameIdRef.current !== null) {
       cancelAnimationFrame(userScrollEndFrameIdRef.current);
@@ -210,49 +263,30 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     }
   }, []);
 
-  const markNativeViewportSettling = useCallback(() => {
-    clearNativeViewportSettling();
-    isNativeViewportSettlingRef.current = true;
-    let remainingFrames = 4;
-    const tick = () => {
-      if (remainingFrames <= 0) {
-        nativeViewportSettlingFrameIdRef.current = null;
-        isNativeViewportSettlingRef.current = false;
-        return;
-      }
-      remainingFrames -= 1;
-      nativeViewportSettlingFrameIdRef.current = requestAnimationFrame(tick);
-    };
-    nativeViewportSettlingFrameIdRef.current = requestAnimationFrame(tick);
-  }, [clearNativeViewportSettling]);
-
-  const getBottomAnchorTransportBehavior = useCallback(
-    () =>
-      resolveBottomAnchorTransportBehavior({
-        strategy,
-        isViewportSettling: isNativeViewportSettlingRef.current,
-      }),
-    [strategy],
-  );
+  const getBottomAnchorTransportBehavior = useCallback(() => BOTTOM_ANCHOR_TRANSPORT_BEHAVIOR, []);
 
   const scrollToBottom = useCallback(
     (animated: boolean) => {
       programmaticScrollEventBudgetRef.current = 3;
-      flatListRef.current?.scrollToOffset({
-        offset: 0,
+      const metrics = streamViewportMetricsRef.current;
+      // The native scroll view finds its end from the content it has mounted, and the end pin holds
+      // it from there. LegendList's own scrollToEnd keeps re-aiming at the end its JS sizes predict
+      // until it lands, which runs ahead of the mount and scrolls the end out of view.
+      const list = listRef.current;
+      list?.cancelScroll();
+      // The scroll component is `EndPinnedScrollView`, a ScrollView.
+      (list?.getNativeScrollRef() as ScrollView | undefined)?.scrollToEnd({
         animated:
           animated &&
           shouldAnimateNativeScrollToBottom({
-            offsetY: scrollOffsetYRef.current,
-            viewportHeight: streamViewportMetricsRef.current.viewportHeight,
-            windowSize: NATIVE_STREAM_WINDOW_SIZE,
+            distanceFromEnd: distanceFromEnd(metrics),
+            viewportHeight: metrics.viewportHeight,
+            drawDistance: NATIVE_STREAM_DRAW_DISTANCE,
           }),
       });
-      scrollOffsetYRef.current = 0;
-      streamViewportMetricsRef.current = {
-        ...streamViewportMetricsRef.current,
-        offsetY: 0,
-      };
+      const endOffsetY = Math.max(0, metrics.contentHeight - metrics.viewportHeight);
+      scrollOffsetYRef.current = endOffsetY;
+      streamViewportMetricsRef.current = { ...metrics, offsetY: endOffsetY };
       onNearBottomChange(true);
     },
     [onNearBottomChange],
@@ -262,7 +296,7 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     agentId,
     routeRequest: routeBottomAnchorRequest,
     isAuthoritativeHistoryReady,
-    renderStrategy: "inverted-stream",
+    renderStrategy: "legend-stream",
     getTransportBehavior: getBottomAnchorTransportBehavior,
     getMeasurementState: () => streamViewportMetricsRef.current,
     isNearBottom: () => {
@@ -277,39 +311,76 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     },
     scrollToBottom,
   });
-  // Android's maintainVisibleContentPosition ignores the list inversion transform and
-  // fights the controller's offset-zero correction while the live header grows.
-  const maintainVisibleContentPosition =
-    Platform.OS === "android" && bottomAnchorController.mode === "sticky-bottom"
-      ? undefined
-      : DEFAULT_MAINTAIN_VISIBLE_CONTENT_POSITION;
-  const topOverlayInset = useStreamTopOverlayInset();
-  // The list is inverted, so its content's bottom padding is the visual top.
-  const listContentContainerStyle = useMemo(
-    () => [
-      baseListContentContainerStyle,
-      {
-        paddingBottom: streamKeyboardInset.contentContainerPaddingBottom + topOverlayInset,
-      },
-    ],
-    [
-      baseListContentContainerStyle,
-      streamKeyboardInset.contentContainerPaddingBottom,
-      topOverlayInset,
-    ],
+
+  const [rowLayoutSyncRegistry] = useState<RowLayoutSyncRegistry>(() => new Map());
+  const isAtEnd = useStableEvent(
+    () => distanceFromEnd(streamViewportMetricsRef.current) <= AT_END_OFFSET_PX,
   );
-  const listInsetProps = useMemo(
-    () =>
-      streamKeyboardInset.contentInset
-        ? {
-            automaticallyAdjustContentInsets: false,
-            automaticallyAdjustsScrollIndicatorInsets: false,
-            contentInsetAdjustmentBehavior: "never" as const,
-            contentInset: streamKeyboardInset.contentInset,
-            scrollIndicatorInsets: streamKeyboardInset.contentInset,
-          }
-        : {},
-    [streamKeyboardInset.contentInset],
+  const releaseDisclosure = useStableEvent(() => {
+    bottomAnchorController.releaseDisclosure({ isAtEnd: isAtEnd() });
+  });
+  const [disclosureHold] = useState(() =>
+    createNativeDisclosureHold({
+      quietFrames: DISCLOSURE_QUIET_FRAMES,
+      requestFrame: requestAnimationFrame,
+      cancelFrame: cancelAnimationFrame,
+      onRelease: releaseDisclosure,
+    }),
+  );
+  useEffect(() => () => disclosureHold.cancel(), [disclosureHold]);
+  // The hold detaches the controller in the same event as `apply`, so the toggle's commit already
+  // has end following off and LegendList anchoring on the held row. The row's measurement trigger
+  // makes that same commit carry the row's new height.
+  const holdRow = useStableEvent((rowId: string, apply: () => void) => {
+    disclosureHold.hold(rowId);
+    bottomAnchorController.holdForDisclosure();
+    apply();
+    rowLayoutSyncRegistry.get(rowId)?.();
+  });
+  const handleItemSizeChanged = useStableEvent(
+    (info: { size: number; previous: number; itemKey: string; itemData: StreamItem }) => {
+      newRowEstimates.noteMeasured(info.itemData, info.size);
+      disclosureHold.noteItemSizeChanged();
+    },
+  );
+  const shouldRestorePosition = useStableEvent((item: StreamItem) => {
+    const heldRowId = disclosureHold.heldRowId();
+    return heldRowId === null || item.id === heldRowId;
+  });
+  // One owner keeps the scroll offset at any moment:
+  // - Before the list has placed its rows for the agent: LegendList's initial scroll to the end. It
+  //   keeps the rows hidden until they are measured and in place, so neither the pin nor the
+  //   controller acts; the content does not count as measured yet (`handleContentSizeChange`).
+  // - Following the end: the end pin. Rows added, rows resized and footer changes never scroll from
+  //   JS; the pin holds the end in the frame the change mounts. The controller scrolls only for a
+  //   viewport resize (the composer growing or shrinking), which the pin cannot see, and for an
+  //   explicit jump, and both go to the native end (`scrollToBottom`). The keyboard does not resize
+  //   the viewport: it translates the list with the composer. LegendList's end keeping stays off: it
+  //   scrolls to the end its JS sizes predict, which runs ahead of the native mount, so it lands
+  //   short of the real end and the controller reads that as the user scrolling away.
+  // - A disclosure hold: the held row. The hold detaches the controller, which removes the pin, and
+  //   LegendList keeps only the held row in place.
+  // - A user scroll: the finger. The controller detaches for the gesture, so streamed lines grow below
+  //   the rows the user is dragging, and resumes following if the gesture ends at the end.
+  // - Detached: the visible rows. LegendList keeps the first visible row in place, so history loading
+  //   above or rows growing below leave what the user is reading where it is.
+  const isFollowingEnd = bottomAnchorController.mode === "sticky-bottom";
+  const pinsEnd = isFollowingEnd && isListPlaced;
+  const maintainVisibleContentPosition = useMemo(
+    () => (isFollowingEnd ? false : { data: true, size: true, shouldRestorePosition }),
+    [isFollowingEnd, shouldRestorePosition],
+  );
+  // A new identity re-renders LegendList's scroll component, which is how the pin follows the mode.
+  const renderScrollComponent = useCallback(
+    (scrollProps: ScrollViewProps) => <EndPinnedScrollView {...scrollProps} pinEnd={pinsEnd} />,
+    [pinsEnd],
+  );
+  const topOverlayInset = useStreamTopOverlayInset();
+  // No keyboard inset: one committed after the keyboard settles moves every row when the end pin is
+  // not holding the offset (docs/agent-stream-disclosure.md).
+  const listContentContainerStyle = useMemo(
+    () => [baseListContentContainerStyle, { paddingTop: topOverlayInset }],
+    [baseListContentContainerStyle, topOverlayInset],
   );
 
   useEffect(() => {
@@ -325,8 +396,7 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     scrollOffsetYRef.current = 0;
     isUserScrollActiveRef.current = false;
     clearPendingUserScrollEnd();
-    clearNativeViewportSettling();
-    isNativeViewportSettlingRef.current = false;
+    disclosureHold.cancel();
     historyStartReadyRef.current = false;
     const initialHistoryStartState = createHistoryStartPaginationState();
     historyStartPaginationStateRef.current = initialHistoryStartState;
@@ -341,13 +411,7 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
       historyStartSettleSchedulerRef.current?.cancel();
       historyStartSettleSchedulerRef.current = null;
     };
-  }, [agentId, clearNativeViewportSettling, clearPendingUserScrollEnd, evaluateHistoryStart]);
-
-  useEffect(() => () => clearNativeViewportSettling(), [clearNativeViewportSettling]);
-
-  useEffect(() => {
-    bottomAnchorController.prepareForStickyContentChange();
-  }, [bottomAnchorController, historyRows, segments.liveHead]);
+  }, [agentId, clearPendingUserScrollEnd, disclosureHold, evaluateHistoryStart]);
 
   useEffect(() => {
     const handle: StreamViewportHandle = {
@@ -359,9 +423,8 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
       },
       prepareForViewportChange: () => {
         bottomAnchorController.prepareForStickyViewportChange();
-        markNativeViewportSettling();
       },
-      holdReadingPosition: () => bottomAnchorController.detachByUser(),
+      holdRow,
     };
     viewportRef.current = handle;
     return () => {
@@ -369,7 +432,32 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
         viewportRef.current = null;
       }
     };
-  }, [agentId, bottomAnchorController, markNativeViewportSettling, viewportRef]);
+  }, [agentId, bottomAnchorController, holdRow, viewportRef]);
+
+  // The scroll-to-bottom button shows whenever following would not resume on its own. A detached
+  // list resumes only from the end, so the button shows anywhere short of it. While following, the
+  // offset can trail content growth for a frame, so the controller's wider threshold keeps the
+  // button from flashing.
+  const publishNearBottom = useStableEvent(() => {
+    const metrics = streamViewportMetricsRef.current;
+    onNearBottomChange(
+      bottomAnchorController.mode === "detached"
+        ? distanceFromEnd(metrics) <= AT_END_OFFSET_PX
+        : isNearBottomForStreamRenderStrategy({
+            strategy,
+            offsetY: metrics.offsetY,
+            threshold: 32,
+            contentHeight: metrics.contentHeight,
+            viewportHeight: metrics.viewportHeight,
+          }),
+    );
+  });
+
+  // Following starts and stops without a scroll, for example when a disclosure hold begins short of
+  // the end, and the button follows it.
+  useEffect(() => {
+    publishNearBottom();
+  }, [isFollowingEnd, publishNearBottom]);
 
   const isScrollEventNearBottom = useStableEvent(
     (event: NativeSyntheticEvent<NativeScrollEvent>) => {
@@ -384,6 +472,17 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     },
   );
 
+  const isScrollEventAtEnd = useStableEvent((event: NativeSyntheticEvent<NativeScrollEvent>) => {
+    const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
+    return (
+      distanceFromEnd({
+        offsetY: contentOffset.y,
+        contentHeight: contentSize.height,
+        viewportHeight: layoutMeasurement.height,
+      }) <= AT_END_OFFSET_PX
+    );
+  });
+
   const handleScroll = useStableEvent((event: NativeSyntheticEvent<NativeScrollEvent>) => {
     const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
     const previousOffsetY = scrollOffsetYRef.current;
@@ -401,14 +500,18 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     };
 
     const nearBottom = isScrollEventNearBottom(event);
-    onNearBottomChange(nearBottom);
+    publishNearBottom();
 
     evaluateHistoryStart();
 
     if (
       !isUserScrollActiveRef.current &&
       programmaticScrollEventBudgetRef.current > 0 &&
-      contentOffset.y <= 8
+      distanceFromEnd({
+        offsetY: contentOffset.y,
+        contentHeight: contentSize.height,
+        viewportHeight: layoutMeasurement.height,
+      }) <= 8
     ) {
       programmaticScrollEventBudgetRef.current -= 1;
     } else {
@@ -424,6 +527,10 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     clearPendingUserScrollEnd();
     isUserScrollActiveRef.current = true;
     scrollKeyboardDismiss.onScrollBeginDrag(event);
+    // The gesture takes the viewport from a disclosure hold. Size changes from a streaming row can
+    // keep the hold's quiet frames from ever passing, and a held row that scrolls away would leave
+    // no row LegendList may anchor a history page on. The gesture's end decides following.
+    disclosureHold.cancel();
     bottomAnchorController.beginUserScroll();
     const rearmed = rearmHistoryStartPagination(historyStartPaginationStateRef.current);
     if (rearmed !== historyStartPaginationStateRef.current) {
@@ -433,17 +540,22 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     }
   });
 
-  // Defer drag end so momentum can take ownership, but capture the terminal
-  // gesture position now because layout may move the viewport in the meantime.
+  // A gesture ends at the end when the finger lifts at or past it, or when its momentum stops there.
+  // A release past the end bounces back to it on iOS, and lines that land during the bounce scroll
+  // in as they do while following. Momentum stopping short of the end, or output that arrived below
+  // the viewport before the decision, leaves the list detached.
+  // Drag end is deferred a frame so momentum can take ownership.
   const handleScrollEndDrag = useStableEvent((event: NativeSyntheticEvent<NativeScrollEvent>) => {
-    const isNearBottom = isScrollEventNearBottom(event);
     scrollKeyboardDismiss.onScrollEndDrag(event);
+    isReleasedAtEndRef.current = isScrollEventAtEnd(event);
 
     clearPendingUserScrollEnd();
     userScrollEndFrameIdRef.current = requestAnimationFrame(() => {
       userScrollEndFrameIdRef.current = null;
       isUserScrollActiveRef.current = false;
-      bottomAnchorController.endUserScroll({ isNearBottom });
+      bottomAnchorController.endUserScroll({
+        isAtEnd: isReleasedAtEndRef.current || isAtEnd(),
+      });
     });
   });
 
@@ -458,10 +570,11 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
       if (!isUserScrollActiveRef.current) {
         return;
       }
-      const isNearBottom = isScrollEventNearBottom(event);
       clearPendingUserScrollEnd();
       isUserScrollActiveRef.current = false;
-      bottomAnchorController.endUserScroll({ isNearBottom });
+      bottomAnchorController.endUserScroll({
+        isAtEnd: isReleasedAtEndRef.current || isScrollEventAtEnd(event),
+      });
     },
   );
 
@@ -470,9 +583,6 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     const previousViewportHeight = streamViewportMetricsRef.current.viewportHeight;
     const viewportWidth = Math.max(0, event.nativeEvent.layout.width);
     const viewportHeight = Math.max(0, event.nativeEvent.layout.height);
-    const viewportChanged =
-      (previousViewportWidth > 0 && previousViewportWidth !== viewportWidth) ||
-      (previousViewportHeight > 0 && previousViewportHeight !== viewportHeight);
     streamViewportMetricsRef.current = {
       ...streamViewportMetricsRef.current,
       containerKey: "native-virtualized",
@@ -480,9 +590,6 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
       viewportHeight,
       viewportMeasuredForKey: "native-virtualized",
     };
-    if (viewportChanged) {
-      markNativeViewportSettling();
-    }
     bottomAnchorController.handleViewportMetricsChange({
       previousViewportWidth,
       viewportWidth,
@@ -493,24 +600,37 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
   });
 
   const handleContentSizeChange = useStableEvent((_width: number, height: number) => {
-    const previousContentHeight = streamViewportMetricsRef.current.contentHeight;
     const nextContentHeight = Math.max(0, height);
     streamViewportMetricsRef.current = {
       ...streamViewportMetricsRef.current,
       containerKey: "native-virtualized",
       contentHeight: nextContentHeight,
-      contentMeasuredForKey: "native-virtualized",
+      contentMeasuredForKey: isListPlacedRef.current ? "native-virtualized" : null,
     };
-    bottomAnchorController.handleContentSizeChange({
-      previousContentHeight,
-      contentHeight: nextContentHeight,
-    });
+    bottomAnchorController.handleContentSizeChange();
+    // Content growing below a detached viewport moves the end away without a scroll event.
+    if (
+      bottomAnchorController.mode === "detached" &&
+      streamViewportMetricsRef.current.viewportHeight > 0
+    ) {
+      publishNearBottom();
+    }
     evaluateHistoryStart();
     if (historyStartPaginationStateRef.current.status === "settling") {
       scheduleHistoryStartSettle();
     }
   });
 
+  const handleListPlaced = useStableEvent(() => {
+    isListPlacedRef.current = true;
+    setPlacedAgentId(agentId);
+    streamViewportMetricsRef.current = {
+      ...streamViewportMetricsRef.current,
+      contentMeasuredForKey: "native-virtualized",
+    };
+    bottomAnchorController.handleContentSizeChange();
+  });
+
   useEffect(() => {
     evaluateHistoryStart();
     if (historyStartPaginationStateRef.current.status === "settling") {
@@ -524,45 +644,35 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     scheduleHistoryStartSettle,
   ]);
 
+  // LegendList re-renders a mounted row only when its item or `extraData` changes, not when
+  // renderItem does. Item identity carries content and display changes (`useRevisedHistoryRows`);
+  // `extraData` carries the history renderer, whose identity changes with the history layout (a
+  // reply gaining its completed footer when the next prompt arrives) and keeps its row's item.
+  // StreamRow's memo limits that pass to the rows whose layout item changed.
   const renderItem = useStableEvent(
-    ({ item, index }: ListRenderItemInfo<StreamItem>): ReactElement | null => {
-      const rendered = renderHistoryMountedRow(item, index, historyItems);
-      return (rendered ?? null) as ReactElement | null;
-    },
+    ({ item, index }: LegendListRenderItemProps<StreamItem>): ReactElement => (
+      <RowLayoutSync rowId={item.id} registry={rowLayoutSyncRegistry}>
+        {liveRowIds.has(item.id)
+          ? renderLiveHeadRow(item, index - historyRows.length, segments.liveHead)
+          : renderHistoryMountedRow(item, index, historyItems)}
+      </RowLayoutSync>
+    ),
   );
 
-  const liveHeaderContent = useMemo(() => {
-    // Stable render events read the latest expansion state; this revision makes
-    // the memo invoke them again when that state changes.
-    void liveHeadRowRevision;
-    const liveHeadRows = segments.liveHead.map((item, index) => (
-      <Fragment key={item.id}>{renderLiveHeadRow(item, index, segments.liveHead)}</Fragment>
-    ));
+  const liveAuxiliaryContent = useMemo(() => {
     const liveAuxiliary = renderLiveAuxiliary();
     if (
-      liveHeadRows.length === 0 &&
+      liveRows.length === 0 &&
       !liveAuxiliary &&
       !boundary.hasMountedHistory &&
       !boundary.hasVirtualizedHistory
     ) {
       return (listEmptyComponent ?? null) as ReactElement | null;
     }
-    return (
-      <Fragment>
-        {liveHeadRows}
-        {liveAuxiliary}
-      </Fragment>
-    );
-  }, [
-    boundary,
-    listEmptyComponent,
-    liveHeadRowRevision,
-    renderLiveAuxiliary,
-    renderLiveHeadRow,
-    segments.liveHead,
-  ]);
+    return <View>{liveAuxiliary}</View>;
+  }, [boundary, listEmptyComponent, liveRows.length, renderLiveAuxiliary]);
 
-  const historyFooterContent = useMemo(() => {
+  const historyStartContent = useMemo(() => {
     const isLoadingOperation = isHistoryStartLoadingOperation(historyStartPaginationState);
     return (
       <View style={historyStartSlotStyle} testID="older-history-slot">
@@ -575,21 +685,21 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     );
   }, [historyStartPaginationState]);
 
-  // RN's FlatList strictMode keeps its internal renderItem wrapper stable when
-  // data or the live header changes, preserving the row identities above.
   return (
-    <FlatList
-      {...listInsetProps}
-      ref={flatListRef}
-      data={historyRows}
+    <LegendList<StreamItem>
+      ref={listRef}
+      data={rows}
       renderItem={renderItem}
+      extraData={renderHistoryMountedRow}
       keyExtractor={keyExtractor}
-      strictMode
       testID="agent-chat-scroll"
       nativeID="agent-chat-scroll-native-virtualized"
-      ListHeaderComponent={liveHeaderContent ?? undefined}
-      ListFooterComponent={historyFooterContent ?? undefined}
+      ListHeaderComponent={historyStartContent}
+      ListFooterComponent={liveAuxiliaryContent ?? undefined}
       contentContainerStyle={listContentContainerStyle}
+      automaticallyAdjustContentInsets={false}
+      automaticallyAdjustsScrollIndicatorInsets={false}
+      contentInsetAdjustmentBehavior="never"
       style={listStyle}
       onLayout={handleListLayout}
       onScroll={handleScroll}
@@ -599,16 +709,18 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
       onMomentumScrollEnd={handleMomentumScrollEnd}
       scrollEventThrottle={16}
       onContentSizeChange={handleContentSizeChange}
+      onItemSizeChanged={handleItemSizeChanged}
+      onReady={handleListPlaced}
+      dataKey={agentId}
       maintainVisibleContentPosition={maintainVisibleContentPosition}
-      // Tall Markdown rows exhaust a shallow window during flings. Keep the initial
-      // render small, then refill a deeper window in batches large enough to keep up.
-      initialNumToRender={2}
-      maxToRenderPerBatch={10}
-      windowSize={NATIVE_STREAM_WINDOW_SIZE}
-      removeClippedSubviews={false}
+      renderScrollComponent={renderScrollComponent}
+      recycleItems={false}
+      alignItemsAtEnd
+      initialScrollAtEnd
+      drawDistance={NATIVE_STREAM_DRAW_DISTANCE}
+      getEstimatedItemSize={getEstimatedItemSize}
       scrollEnabled={scrollEnabled}
       showsVerticalScrollIndicator
-      inverted
     />
   );
 }
@@ -616,26 +728,20 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
 export function createNativeStreamStrategy(): StreamStrategy {
   const strategy = createStreamStrategy({
     render: (renderInput) => <NativeStreamViewport {...renderInput} strategy={strategy} />,
-    orderTailReverse: true,
-    orderHeadReverse: true,
-    assistantTurnTraversalStep: 1,
-    edgeSlot: "header",
-    historyLiveBoundaryEdge: "first",
-    liveHeadHistoryBoundaryEdge: "last",
-    frameChildOrder: "footer-then-content",
-    flatListInverted: true,
-    overlayScrollbarInverted: true,
-    maintainVisibleContentPosition: DEFAULT_MAINTAIN_VISIBLE_CONTENT_POSITION,
-    bottomAnchorTransportBehavior: {
-      verificationDelayFrames: 2,
-      verificationRetryMode: "recheck",
-    },
+    orderTailReverse: false,
+    orderHeadReverse: false,
+    assistantTurnTraversalStep: -1,
+    edgeSlot: "footer",
+    historyLiveBoundaryEdge: "last",
+    liveHeadHistoryBoundaryEdge: "first",
+    frameChildOrder: "content-then-footer",
+    bottomAnchorTransportBehavior: BOTTOM_ANCHOR_TRANSPORT_BEHAVIOR,
     disableParentScrollOnInlineDetailsExpansion: false,
     anchorBottomOnContentSizeChange: false,
     animateManualScrollToBottom: true,
     useVirtualizedList: true,
-    isNearBottom: (input) => input.offsetY <= input.threshold,
-    getBottomOffset: () => 0,
+    isNearBottom: (input) => distanceFromEnd(input) <= input.threshold,
+    getBottomOffset: (metrics) => Math.max(0, metrics.contentHeight - metrics.viewportHeight),
   });
   return strategy;
 }

packages/app/src/agent-stream/strategy-web.browser.test.tsx

@@ -0,0 +1,158 @@
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { DEFAULT_CONTENT_MAX_WIDTH } from "@/styles/theme";
+import type { StreamItem } from "@/types/stream";
+import type { StreamRenderInput, StreamViewportHandle } from "./strategy";
+import { createWebStreamStrategy } from "./strategy-web";
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+
+const VIEWPORT_HEIGHT = 100;
+const ROW_HEIGHT = 40;
+
+// A row's height comes from its text, so a disclosure that opens or grows a row is a new item
+// for that row, as it is in the app.
+function row(index: number, height = ROW_HEIGHT): Extract<StreamItem, { kind: "user_message" }> {
+  return {
+    kind: "user_message",
+    id: `message-${index}`,
+    text: String(height),
+    timestamp: new Date(`2026-04-20T00:00:${String(index % 60).padStart(2, "0")}.000Z`),
+  };
+}
+
+const rowStyleByHeight = new Map<number, { height: number }>();
+
+function renderRow(item: StreamItem) {
+  const height = item.kind === "user_message" ? Number(item.text) : ROW_HEIGHT;
+  let style = rowStyleByHeight.get(height);
+  if (!style) {
+    style = { height };
+    rowStyleByHeight.set(height, style);
+  }
+  return <div style={style}>{item.id}</div>;
+}
+
+let root: Root;
+let host: HTMLDivElement;
+
+beforeEach(() => {
+  host = document.createElement("div");
+  host.style.cssText = `display:flex;flex-direction:column;width:500px;height:${VIEWPORT_HEIGHT}px`;
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+
+function mountTimeline(historyMounted: StreamItem[]) {
+  const strategy = createWebStreamStrategy({ isMobileBreakpoint: true });
+  const viewportRef = React.createRef<StreamViewportHandle>();
+  const input: StreamRenderInput = {
+    agentId: "agent",
+    segments: { historyVirtualized: [], historyMounted, liveHead: [] },
+    boundary: { hasVirtualizedHistory: false, hasMountedHistory: true, hasLiveHead: false },
+    renderers: {
+      renderHistoryVirtualizedRow: renderRow,
+      renderHistoryMountedRow: renderRow,
+      renderLiveHeadRow: renderRow,
+      renderLiveAuxiliary: () => null,
+    },
+    listEmptyComponent: null,
+    viewportRef,
+    routeBottomAnchorRequest: null,
+    isAuthoritativeHistoryReady: true,
+    onNearBottomChange: () => {},
+    onNearHistoryStart: () => true,
+    isLoadingOlderHistory: false,
+    hasOlderHistory: false,
+    olderHistoryProgressKey: null,
+    scrollEnabled: true,
+    listStyle: null,
+    baseListContentContainerStyle: null,
+    forwardListContentContainerStyle: null,
+    contentMaxWidth: DEFAULT_CONTENT_MAX_WIDTH,
+  };
+  const render = (segments: Partial<StreamRenderInput["segments"]>) =>
+    root.render(strategy.render({ ...input, segments: { ...input.segments, ...segments } }));
+  act(() => render({}));
+
+  const scrollContainer = host.querySelector<HTMLElement>('[data-testid="agent-chat-scroll"]');
+  if (!scrollContainer) throw new Error("Expected agent chat scroll container");
+  const rowElement = (id: string) => {
+    const element = host.querySelector<HTMLElement>(`[data-history-row-id="${id}"]`);
+    if (!element) throw new Error(`Expected row ${id}`);
+    return element;
+  };
+
+  return {
+    render: (segments: Partial<StreamRenderInput["segments"]>) => act(() => render(segments)),
+    hold: (rowId: string, apply: () => void) =>
+      act(() => viewportRef.current!.holdRow(rowId, apply)),
+    rowTop: (id: string) =>
+      rowElement(id).getBoundingClientRect().top - scrollContainer.getBoundingClientRect().top,
+    distanceFromEnd: () =>
+      scrollContainer.scrollHeight - scrollContainer.clientHeight - scrollContainer.scrollTop,
+    // Resize observers and the hold's settle run on animation frames.
+    settle: () =>
+      act(async () => {
+        for (let frame = 0; frame < 4; frame += 1) {
+          await new Promise((resolve) => requestAnimationFrame(resolve));
+        }
+      }),
+  };
+}
+
+describe("web disclosure hold", () => {
+  it("keeps the trigger's top when an anchored toggle at the bottom opens rows below it, and stops following", async () => {
+    const history = [1, 2, 3, 4, 5, 6].map((index) => row(index));
+    const timeline = mountTimeline(history);
+    await timeline.settle();
+    expect(timeline.distanceFromEnd()).toBeLessThanOrEqual(1);
+    const triggerTop = timeline.rowTop("message-5");
+
+    timeline.hold("message-5", () =>
+      timeline.render({ historyMounted: [...history.slice(0, 5), row(7, 200), history[5]!] }),
+    );
+    await timeline.settle();
+    expect(timeline.rowTop("message-5")).toBe(triggerTop);
+
+    timeline.render({ liveHead: [row(8)] });
+    await timeline.settle();
+    expect(timeline.rowTop("message-5")).toBe(triggerTop);
+  });
+
+  it("keeps the trigger's top when its row grows while following output", async () => {
+    const history = [1, 2, 3, 4, 5, 6].map((index) => row(index));
+    const timeline = mountTimeline(history);
+    await timeline.settle();
+    const triggerTop = timeline.rowTop("message-5");
+
+    timeline.hold("message-5", () =>
+      timeline.render({ historyMounted: [...history.slice(0, 4), row(5, 240), history[5]!] }),
+    );
+    await timeline.settle();
+    expect(timeline.rowTop("message-5")).toBe(triggerTop);
+  });
+
+  it("resumes following when collapsing an anchored row lands back at the end", async () => {
+    const history = [1, 2, 3, 4, 5, 6].map((index) => row(index));
+    const timeline = mountTimeline(history);
+    await timeline.settle();
+    timeline.hold("message-5", () =>
+      timeline.render({ historyMounted: [...history.slice(0, 4), row(5, 240), history[5]!] }),
+    );
+    await timeline.settle();
+
+    timeline.hold("message-5", () => timeline.render({ historyMounted: history }));
+    await timeline.settle();
+
+    timeline.render({ liveHead: [row(8)] });
+    await timeline.settle();
+    expect(timeline.distanceFromEnd()).toBeLessThanOrEqual(1);
+  });
+});

packages/app/src/agent-stream/strategy-web.tsx

@@ -363,6 +363,8 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
   const wasFollowOutputLayoutActiveRef = useRef(false);
   const resumedUnchangedLayoutRef = useRef(false);
   const pendingResumeGeometryCheckRef = useRef(false);
+  // Set by holdRow; the next reading reconcile sees the disclosure's layout.
+  const disclosurePendingRef = useRef(false);
   const shouldUseVirtualizer = segments.historyVirtualized.length > 0;
   const {
     renderHistoryVirtualizedRow,
@@ -728,22 +730,27 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
     onNearBottomChange,
   });
 
-  const reconcileReadingPosition = useStableEvent(() => {
+  // Row tops in content coordinates, which survive scrolling.
+  const measureRows = useStableEvent(() => {
     const container = scrollContainerRef.current;
     const content = contentRef.current;
-    if (!isActiveRef.current || !container || !content) return;
+    if (!container || !content) return null;
     const viewportTop = container.getBoundingClientRect().top;
     const scrollTop = container.scrollTop;
     const width = content.getBoundingClientRect().width;
-    const rows = Array.from(
-      content.querySelectorAll<HTMLElement>("[data-history-row-id]"),
-      (element) => {
-        const bounds = element.getBoundingClientRect();
-        const id = element.dataset.historyRowId!;
-        measuredRowHeights.current.set(id, { width, height: bounds.height });
-        return { id, top: bounds.top - viewportTop + scrollTop, height: bounds.height };
-      },
-    );
+    return Array.from(content.querySelectorAll<HTMLElement>("[data-history-row-id]"), (element) => {
+      const bounds = element.getBoundingClientRect();
+      const id = element.dataset.historyRowId!;
+      measuredRowHeights.current.set(id, { width, height: bounds.height });
+      return { id, top: bounds.top - viewportTop + scrollTop, height: bounds.height };
+    });
+  });
+
+  const reconcileReadingPosition = useStableEvent(() => {
+    const container = scrollContainerRef.current;
+    if (!isActiveRef.current || !container) return;
+    const rows = measureRows();
+    if (!rows) return;
     const shouldAnchor = !followOutputRef.current && !isJumpSettling();
     if (!shouldAnchor) readingAnchor.reset();
     const correctedTop = readingAnchor.reconcile(
@@ -763,6 +770,11 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
       // this layout so the reader does not get a frame containing only the pin.
       virtualOffsetListener.current?.(container.scrollTop, false);
     }
+    // A disclosure that closes back to the end of the list rejoins the output.
+    if (disclosurePendingRef.current) {
+      disclosurePendingRef.current = false;
+      if (isScrollContainerAtBottom(container)) setFollowOutput(true);
+    }
   });
 
   // Apply row positions and their scroll correction in the same paint, including
@@ -1182,10 +1194,13 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
         }
         scheduleStickToBottom();
       },
-      holdReadingPosition: () => {
+      holdRow: (rowId, apply) => {
         cancelPendingStickToBottom();
         setFollowOutput(false);
-        readingAnchor.scroll(scrollContainerRef.current?.scrollTop ?? 0);
+        const row = measureRows()?.find((candidate) => candidate.id === rowId);
+        if (row) readingAnchor.pin(row);
+        disclosurePendingRef.current = true;
+        apply();
       },
       scrollToMessage,
     };
@@ -1199,6 +1214,7 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
   }, [
     cancelPendingStickToBottom,
     forceStickToBottom,
+    measureRows,
     readingAnchor,
     scheduleStickToBottom,
     scrollToMessage,
@@ -1392,9 +1408,6 @@ export function createWebStreamStrategy(input: CreateWebStreamStrategyInput): St
     historyLiveBoundaryEdge: "last",
     liveHeadHistoryBoundaryEdge: "first",
     frameChildOrder: "content-then-footer",
-    flatListInverted: false,
-    overlayScrollbarInverted: false,
-    maintainVisibleContentPosition: undefined,
     bottomAnchorTransportBehavior: {
       verificationDelayFrames: 0,
       verificationRetryMode: "rescroll",

packages/app/src/agent-stream/strategy.ts

@@ -14,11 +14,6 @@ type NeighborRelation = "above" | "below";
 type AssistantTurnTraversalStep = -1 | 1;
 export type StreamFrameChildOrder = "content-then-footer" | "footer-then-content";
 
-export type MaintainVisibleContentPositionConfig = Readonly<{
-  minIndexForVisible: number;
-  autoscrollToTopThreshold: number;
-}>;
-
 export type BottomAnchorTransportBehavior = Readonly<{
   verificationDelayFrames: number;
   verificationRetryMode: "rescroll" | "recheck";
@@ -56,8 +51,11 @@ export interface StreamViewportHandle {
   focus?: () => void;
   scrollToBottom: (reason?: BottomAnchorLocalRequest["reason"]) => void;
   prepareForViewportChange: () => void;
-  /** Stop following output so the rows on screen stay put while rows below them open or close. */
-  holdReadingPosition: () => void;
+  /**
+   * Run a disclosure's state change so the row that owns its trigger keeps its visual top.
+   * Following output stops; it resumes if the change leaves the list at its end.
+   */
+  holdRow: (rowId: string, apply: () => void) => void;
   scrollToMessage?: (messageId: string, occurrence?: ScrollToMessageOccurrence) => void;
 }
 
@@ -125,14 +123,11 @@ export interface StreamStrategy {
     component: ReactElement | ComponentType<unknown> | null,
     gapSize: number,
   ) => StreamEdgeSlotProps;
-  getMaintainVisibleContentPosition: () => MaintainVisibleContentPositionConfig | undefined;
   getBottomAnchorTransportBehavior: () => BottomAnchorTransportBehavior;
   getHistoryLiveBoundaryIndex: (history: StreamItem[]) => number | null;
   getLiveHeadHistoryBoundaryIndex: (liveHead: StreamItem[]) => number | null;
   getLatestItemIndex: (items: StreamItem[]) => number | null;
   getFrameChildOrder: () => StreamFrameChildOrder;
-  getFlatListInverted: () => boolean;
-  getOverlayScrollbarInverted: () => boolean;
   shouldDisableParentScrollOnInlineDetailsExpansion: () => boolean;
   shouldAnchorBottomOnContentSizeChange: () => boolean;
   shouldAnimateManualScrollToBottom: () => boolean;
@@ -148,9 +143,6 @@ interface StreamStrategyConfig {
   historyLiveBoundaryEdge: "first" | "last";
   liveHeadHistoryBoundaryEdge: "first" | "last";
   frameChildOrder: StreamFrameChildOrder;
-  flatListInverted: boolean;
-  overlayScrollbarInverted: boolean;
-  maintainVisibleContentPosition?: MaintainVisibleContentPositionConfig;
   bottomAnchorTransportBehavior: BottomAnchorTransportBehavior;
   disableParentScrollOnInlineDetailsExpansion: boolean;
   anchorBottomOnContentSizeChange: boolean;
@@ -160,8 +152,6 @@ interface StreamStrategyConfig {
   getBottomOffset: (metrics: StreamViewportMetrics) => number;
 }
 
-const NATIVE_SETTLING_VERIFICATION_DELAY_FRAMES = 4;
-
 export function createStreamStrategy(config: StreamStrategyConfig): StreamStrategy {
   return {
     render: config.render,
@@ -216,7 +206,6 @@ export function createStreamStrategy(config: StreamStrategyConfig): StreamStrate
         ListFooterComponentStyle: { marginTop: gapSize },
       };
     },
-    getMaintainVisibleContentPosition: () => config.maintainVisibleContentPosition,
     getBottomAnchorTransportBehavior: () => config.bottomAnchorTransportBehavior,
     getHistoryLiveBoundaryIndex: (history) => {
       if (history.length === 0) {
@@ -237,8 +226,6 @@ export function createStreamStrategy(config: StreamStrategyConfig): StreamStrate
       return config.historyLiveBoundaryEdge === "first" ? 0 : items.length - 1;
     },
     getFrameChildOrder: () => config.frameChildOrder,
-    getFlatListInverted: () => config.flatListInverted,
-    getOverlayScrollbarInverted: () => config.overlayScrollbarInverted,
     shouldDisableParentScrollOnInlineDetailsExpansion: () =>
       config.disableParentScrollOnInlineDetailsExpansion,
     shouldAnchorBottomOnContentSizeChange: () => config.anchorBottomOnContentSizeChange,
@@ -247,23 +234,6 @@ export function createStreamStrategy(config: StreamStrategyConfig): StreamStrate
   };
 }
 
-export function resolveBottomAnchorTransportBehavior(input: {
-  strategy: StreamStrategy;
-  isViewportSettling: boolean;
-}): BottomAnchorTransportBehavior {
-  const baseBehavior = input.strategy.getBottomAnchorTransportBehavior();
-  if (!input.isViewportSettling || !input.strategy.getFlatListInverted()) {
-    return baseBehavior;
-  }
-  return {
-    verificationDelayFrames: Math.max(
-      baseBehavior.verificationDelayFrames,
-      NATIVE_SETTLING_VERIFICATION_DELAY_FRAMES,
-    ),
-    verificationRetryMode: "recheck",
-  };
-}
-
 export function orderTailForStreamRenderStrategy(params: {
   strategy: StreamStrategy;
   streamItems: StreamItem[];

packages/app/src/agent-stream/stream-row.browser.test.tsx

@@ -0,0 +1,69 @@
+import { act, createRef } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, expect, it } from "vitest";
+import type { StreamItem } from "@/types/stream";
+import type { StreamLayoutItem } from "./layout";
+import type { StreamViewportHandle } from "./strategy";
+import { renderStreamRow } from "./stream-row";
+
+// stream-row.tsx is compiled with the React Compiler here, as Expo compiles it.
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+
+let root: Root;
+let host: HTMLDivElement;
+
+beforeEach(() => {
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+
+const turnHost: StreamItem = {
+  kind: "user_message",
+  id: "host",
+  text: "Fix the build",
+  timestamp: new Date(0),
+};
+
+const turnHostLayout: StreamLayoutItem = {
+  item: turnHost,
+  aboveItem: null,
+  // The turn's rows land below another row, so opening it leaves the host's layout unchanged.
+  belowItem: null,
+  gapBelow: 0,
+  assistantSpacing: "default",
+  completedFooter: null,
+  toolSequence: "none",
+  isFirstInUserGroup: true,
+  isLastInUserGroup: true,
+  isLastInToolSequence: false,
+  frameOrder: "content-then-footer",
+  phase: "complete",
+};
+
+it("renders a revised row again when its layout is unchanged", () => {
+  // The turn's open state lives outside the row, as `getCollapsedTurn` reads it in view.tsx.
+  let turnOpen = false;
+  const renderStreamItem = () => <span>{turnOpen ? "open" : "closed"}</span>;
+  const viewportRef = createRef<StreamViewportHandle>();
+  const layoutItemById = new Map([[turnHost.id, turnHostLayout]]);
+  const renderRow = (item: StreamItem) =>
+    act(() =>
+      root.render(renderStreamRow({ item, layoutItemById, renderStreamItem, viewportRef })),
+    );
+
+  renderRow(turnHost);
+  expect(host.textContent).toBe("closed");
+
+  turnOpen = true;
+  // useRevisedHistoryRows hands the row a fresh item when its display state changes.
+  renderRow({ ...turnHost });
+
+  expect(host.textContent).toBe("open");
+});

packages/app/src/agent-stream/stream-row.tsx

@@ -0,0 +1,58 @@
+import { memo, type ReactNode, type RefObject } from "react";
+import type { StreamItem } from "@/types/stream";
+import { DisclosureRow } from "./disclosure";
+import type { StreamLayoutItem } from "./layout";
+import type { StreamViewportHandle } from "./strategy";
+
+/**
+ * Renders a timeline row from the item the row was handed. The item is a revision of
+ * `layoutItem.item` with the same content: render from it, so a revision that leaves the layout
+ * unchanged still renders the row again.
+ */
+export type RenderStreamItem = (item: StreamItem, layoutItem: StreamLayoutItem) => ReactNode;
+
+// Live and retained rows use the same boundary so completion preserves the message
+// subtree, including measured diagrams and selections. LegendList renders every mounted row
+// again when `extraData` (the history renderer) changes, and history rows shift index when older
+// history loads. This boundary limits that pass: a row renders again only when its stream item
+// identity, its layout item identity, or the renderer itself changes. Item identity is the
+// revision signal the strategy already uses (`useRevisedHistoryRows` clones items whose content or
+// display state changed). The row passes the item to the renderer, so the React Compiler's cache
+// of the rendered content keys on it too.
+const StreamRow = memo(function StreamRow({
+  item,
+  layoutItem,
+  renderStreamItem,
+  viewportRef,
+}: {
+  item: StreamItem;
+  layoutItem: StreamLayoutItem;
+  renderStreamItem: RenderStreamItem;
+  viewportRef: RefObject<StreamViewportHandle | null>;
+}) {
+  return (
+    <DisclosureRow rowId={item.id} viewportRef={viewportRef}>
+      {renderStreamItem(item, layoutItem)}
+    </DisclosureRow>
+  );
+});
+
+export function renderStreamRow(input: {
+  item: StreamItem;
+  layoutItemById: Map<string, StreamLayoutItem>;
+  renderStreamItem: RenderStreamItem;
+  viewportRef: RefObject<StreamViewportHandle | null>;
+}): ReactNode {
+  const layoutItem = input.layoutItemById.get(input.item.id);
+  if (!layoutItem) {
+    return null;
+  }
+  return (
+    <StreamRow
+      item={input.item}
+      layoutItem={layoutItem}
+      renderStreamItem={input.renderStreamItem}
+      viewportRef={input.viewportRef}
+    />
+  );
+}

packages/app/src/agent-stream/top-overlay.ts

@@ -1,7 +1,7 @@
 import { createContext, useContext } from "react";
 import { isNative } from "@/constants/platform";
 
-/** The native inverted viewport reserves visual-top clearance; web stays in flow. */
+/** The native viewport reserves top clearance under the overlay; web stays in flow. */
 export const supportsStreamTopOverlay = isNative;
 
 const StreamTopOverlayContext = createContext(0);

packages/app/src/agent-stream/turn-collapse/model.test.ts

@@ -41,6 +41,7 @@ function collapse(tail: StreamItem[], options: Partial<CollapseTurnsInput> = {})
     isLatestTurnOpen: false,
     expandedHostIds: new Set(),
     getGroupedCalls: () => undefined,
+    previousTurnsByHostId: new Map(),
     ...options,
   });
 }
@@ -48,6 +49,37 @@ function collapse(tail: StreamItem[], options: Partial<CollapseTurnsInput> = {})
 const ids = (items: StreamItem[]) => items.map((item) => item.id);
 
 describe("collapseTurns", () => {
+  // A history row renders again only when its item changes, so a prompt that is already retained
+  // when its turn closes needs its row revised to show the summary line.
+  it("reports the hosts whose summary line appeared, changed or went away", () => {
+    const open = collapse([user("u1"), shell("c1"), reply("r1"), user("u2"), shell("c2")], {
+      isLatestTurnOpen: true,
+    });
+    expect([...open.updatedHostIds]).toEqual(["u1"]);
+    const closed = collapse(
+      [user("u1"), shell("c1"), reply("r1"), user("u2"), shell("c2"), reply("r2")],
+      {
+        previousTurnsByHostId: open.turnsByHostId,
+      },
+    );
+    expect([...closed.updatedHostIds]).toEqual(["u2"]);
+    const unchanged = collapse(
+      [user("u1"), shell("c1"), reply("r1"), user("u2"), shell("c2"), reply("r2")],
+      {
+        previousTurnsByHostId: closed.turnsByHostId,
+      },
+    );
+    expect(unchanged.updatedHostIds.size).toBe(0);
+    const moreWork = collapse(
+      [user("u1"), shell("c1"), reply("r1"), user("u2"), shell("c2"), shell("c3"), reply("r2")],
+      { previousTurnsByHostId: unchanged.turnsByHostId },
+    );
+    expect([...moreWork.updatedHostIds]).toEqual(["u2"]);
+    const rewound = collapse([user("u1"), shell("c1"), reply("r1")], {
+      previousTurnsByHostId: moreWork.turnsByHostId,
+    });
+    expect([...rewound.updatedHostIds]).toEqual(["u2"]);
+  });
   it("maps hidden rows only while their turn is closed", () => {
     const result = collapse([user("u1"), shell("c1"), reply("final")]);
     expect(result.hostIdByHiddenRowId.get("c1")).toBe("u1");

packages/app/src/agent-stream/turn-collapse/model.ts

@@ -27,6 +27,11 @@ export interface TurnCollapse {
   hostIdByFoldedMessageId: ReadonlyMap<string, string>;
   /** Mounted rows replaced by a closed turn's host, for preserving the reading position. */
   hostIdByHiddenRowId: ReadonlyMap<string, string>;
+  /**
+   * Hosts whose summary line appeared, changed or went away since `previousTurnsByHostId`. A
+   * history row renders again only when its item changes, so these rows are revised.
+   */
+  updatedHostIds: ReadonlySet<string>;
 }
 
 export interface CollapseTurnsInput {
@@ -36,6 +41,8 @@ export interface CollapseTurnsInput {
   expandedHostIds: ReadonlySet<string>;
   /** The calls a tool-call group row stands for; undefined for a single call. */
   getGroupedCalls: (itemId: string) => readonly (ToolCallItem | ThoughtItem)[] | undefined;
+  /** The previous fold of the same history, the baseline for `updatedHostIds`. */
+  previousTurnsByHostId: ReadonlyMap<string, CollapsedTurn>;
 }
 
 const EMPTY_TURNS: ReadonlyMap<string, CollapsedTurn> = new Map();
@@ -59,6 +66,36 @@ function hasWork(summary: TurnSummary): boolean {
   return Object.keys(paseoActions).length > 0 || Object.values(counts).some((count) => count > 0);
 }
 
+function isSameTurn(a: CollapsedTurn, b: CollapsedTurn): boolean {
+  const { paseoActions: actionsA, ...countsA } = a.summary.tools;
+  const { paseoActions: actionsB, ...countsB } = b.summary.tools;
+  return (
+    a.expanded === b.expanded &&
+    hasSameCounts(countsA, countsB) &&
+    hasSameCounts(actionsA, actionsB)
+  );
+}
+
+function hasSameCounts(a: Record<string, number>, b: Record<string, number>): boolean {
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((key) => a[key] === b[key]);
+}
+
+function findUpdatedHosts(
+  previous: ReadonlyMap<string, CollapsedTurn>,
+  next: ReadonlyMap<string, CollapsedTurn>,
+): ReadonlySet<string> {
+  const updated = new Set<string>();
+  for (const [hostId, turn] of next) {
+    const before = previous.get(hostId);
+    if (!before || !isSameTurn(before, turn)) updated.add(hostId);
+  }
+  for (const hostId of previous.keys()) {
+    if (!next.has(hostId)) updated.add(hostId);
+  }
+  return updated.size === 0 ? EMPTY_IDS : updated;
+}
+
 function staysVisibleWhenCollapsed(item: StreamItem): boolean {
   return isTurnTrigger(item) || item.kind === "compaction";
 }
@@ -137,6 +174,7 @@ export function collapseTurns(input: CollapseTurnsInput): TurnCollapse {
   }
   flushRun(tail.length);
 
+  const updatedHostIds = findUpdatedHosts(input.previousTurnsByHostId, turnsByHostId);
   if (turnsByHostId.size === 0) {
     return {
       tail,
@@ -144,6 +182,7 @@ export function collapseTurns(input: CollapseTurnsInput): TurnCollapse {
       nestedItemIds: EMPTY_IDS,
       hostIdByFoldedMessageId: EMPTY_HOSTS,
       hostIdByHiddenRowId: EMPTY_HOSTS,
+      updatedHostIds,
     };
   }
   return {
@@ -155,5 +194,6 @@ export function collapseTurns(input: CollapseTurnsInput): TurnCollapse {
     nestedItemIds,
     hostIdByFoldedMessageId,
     hostIdByHiddenRowId,
+    updatedHostIds,
   };
 }

packages/app/src/agent-stream/turn-collapse/summary-line.tsx

@@ -1,6 +1,7 @@
 import { memo, useCallback } from "react";
 import { useTranslation } from "react-i18next";
 import { Summary } from "lucide-react-native";
+import { useDisclosureHold } from "@/agent-stream/disclosure";
 import { ExpandableBadge } from "@/components/message";
 import { useOverviewSummaryLabel } from "@/tool-calls/detail-level/overview/label";
 import type { CollapsedTurn } from "./model";
@@ -18,9 +19,10 @@ export const TurnSummaryLine = memo(function TurnSummaryLine({
 }) {
   const { t } = useTranslation();
   const label = useOverviewSummaryLabel(turn.summary.tools) || t("turnSummary.details");
+  const hold = useDisclosureHold();
   const toggle = useCallback(
-    () => onExpandedChange(turn.hostId, !turn.expanded),
-    [onExpandedChange, turn.expanded, turn.hostId],
+    () => hold(() => onExpandedChange(turn.hostId, !turn.expanded)),
+    [hold, onExpandedChange, turn.expanded, turn.hostId],
   );
 
   return (

packages/app/src/agent-stream/view.tsx

@@ -74,6 +74,8 @@ import { TurnSummaryLine } from "./turn-collapse/summary-line";
 import { type AgentStreamRenderModel, buildAgentStreamRenderModel } from "./model";
 import { resolveStreamRenderStrategy } from "./strategy-resolver";
 import { type StreamSegmentRenderers, type StreamViewportHandle } from "./strategy";
+import { renderStreamRow, type RenderStreamItem } from "./stream-row";
+import { type NearBottom, useIsNearBottom, useNearBottom } from "./near-bottom";
 import { ChatOutlineRail } from "@/agent-stream/chat-outline/rail";
 import { useChatOutline } from "@/agent-stream/chat-outline/use-chat-outline";
 import { getHostRuntimeStore } from "@/runtime/host-runtime";
@@ -230,41 +232,6 @@ function renderListEmptyComponent(input: {
   );
 }
 
-// Live and retained rows use the same boundary so completion preserves the message
-// subtree, including measured diagrams and selections. FlatList recreates history
-// cells with fresh refs and shifted indexes on data changes. This boundary is
-// what stops that churn: a row renders again only when its stream item identity, its layout item
-// identity, or the renderer itself changes. Item identity is the revision signal the strategy
-// already uses (`useRevisedHistoryRows` clones items whose content or display state changed).
-const StreamRow = memo(function StreamRow({
-  layoutItem,
-  renderStreamItem,
-}: {
-  item: StreamItem;
-  layoutItem: StreamLayoutItem;
-  renderStreamItem: (layoutItem: StreamLayoutItem) => ReactNode;
-}) {
-  return <>{renderStreamItem(layoutItem)}</>;
-});
-
-function renderStreamRow(input: {
-  item: StreamItem;
-  layoutItemById: Map<string, StreamLayoutItem>;
-  renderStreamItem: (layoutItem: StreamLayoutItem) => ReactNode;
-}): ReactNode {
-  const layoutItem = input.layoutItemById.get(input.item.id);
-  if (!layoutItem) {
-    return null;
-  }
-  return (
-    <StreamRow
-      item={input.item}
-      layoutItem={layoutItem}
-      renderStreamItem={input.renderStreamItem}
-    />
-  );
-}
-
 export interface AgentStreamViewHandle {
   scrollToBottom(reason?: BottomAnchorLocalRequest["reason"]): void;
   prepareForViewportChange(): void;
@@ -324,6 +291,47 @@ function resolveBottomOverlayControlOffset(clearance: number | undefined): numbe
   return Math.max(16, clearance ?? 0);
 }
 
+// Keep entry/exit animations off on Android due to RN dispatchDraw crashes
+// tracked in react-native-reanimated#8422.
+const shouldDisableEntryExitAnimations = Platform.OS === "android";
+const scrollIndicatorFadeIn = shouldDisableEntryExitAnimations ? undefined : FadeIn.duration(200);
+const scrollIndicatorFadeOut = shouldDisableEntryExitAnimations ? undefined : FadeOut.duration(200);
+
+function ScrollToBottomButton({
+  nearBottom,
+  isTimelineDetached,
+  bottomOffset,
+  onPress,
+}: {
+  nearBottom: NearBottom;
+  isTimelineDetached: boolean;
+  bottomOffset: number;
+  onPress: () => void;
+}) {
+  const { t } = useTranslation();
+  const isNearBottom = useIsNearBottom(nearBottom);
+  const containerStyle = useMemo(
+    () => [stylesheet.scrollToBottomContainer, { bottom: bottomOffset }],
+    [bottomOffset],
+  );
+  if (isNearBottom && !isTimelineDetached) return null;
+  return (
+    <View style={containerStyle} pointerEvents="box-none">
+      <Animated.View entering={scrollIndicatorFadeIn} exiting={scrollIndicatorFadeOut}>
+        <Pressable
+          style={stylesheet.scrollToBottomButton}
+          onPress={onPress}
+          accessibilityRole="button"
+          accessibilityLabel={t("agentStream.scrollToBottom")}
+          testID="scroll-to-bottom-button"
+        >
+          <ChevronDown size={24} color={stylesheet.scrollToBottomIcon.color} />
+        </Pressable>
+      </Animated.View>
+    </View>
+  );
+}
+
 const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamViewProps>(
   function AgentStreamView(
     {
@@ -365,7 +373,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         }),
       [isMobile],
     );
-    const [isNearBottom, setIsNearBottom] = useState(true);
+    const nearBottom = useNearBottom(agentId);
     const [expandedInlineToolCallIds, setExpandedInlineToolCallIds] = useState<Set<string>>(
       new Set(),
     );
@@ -422,18 +430,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           loadOlder: historyPagination.onLoadOlder,
         }
       : agentHistoryPagination;
-    // Keep entry/exit animations off on Android due to RN dispatchDraw crashes
-    // tracked in react-native-reanimated#8422.
-    const shouldDisableEntryExitAnimations = Platform.OS === "android";
-    const scrollIndicatorFadeIn = shouldDisableEntryExitAnimations
-      ? undefined
-      : FadeIn.duration(200);
-    const scrollIndicatorFadeOut = shouldDisableEntryExitAnimations
-      ? undefined
-      : FadeOut.duration(200);
-
     useEffect(() => {
-      setIsNearBottom(true);
       setExpandedInlineToolCallIds(new Set());
       setExpandedTurnHostIds(new Set());
     }, [agentId]);
@@ -675,9 +672,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [streamRenderStrategy],
     );
 
+    // The summary line holds its row around this; chat find opens a turn without a hold.
     const setTurnExpanded = useCallback((hostId: string, expanded: boolean) => {
-      // A turn opens below its summary line; keep that line under the reader's pointer.
-      viewportRef.current?.holdReadingPosition();
       setExpandedTurnHostIds((previous) => {
         if (previous.has(hostId) === expanded) return previous;
         const next = new Set(previous);
@@ -928,8 +924,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     );
 
     const renderStreamItemContent = useCallback(
-      (layoutItem: StreamLayoutItem) => {
-        const item = layoutItem.item;
+      (item: StreamItem, layoutItem: StreamLayoutItem) => {
         switch (item.kind) {
           case "user_message":
             return renderUserMessageItem(layoutItem, item);
@@ -990,9 +985,9 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
 
     const bottomTurnFooterHost = streamLayout.auxiliaryTurnFooter;
 
-    const renderStreamItem = useCallback(
-      (layoutItem: StreamLayoutItem) => {
-        const content = renderStreamItemContent(layoutItem);
+    const renderStreamItem = useCallback<RenderStreamItem>(
+      (item, layoutItem) => {
+        const content = renderStreamItemContent(item, layoutItem);
         return renderStreamItemWithTurnFooter({
           content,
           layoutItem,
@@ -1061,13 +1056,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     }, [baseRenderModel, pendingPermissionsNode, turnFooterNode]);
 
     const emptyStateStyle = useMemo(() => [stylesheet.emptyState, stylesheet.contentWrapper], []);
-    const scrollToBottomContainerStyle = useMemo(
-      () => [
-        stylesheet.scrollToBottomContainer,
-        { bottom: resolveBottomOverlayControlOffset(bottomOverlayControlClearance) },
-      ],
-      [bottomOverlayControlClearance],
-    );
+    const scrollToBottomOffset = resolveBottomOverlayControlOffset(bottomOverlayControlClearance);
     const listEmptyComponent = useMemo(
       () =>
         renderListEmptyComponent({
@@ -1110,6 +1099,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           item,
           layoutItemById: layoutHistoryItemById,
           renderStreamItem,
+          viewportRef,
         }),
       [layoutHistoryItemById, renderStreamItem],
     );
@@ -1131,6 +1121,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           item,
           layoutItemById: layoutLiveHeadItemById,
           renderStreamItem,
+          viewportRef,
         }),
     );
     const renderLiveAuxiliary = useCallback<StreamSegmentRenderers["renderLiveAuxiliary"]>(() => {
@@ -1165,10 +1156,13 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     const streamScrollEnabled =
       !streamRenderStrategy.shouldDisableParentScrollOnInlineDetailsExpansion() ||
       expandedInlineToolCallIds.size === 0;
-    const { nestedItemIds } = presentation.turns;
+    const { nestedItemIds, updatedHostIds: updatedTurnHostIds } = presentation.turns;
     const historyRowRevision = useMemo(
       () => ({
-        contentById: presentation.historyGroupUpdatesByHostId,
+        contentById: {
+          has: (id: string) =>
+            presentation.historyGroupUpdatesByHostId.has(id) || updatedTurnHostIds.has(id),
+        },
         displayStateById: {
           // An opened lone call also marks its future group open; that row stays unrevised
           // until a group actually forms there.
@@ -1186,6 +1180,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         isMobile,
         nestedItemIds,
         presentation.historyGroupUpdatesByHostId,
+        updatedTurnHostIds,
       ],
     );
 
@@ -1219,7 +1214,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
                   viewportRef,
                   routeBottomAnchorRequest,
                   isAuthoritativeHistoryReady,
-                  onNearBottomChange: setIsNearBottom,
+                  onNearBottomChange: nearBottom.set,
                   onReadingPositionChange: handleReadingPositionChange,
                   onNearHistoryStart: loadOlder,
                   isLoadingOlderHistory: isLoadingOlder,
@@ -1238,21 +1233,12 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
               activePrompt={chatOutline.activePrompt}
               onJumpToPrompt={chatOutline.jumpToPrompt}
             />
-            {(!isNearBottom || isTimelineDetached) && (
-              <View style={scrollToBottomContainerStyle} pointerEvents="box-none">
-                <Animated.View entering={scrollIndicatorFadeIn} exiting={scrollIndicatorFadeOut}>
-                  <Pressable
-                    style={stylesheet.scrollToBottomButton}
-                    onPress={scrollToBottom}
-                    accessibilityRole="button"
-                    accessibilityLabel={t("agentStream.scrollToBottom")}
-                    testID="scroll-to-bottom-button"
-                  >
-                    <ChevronDown size={24} color={stylesheet.scrollToBottomIcon.color} />
-                  </Pressable>
-                </Animated.View>
-              </View>
-            )}
+            <ScrollToBottomButton
+              nearBottom={nearBottom}
+              isTimelineDetached={isTimelineDetached}
+              bottomOffset={scrollToBottomOffset}
+              onPress={scrollToBottom}
+            />
           </AssistantSelectionCopySurface>
         </ToolCallSheetProvider>
       </ChatFind>
@@ -1304,8 +1290,7 @@ function collectAgentSetupDiffs(left: AgentScreenAgent, right: AgentScreenAgent)
   if (left.runtimeInfo?.thinkingOptionId !== right.runtimeInfo?.thinkingOptionId) {
     reasons.push("agent.runtimeInfo.thinkingOptionId");
   }
-  if (left.options !== right.options) reasons.push("agent.options");
-  if (left.controls !== right.controls) reasons.push("agent.controls");
+  if (left.features !== right.features) reasons.push("agent.features");
   return reasons;
 }
 
@@ -1790,10 +1775,6 @@ const stylesheet = StyleSheet.create((theme) => ({
     color: theme.colors.foregroundMuted,
     fontSize: theme.fontSize.base,
   },
-  invertedWrapper: {
-    transform: [{ scaleY: -1 }],
-    width: "100%",
-  },
   emptyStateText: {
     color: theme.colors.foregroundMuted,
     fontSize: theme.fontSize.base,

packages/app/src/app/_layout.tsx

@@ -1,4 +1,12 @@
 import { useHardwareKeyboardPresent } from "@/keyboard";
+import {
+  WindowLayoutProvider,
+  WindowLayoutActionsHost,
+  WindowLayoutSurface,
+  WindowLayoutDivisionGap,
+  useWindowLayout,
+  resolveDesktopDivisionLayout,
+} from "@/window-layout";
 import { AddHostProvider, AddHostFlowHost } from "@/hosts/add-host";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import { useActiveWorkspaceSelection } from "@/stores/navigation-active-workspace-store";
@@ -59,6 +67,7 @@ import {
   resolveDesktopAppChromeLayout,
   resolveDesktopAppContentMinimum,
   resolveDesktopSidebarVisibility,
+  resolveSidebarActivity,
 } from "@/components/desktop-sidebar-layout";
 import { isNative, isWeb } from "@/constants/platform";
 import { HorizontalScrollProvider } from "@/contexts/horizontal-scroll-context";
@@ -355,9 +364,16 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
   const isFocusModeEnabled = usePanelStore((state) => state.desktop.focusModeEnabled);
   const isDesktopAgentListOpen = usePanelStore((state) => state.desktop.agentListOpen);
   const sidebarWidth = usePanelStore((state) => state.sidebarWidth);
-  const { width: windowWidth } = useWindowDimensions();
+  const { width: windowWidth, height: windowHeight } = useWindowDimensions();
   const insets = useSafeAreaInsets();
   const viewportWidth = windowWidth - insets.left - insets.right;
+  const divisionLayout = resolveDesktopDivisionLayout({
+    geometry: useWindowLayout(),
+    windowWidth,
+    windowHeight,
+    leftInset: insets.left,
+    rightInset: insets.right,
+  });
 
   const cycleTheme = useCallback(() => {
     void updateSettings({ theme: getNextThemePreference(settings.theme) });
@@ -418,6 +434,7 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
     isCompactLayout,
     isMounted: desktopSidebarMounted,
     isOpen: isDesktopAgentListOpen,
+    divisionLayout,
     canShare: canDesktopAppSidebarShare({
       contentMinimumWidth: appContentMinimumWidth,
       requestedSidebarWidth: sidebarWidth,
@@ -441,18 +458,19 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
   if (isWeb) {
     themedSidebarChrome = <AppearanceStyleBoundary>{sidebarChrome}</AppearanceStyleBoundary>;
   }
-  const workspaceChromeStyle = useMemo(
-    () => [rowStyle, !isCompactLayout && { paddingLeft: insets.left, paddingRight: insets.right }],
-    [insets.left, insets.right, isCompactLayout],
-  );
   const workspaceChrome = (
-    <View style={workspaceChromeStyle}>
+    <WindowLayoutSurface compact={isCompactLayout} style={rowStyle}>
       <WorkspaceLayoutModePublisher />
       {!isCompactLayout ? (
         <WindowChromeRegion corners={appChromeLayout.sidebarCorners}>
           {themedSidebarChrome}
         </WindowChromeRegion>
       ) : null}
+      <WindowLayoutDivisionGap
+        layout={divisionLayout}
+        sidebarVisible={desktopSidebarVisible}
+        compact={isCompactLayout}
+      />
       <WorkspaceExplorerOpenGesture enabled={chromeEnabled && isCompactLayout}>
         <WindowChromeRegion
           corners={isCompactLayout && chromeEnabled ? "both" : appChromeLayout.contentCorners}
@@ -460,7 +478,7 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
           <View style={flexStyle}>{children}</View>
         </WindowChromeRegion>
       </WorkspaceExplorerOpenGesture>
-    </View>
+    </WindowLayoutSurface>
   );
 
   // Native panel gesture hosts outlive appearance keys, like native navigators.
@@ -548,8 +566,7 @@ function SidebarChrome({
 }) {
   const isCompactLayout = useIsCompactFormFactor();
   const isMobileActive = useIsMobilePanelActive("agent-list");
-  const isDesktopOpen = usePanelStore((state) => state.desktop.agentListOpen);
-  const active = visible && (isCompactLayout ? isMobileActive : isDesktopOpen);
+  const active = resolveSidebarActivity(visible, isCompactLayout, isMobileActive);
   const hardwareKeyboardPresent = useHardwareKeyboardPresent();
   return (
     <SidebarModelProvider
@@ -875,20 +892,31 @@ function RuntimeProviders({ children }: { children: ReactNode }) {
 // auth, settings, ...) must wrap PortalProvider, not be wrapped by it.
 // BottomSheetModalProvider is the exception: Gorhom modals consume portal
 // context and need one shared provider for sibling sheets to stack.
+function RootOverlayProviders({ children }: { children: ReactNode }) {
+  return (
+    <ToastProvider>
+      <PortalProvider>
+        <BottomSheetModalProvider>
+          {children}
+          <WindowLayoutActionsHost />
+        </BottomSheetModalProvider>
+      </PortalProvider>
+    </ToastProvider>
+  );
+}
+
 function RootProviders({ children }: { children: ReactNode }) {
   return (
     <KeyboardActionDispatcherProvider>
-      <WindowChromeProvider>
-        <KeyboardProvider>
-          <KeyboardShiftProvider>
-            <ToastProvider>
-              <PortalProvider>
-                <BottomSheetModalProvider>{children}</BottomSheetModalProvider>
-              </PortalProvider>
-            </ToastProvider>
-          </KeyboardShiftProvider>
-        </KeyboardProvider>
-      </WindowChromeProvider>
+      <WindowLayoutProvider>
+        <WindowChromeProvider>
+          <KeyboardProvider>
+            <KeyboardShiftProvider>
+              <RootOverlayProviders>{children}</RootOverlayProviders>
+            </KeyboardShiftProvider>
+          </KeyboardProvider>
+        </WindowChromeProvider>
+      </WindowLayoutProvider>
     </KeyboardActionDispatcherProvider>
   );
 }

packages/app/src/client-slash-commands/index.test.ts

@@ -40,7 +40,16 @@ function createAgent(overrides: Partial<Agent> = {}): Agent {
     cwd: "/repo",
     model: "agent-model",
     thinkingOptionId: "think-hard",
-    options: { "web-search": true, effort: "high" },
+    features: [
+      { type: "toggle", id: "web-search", label: "Web search", value: true },
+      {
+        type: "select",
+        id: "effort",
+        label: "Effort",
+        value: "high",
+        options: [{ id: "high", label: "High" }],
+      },
+    ],
     parentAgentId: null,
     labels: {},
     ...overrides,
@@ -105,7 +114,7 @@ describe("buildDraftAgentSetup", () => {
       modeId: "mode-current",
       model: "agent-model",
       thinkingOptionId: "think-hard",
-      providerOptions: {
+      featureValues: {
         "web-search": true,
         effort: "high",
       },

packages/app/src/client-slash-commands/index.ts

@@ -65,12 +65,17 @@ export function resolveClientSlashCommand(input: {
 }
 
 export function buildDraftAgentSetup(agent: Agent): WorkspaceDraftTabSetup {
+  const featureValues: Record<string, unknown> = {};
+  for (const feature of agent.features ?? []) {
+    featureValues[feature.id] = feature.value;
+  }
+
   return {
     provider: agent.provider,
     cwd: agent.cwd,
     modeId: agent.currentModeId ?? agent.runtimeInfo?.modeId ?? null,
     model: agent.model ?? agent.runtimeInfo?.model ?? null,
     thinkingOptionId: agent.thinkingOptionId ?? agent.runtimeInfo?.thinkingOptionId ?? null,
-    providerOptions: { ...agent.options },
+    featureValues,
   };
 }

packages/app/src/command-center/agent-control-contributions.test.ts

@@ -1,9 +1,5 @@
 import { describe, expect, it } from "vitest";
-import type {
-  AgentMode,
-  AgentOptionControl,
-  AgentSelectOption,
-} from "@getpaseo/protocol/agent-types";
+import type { AgentFeature, AgentMode, AgentSelectOption } from "@getpaseo/protocol/agent-types";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import type { CommandCenterContribution } from "./contributions";
 import {
@@ -35,7 +31,7 @@ const ICONS: AgentControlContributionSource["icons"] = {
   thinking: TestIcon,
   planMode: TestIcon,
   mode: () => TestIcon,
-  control: () => TestIcon,
+  feature: () => TestIcon,
 };
 
 function provider(input: {
@@ -69,8 +65,8 @@ function provider(input: {
   };
 }
 
-function toggleControl(key: string, icon?: string): AgentOptionControl {
-  return { type: "toggle", key, label: key, icon };
+function toggleFeature(id: string, value = false, icon?: string): AgentFeature {
+  return { type: "toggle", id, label: id, value, icon };
 }
 
 function makeSource(
@@ -79,7 +75,7 @@ function makeSource(
     models?: Partial<AgentControlContributionSource["models"]>;
     thinking?: Partial<AgentControlContributionSource["thinking"]>;
     modes?: Partial<NonNullable<AgentControlContributionSource["modes"]>>;
-    optionControls?: Partial<AgentControlContributionSource["optionControls"]>;
+    features?: Partial<AgentControlContributionSource["features"]>;
   } = {},
 ): AgentControlContributionSource {
   return {
@@ -108,11 +104,10 @@ function makeSource(
       select: () => undefined,
       ...overrides.modes,
     },
-    optionControls: {
-      controls: [],
-      options: {},
-      onSetOption: () => undefined,
-      ...overrides.optionControls,
+    features: {
+      list: [],
+      set: () => undefined,
+      ...overrides.features,
     },
   };
 }
@@ -138,7 +133,7 @@ describe("Command Center agent-control contributions", () => {
     const contributions = buildAgentControlContributions({
       ...makeSource({
         models: { providers: [provider({ id: "claude", label: "Claude" })] },
-        optionControls: { controls: [toggleControl("plan_mode")], options: { plan_mode: true } },
+        features: { list: [toggleFeature("plan_mode", true)] },
       }),
       modes: undefined,
     });
@@ -328,10 +323,9 @@ describe("Command Center agent-control contributions", () => {
           selectedId: "default",
           defaultModeId: "default",
         },
-        optionControls: {
-          controls: [toggleControl("plan_mode", "list-todo")],
-          options: { plan_mode: true },
-          onSetOption: (id, value) => {
+        features: {
+          list: [toggleFeature("plan_mode", true, "list-todo")],
+          set: (id, value) => {
             calls.push([id, value]);
           },
         },
@@ -347,10 +341,9 @@ describe("Command Center agent-control contributions", () => {
     const calls: [string, unknown][] = [];
     const contributions = buildAgentControlContributions(
       makeSource({
-        optionControls: {
-          controls: [toggleControl("fast_mode", "zap"), toggleControl("auto_accept")],
-          options: { fast_mode: false, auto_accept: true },
-          onSetOption: (id, value) => {
+        features: {
+          list: [toggleFeature("fast_mode", false, "zap"), toggleFeature("auto_accept", true)],
+          set: (id, value) => {
             calls.push([id, value]);
           },
         },
@@ -383,7 +376,7 @@ describe("Command Center agent-control contributions", () => {
           selectedId: "default",
           defaultModeId: "default",
         },
-        optionControls: { controls: [toggleControl("fast_mode")], options: {} },
+        features: { list: [toggleFeature("fast_mode")] },
       }),
     );
     const ranks = new Map<string, number>();

packages/app/src/command-center/agent-control-contributions.ts

@@ -1,10 +1,9 @@
 import type {
+  AgentFeature,
   AgentMode,
-  AgentOptionControl,
   AgentProvider,
   AgentSelectOption,
 } from "@getpaseo/protocol/agent-types";
-import { readToggleOption, type ComposerOptionControls } from "@/agent-controls/option-controls";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import { formatAgentModeLabel, formatThinkingOptionLabel } from "@/agent-controls/labels";
 import {
@@ -62,7 +61,7 @@ export interface AgentControlContributionIcons {
   thinking: CommandCenterIcon;
   planMode: CommandCenterIcon;
   mode(modeId: string): CommandCenterIcon;
-  control(control: AgentOptionControl): CommandCenterIcon;
+  feature(feature: AgentFeature): CommandCenterIcon;
 }
 
 interface CommandCenterChoice {
@@ -106,7 +105,10 @@ export interface AgentControlContributionSource {
     defaultModeId: string | null;
     select(modeId: string): void | Promise<void>;
   };
-  optionControls: ComposerOptionControls;
+  features: {
+    list: readonly AgentFeature[];
+    set(featureId: string, value: unknown): void | Promise<void>;
+  };
 }
 
 function buildContributions(
@@ -240,19 +242,18 @@ function toggleChoices(input: {
 }
 
 function buildPlanModeGroup(source: AgentControlContributionSource): CommandCenterChoiceGroup {
-  const { controls, options, onSetOption } = source.optionControls;
-  const planControl = controls.find(
-    (control) => control.key === PLAN_MODE_FEATURE_ID && control.type === "toggle",
+  const planFeature = source.features.list.find(
+    (feature) => feature.id === PLAN_MODE_FEATURE_ID && feature.type === "toggle",
   );
   let choices: CommandCenterChoice[] = [];
-  if (planControl?.type === "toggle") {
+  if (planFeature?.type === "toggle") {
     choices = toggleChoices({
       source,
       key: "plan",
-      icon: source.icons.control(planControl),
-      isOn: readToggleOption(planControl, options),
-      turnOn: () => onSetOption(PLAN_MODE_FEATURE_ID, true),
-      turnOff: () => onSetOption(PLAN_MODE_FEATURE_ID, false),
+      icon: source.icons.feature(planFeature),
+      isOn: planFeature.value,
+      turnOn: () => source.features.set(PLAN_MODE_FEATURE_ID, true),
+      turnOff: () => source.features.set(PLAN_MODE_FEATURE_ID, false),
     });
   } else if (source.modes) {
     const modes = source.modes;
@@ -279,19 +280,18 @@ function buildPlanModeGroup(source: AgentControlContributionSource): CommandCent
 }
 
 function buildFastModeGroup(source: AgentControlContributionSource): CommandCenterChoiceGroup {
-  const { controls, options, onSetOption } = source.optionControls;
-  const fastControl = controls.find(
-    (control) => control.key === FAST_MODE_FEATURE_ID && control.type === "toggle",
+  const fastFeature = source.features.list.find(
+    (feature) => feature.id === FAST_MODE_FEATURE_ID && feature.type === "toggle",
   );
   const choices =
-    fastControl?.type === "toggle"
+    fastFeature?.type === "toggle"
       ? toggleChoices({
           source,
           key: "fast",
-          icon: source.icons.control(fastControl),
-          isOn: readToggleOption(fastControl, options),
-          turnOn: () => onSetOption(FAST_MODE_FEATURE_ID, true),
-          turnOff: () => onSetOption(FAST_MODE_FEATURE_ID, false),
+          icon: source.icons.feature(fastFeature),
+          isOn: fastFeature.value,
+          turnOn: () => source.features.set(FAST_MODE_FEATURE_ID, true),
+          turnOff: () => source.features.set(FAST_MODE_FEATURE_ID, false),
         })
       : [];
   return {

packages/app/src/command-center/agent-control-registration.tsx

@@ -1,6 +1,11 @@
 import { useMemo } from "react";
 import { useTranslation } from "react-i18next";
-import type { AgentMode, AgentProvider, AgentSelectOption } from "@getpaseo/protocol/agent-types";
+import type {
+  AgentFeature,
+  AgentMode,
+  AgentProvider,
+  AgentSelectOption,
+} from "@getpaseo/protocol/agent-types";
 import type { AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 import {
   getAgentFeatureIcon,
@@ -9,7 +14,6 @@ import {
   ThinkingIcon,
 } from "@/agent-controls/icons";
 import { useProviderIcons } from "@/components/provider-icons";
-import type { ComposerOptionControls } from "@/agent-controls/option-controls";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import {
   buildAgentControlContributions,
@@ -40,15 +44,15 @@ export interface AgentControlCommandCenterSource {
     selectedId: string | null | undefined;
     select(modeId: string): void | Promise<void>;
   };
-  /** Absent when the surface cannot change options (the agent has no client). */
-  optionControls: ComposerOptionControls | null;
+  features: {
+    list: readonly AgentFeature[] | undefined;
+    set?: (featureId: string, value: unknown) => void | Promise<void>;
+  };
 }
 
-const NO_OPTION_CONTROLS: ComposerOptionControls = {
-  controls: [],
-  options: {},
-  onSetOption: () => undefined,
-};
+function ignoreAgentFeatureChange(): void {
+  return;
+}
 
 function resolveDefaultModeId(
   provider: string | null | undefined,
@@ -83,7 +87,7 @@ export function useAgentControlCommandCenterActions(input: {
 }): void {
   const { t } = useTranslation();
   const { controls } = input;
-  const { optionControls, models, modes, thinking } = controls;
+  const { features, models, modes, thinking } = controls;
   const getProviderIcon = useProviderIcons(controls.serverId);
   const actions = useMemo(
     () =>
@@ -100,7 +104,7 @@ export function useAgentControlCommandCenterActions(input: {
             getCommandCenterIcon(
               getAgentModeIcon(controls.provider ?? "", modeId, controls.providerDefinitions),
             ),
-          control: (control) => getCommandCenterIcon(getAgentFeatureIcon(control.icon)),
+          feature: (feature) => getCommandCenterIcon(getAgentFeatureIcon(feature.icon)),
         },
         models: {
           providers: models.providers,
@@ -119,7 +123,10 @@ export function useAgentControlCommandCenterActions(input: {
           modes?.select,
           resolveDefaultModeId(controls.provider, controls.providerDefinitions),
         ),
-        optionControls: optionControls ?? NO_OPTION_CONTROLS,
+        features: {
+          list: features.set ? (features.list ?? []) : [],
+          set: features.set ?? ignoreAgentFeatureChange,
+        },
       }),
     [
       getProviderIcon,
@@ -127,7 +134,8 @@ export function useAgentControlCommandCenterActions(input: {
       controls.provider,
       controls.providerDefinitions,
       controls.serverId,
-      optionControls,
+      features.list,
+      features.set,
       models.providers,
       models.select,
       models.selectedModelId,

packages/app/src/components/combined-model-selector.tsx

@@ -13,6 +13,7 @@ import { useIsCompactFormFactor } from "@/constants/layout";
 import { isNative, isWeb } from "@/constants/platform";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import { ICON_SIZE, type Theme } from "@/styles/theme";
+import { TOOLBAR_CONTROL_HEIGHT } from "@/components/ui/control-geometry";
 
 const EMPTY_COMBOBOX_OPTIONS: ComboboxOption[] = [];
 const ThemedLoadingSpinner = withUnistyles(LoadingSpinner);
@@ -292,7 +293,7 @@ const styles = StyleSheet.create((theme) => ({
     paddingHorizontal: 0,
   },
   trigger: {
-    height: 28,
+    height: TOOLBAR_CONTROL_HEIGHT,
     minWidth: 0,
     flexShrink: 1,
     flexDirection: "row",

packages/app/src/components/context-window-meter.tsx

@@ -9,6 +9,7 @@ import { useIsCompactFormFactor } from "@/constants/layout";
 import { isNative } from "@/constants/platform";
 import { useHostReportsUsage } from "@/usage";
 import type { Theme } from "@/styles/theme";
+import { TOOLBAR_CONTROL_HEIGHT } from "@/components/ui/control-geometry";
 import { ContextWindowDetails } from "./context-window-details";
 import { ContextWindowSheet } from "./context-window-sheet";
 import { formatContextPercentage } from "./context-window-meter.utils";
@@ -306,14 +307,14 @@ export function ContextWindowMeter({
 
 const styles = StyleSheet.create((theme) => ({
   container: {
-    width: 28,
-    height: 28,
+    width: TOOLBAR_CONTROL_HEIGHT,
+    height: TOOLBAR_CONTROL_HEIGHT,
     borderRadius: theme.borderRadius.full,
     alignItems: "center",
     justifyContent: "center",
   },
   containerWithLabel: {
-    height: 28,
+    height: TOOLBAR_CONTROL_HEIGHT,
     flexDirection: "row",
     alignItems: "center",
     justifyContent: "center",