fix(plugins): a New workspace item's commands stop working once its project or host is left

Every item received the same command functions, which act on the current screen state. A lookup
that finished after the user switched projects could still call setBranch or setMetadata and
overwrite the new project's choices; the reset on a switch only clears what was already written.

The setup model now hands out commands per target with commandsFor({ serverId, projectId }).
They reject with a "moved to another project or host" error when the screen is on another target,
like the lock rejects, so the promise only resolves when the change took effect.

CHANGELOG.md

@@ -1,34 +1,5 @@
 # Changelog
 
-## 0.15.3 - 2026-11-06
-
-### Fixed
-
-- Fixed conversation text becoming blurred when opening or dismissing the keyboard on iOS 26+ ([#8918](https://github.com/getpaseo/paseo/pull/8918) by [@dgreensp](https://github.com/dgreensp))
-
-## 0.15.2 - 2026-11-05
-
-### Added
-
-- Added a first-run setup on Paseo Desktop and web that walks new users through theme, providers, projects, agent orchestration and the mobile app, with Settings → General → Show setup again to reopen it ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- Added project suggestions from the folders where you ran Claude Code, Codex, OpenCode or Pi, shown in the setup Projects step ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-
-### Improved
-
-- Changed the theme picker to a grid of tiles with a preview of each theme ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- Replaced the "Loading…" text in Providers settings with skeleton rows ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- Changed controls to two sizes: default controls are 32px tall on desktop and 44px on phones, and compact controls are 28px ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- Changed first launch to go from the loading screen straight into setup instead of showing the empty home first ([#8824](https://github.com/getpaseo/paseo/pull/8824))
-- Changed dialogs on desktop and web to fade in over about 160ms ([#8824](https://github.com/getpaseo/paseo/pull/8824))
-- Changed modal and sheet backgrounds to match the screen background ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- Changed documentation links in Settings sections to a `Label ↗` link beside the section title ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-
-## 0.15.1 - 2026-11-05
-
-### Fixed
-
-- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run `Get-CimInstance` ([#8810](https://github.com/getpaseo/paseo/pull/8810))
-
 ## 0.15.0 - 2026-11-03
 
 Daemon restarts now keep terminal programs running. Interrupted agents can resume in their existing conversations when you turn on agent recovery.

CHANGELOG.zh-CN.md

@@ -1,34 +1,5 @@
 # Changelog
 
-## 0.15.3 - 2026-11-06
-
-### 修复
-
-- 修复了 iOS 26 及更高版本中打开或收起键盘时聊天内容变模糊的问题 ([#8918](https://github.com/getpaseo/paseo/pull/8918)，贡献者：[@dgreensp](https://github.com/dgreensp))
-
-## 0.15.2 - 2026-11-05
-
-### 新增
-
-- 在 Paseo 桌面版和网页版新增首次运行引导，依次带新用户设置主题、提供商、项目、Agent 编排和移动端应用，并可通过“设置 → 通用 → Show setup again”重新打开 ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- 在引导的“项目”步骤中，根据你运行过 Claude Code、Codex、OpenCode 或 Pi 的文件夹推荐项目 ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-
-### 改进
-
-- 将主题选择器改为带各主题预览的图块网格 ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- 将“提供商”设置中的“Loading…”文字替换为骨架占位行 ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- 将控件统一为两种尺寸：默认控件在桌面端高 32px、在手机上高 44px，紧凑控件高 28px ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- 将首次启动改为从加载界面直接进入引导，不再先显示空白的主页 ([#8824](https://github.com/getpaseo/paseo/pull/8824))
-- 将桌面端和网页版的对话框改为约 160 毫秒的淡入 ([#8824](https://github.com/getpaseo/paseo/pull/8824))
-- 将弹窗和面板的背景改为与屏幕背景一致 ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-- 将“设置”各分区的文档链接改为分区标题旁的 `Label ↗` 链接 ([#8363](https://github.com/getpaseo/paseo/pull/8363))
-
-## 0.15.1 - 2026-11-05
-
-### 修复
-
-- 修复终端工作进程无法读取自身进程标识时 daemon 无法启动的问题；此前在 Windows PowerShell 5.1 无法运行 `Get-CimInstance` 的 Windows 机器上，Paseo 桌面版因此没有可用的 daemon ([#8810](https://github.com/getpaseo/paseo/pull/8810))
-
 ## 0.15.0 - 2026-11-03
 
 daemon 重启后，终端中的程序继续运行。开启 Agent 恢复后，被中断的 Agent 会在原有会话中恢复工作。

CLAUDE.md

@@ -55,7 +55,6 @@ 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-lifecycle.md

@@ -136,12 +136,6 @@ the marker. Closing a tab sets that client's label to `false`. Any `true` client
 open. Detach clears the parent and every open-tab label. The surviving child therefore becomes a
 normal root agent immediately, and closing its still-open tab archives it.
 
-Agent-scoped workspace creation records the caller's workspace as `parentWorkspaceId`.
-This is informational ancestry for future workspace grouping. It does not change placement,
-visibility, status, or archive behavior. Archiving a parent workspace preserves its children's
-records and parentage. Unscoped creation and existing workspaces have no parent; ancestry is
-never inferred from directories, projects, or Git branches.
-
 Runtime ownership is resolved from explicit workspace ID and caller context, never from `cwd`. Workspace creation is a separate operation with `local | worktree` isolation; agent creation reuses that workspace unless a new workspace is explicitly requested.
 
 Setup belongs to the workspace, including combined workspace-plus-agent creation and the supported agent `worktree` request. Run setup through the workspace workflow before launching configured terminals or scripts. Setup output is read in the Setup panel from per-command snapshots; never produce setup chat timeline rows or concatenate command logs. Legacy agent `git`/`worktreeName` inputs and hidden MCP worktree placement are rejected with workspace-creation guidance. Existing wire schemas retain an empty combined-log string for parsing compatibility.
@@ -259,27 +253,6 @@ archived workspace. History navigation must not infer workspace lifecycle from `
 or mutate either lifecycle. The workspace route asks the daemon for authoritative recovery state;
 only the route's explicit Unarchive or Restore action changes the archived workspace.
 
-Workspace archive is undoable from the archived toast, or with Cmd/Ctrl+Z, while the toast is up.
-The daemon runs one archive lane per workspace, shared by every connection
-(`packages/server/src/server/workspace-archive-operations.ts`):
-
-| A request arrives while  | Result                                                    |
-| ------------------------ | --------------------------------------------------------- |
-| an archive runs: archive | joins the running archive                                 |
-| an archive runs: undo    | aborts the archive, waits for it to settle, then restores |
-| an undo runs: archive    | waits for the undo, then archives                         |
-| an undo runs: undo       | joins the running undo                                    |
-
-A request takes its place in the lane before its first `await`. Arrival order decides, so an undo
-sent right behind its archive still cancels it.
-
-An aborted archive stops at its next checkpoint and reports `canceled`; the undo unarchives only
-the agents that archive itself archived. Deleting the worktree directory is the point of no
-return: an undo after it recreates the worktree through workspace recovery. The client shows or
-hides the row by the latest local intent, so a late remove or upsert from a superseded request
-does not flip it back. Tabs and layout are purged only once the undo window closes with the
-archive committed.
-
 History navigation opens the selected agent without changing either archive state. Workspace
 **Restore** recovers only the workspace; the selected archived agent stays open with its callout.
 The agent's **Unarchive** runs the provider's native unarchive hook before interactive resume and
@@ -332,27 +305,17 @@ Workspace status is an aggregate activity signal computed **per `workspaceId`**.
 
 Running provider-native subagents contribute `running` to the workspace owned by their parent agent. Their completed, failed, and canceled states stay in the parent's subagents track.
 
-A finished or failed workspace can be marked unread after it has been reviewed. The daemon restores
-attention on its newest eligible workspace-root agent, `error` for an agent whose lifecycle is
-`error` and `finished` otherwise, without sending a new notification. Opening a workspace restores
-its selected tab; attention on another agent remains unread until that agent is focused or the
-workspace is explicitly marked read.
+A finished workspace can be marked unread after it has been reviewed. The daemon restores
+`finished` attention on its newest eligible workspace-root agent without sending a new completion
+notification. Opening the workspace clears that attention through the normal focus flow.
 
-Attention is set by the agent finishing or failing and acknowledged by deliberate focus or
-interaction with its chat, including repeat clicks in an already focused pane. A completion
-arriving while focused stays unread until the next interaction; leaving does not acknowledge it. Loading an agent's runtime is
+Attention is set by the agent finishing or failing and cleared by the client's
+`workspace.clear_attention`, which fires when the user reads the chat. Loading an agent's runtime is
 neither, so resuming carries the stored attention and the stored last-activity time through
 untouched. Forging either makes a background resume look like the user read a workspace and like the
 agent worked in it just now, which rewrites the sidebar timestamp permanently — persisted
 `updatedAt` is what workspace `statusEnteredAt` is re-derived from on the next daemon start.
 
-The `failed` bucket follows unread `error` attention, not lifecycle status. An agent stays `error`
-until its next turn starts, so reading the chat dismisses the red dot the same way it dismisses the
-green one. For the same reason every new failure raises `error` attention, including a failed reload
-that leaves the lifecycle at `error`, and replaces unread `finished` attention; otherwise the failed
-agent would show the green dot or none. Subagents track marks are the exception: they follow the
-child's lifecycle, because the track is where a failed child stays visible.
-
 ## The subagents track
 
 The track is a pill at the foot of an agent's pane (`packages/app/src/subagents/track.tsx`): a count you can read at a glance, and a panel behind it — a popover on wide screens, a sheet on compact ones — holding the rows. It floats over the transcript rather than sitting in a band above the composer, so the timeline scrolls underneath it; `packages/app/src/panels/agent-tracks.tsx` owns that placement, and the pill frame is shared with the task list in `packages/app/src/composer/tracks.tsx`.

docs/agent-stream-disclosure.md

@@ -1,197 +0,0 @@
-# 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, a long user message's show more, a plan 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, triggerEdge)` (`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.
-A toggle that calls `setState` directly skips the hold: on Android the expanded content paints
-over the next row for a frame before the list learns the new size.
-
-`triggerEdge` names the edge of the row the trigger sits on, and the strategy keeps that edge in
-place. Header triggers sit on the top edge, the default. A long user message's show more sits under
-the text it opens, so `MessagePreview` passes `{ triggerEdge: "bottom" }`: the text grows and shrinks
-above the trigger, and the rows below stay put.
-
-Following output:
-
-- A hold detaches the bottom anchor controller (`holdForDisclosure`), except a bottom-edge hold on
-  native while following: there the end pin already keeps the row's bottom in place.
-- 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's trigger edge in the reading anchor and runs `apply`; the next reading
-reconcile restores that edge after layout, before paint (`strategy-web.tsx`). The pin records the
-scroll offset it was taken at, because the browser clamps `scrollTop` when a collapse shrinks the
-content past the offset, before the reconcile reads it. Restoring from the clamped offset would
-apply the shrink twice.
-
-## Native
-
-On compact layouts, tool calls and tool-call groups open a sheet instead of expanding, so they do
-not hold. Summary lines, todo cards, plan cards and show more 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`), also for a bottom-edge hold.                                                  |
-| Disclosure hold        | LegendList's `maintainVisibleContentPosition` on the hold's anchor row, or the end pin for the last row's bottom. |
-| 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, triggerEdge)` runs in the toggle's event:
-
-1. Pick the anchor and detach the controller (`holdForDisclosure`). LegendList restores row
-   tops only, so a top-edge hold anchors the toggled row and a bottom-edge hold anchors the row
-   below it, whose top is the toggled row's bottom (`disclosureAnchor`). The pin goes away
-   and LegendList's `maintainVisibleContentPosition` takes over, restoring only the anchor row
-   (`shouldRestorePosition`). A bottom-edge hold while following skips this step: the end pin
-   keeps the content end, and the row's bottom with it, in the frame the new height mounts.
-
-   A bottom-edge hold on the last row, such as a prompt the agent has not answered yet, has no
-   row below it: its bottom is the content end (the running indicator is the list footer, not a
-   row). The hold mounts the end pin while detached, and `apply` runs a frame later. The pin
-   anchors only once it is mounted, and a pin that mounts in the same commit as the new height
-   anchors nothing. The pin's commit mounts before that frame's JS callbacks run, so `apply`'s
-   commit mounts with the pin already in place. The pin keeps the distance from the end, and each
-   content size change clamps it to the scroll room left, so the hold re-sticks if the list was
-   at its end when tapped or a collapse used up the room. The release tracks that distance
-   instead of reading the offset: the new content size reaches JS before the pin's scroll does.
-   A reply landing below the row ends the pin in the commit that mounts the reply, so the reply
-   grows below the row and the trigger stays where it was. A reply that lands before `apply` runs
-   moves the hold to the reply's row.
-
-   Upstream LegendList anchors only rows from the first fully visible one down to the last fully
-   visible one, 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, and a bottom-edge anchor just under the viewport would not hold at all. The LegendList
-   patch counts the rows cut off at the top, and the row just past the bottom, as in view and
-   applies `shouldRestorePosition` to size changes too. It also drops LegendList's Android clamp
-   prediction: the scroll view clamps after the adjustment
-   ([scroll view corrections](#scroll-view-corrections)), so the prediction moved a collapse near
-   the end to the end.
-
-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 twelve 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,11 +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 turn boundary commits the queue before turn liveness changes.** The final reply arrives a few milliseconds before `turn_completed`, so it is still queued when the turn ends. `applyStreamEvent` in `viewed-timeline-sync.ts` flushes the agent's queue first; otherwise the chat paints a finished turn with no reply, drops the footer, and jumps twice.
-- **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,
+- **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,
   `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`.
 
-## Scroll view corrections
+## Inverted timeline input
 
-`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:
+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.
 
-```bash
-cd packages/app/android
-./gradlew :paseo-scroll:connectedDebugAndroidTest --no-daemon --max-workers=2 -Dorg.gradle.parallel=false
-```
+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.
 
 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/architecture.md

@@ -276,7 +276,7 @@ its teardown; reconnect creates new server IDs for surviving client handles. See
 
 **Top-level WS envelopes** are `hello`, `recording_state`, `ping`/`pong`, and `session` (which wraps the rich union of session messages).
 
-Client liveness checks use the top-level JSON `ping`/`pong` envelope, not a session RPC or RFC6455 control ping. Current clients ping every 10 seconds, beginning one interval after connecting; a window with no validated inbound frame is a miss, and two misses in a row tear the socket down. When the app returns to the foreground the client runs a fresh cycle of two 5-second windows back to back, then reconnects without backoff, because a socket that died while the OS had JS suspended stays `OPEN` and accepts sends: only inbound frames prove it. Misses and probes from before the suspension do not count toward that cycle, and a window whose timer fires long after its deadline spanned another suspension, so it is discarded and the cycle starts over. Any complete frame inside a window keeps the connection, so a slow multi-frame transfer survives; a single frame that takes longer than the two windows to arrive after foreground does not, and the fix for that is smaller daemon-to-client frames, not a longer window. The first ping claims an application-ownership lease for that physical socket, all later inbound activity renews it, and the daemon forcibly terminates the socket if the lease expires. A legacy or raw socket that never sends an application ping never enters this lease and is not closed for omitting one. Session RPC timeouts are operation failures, not proof that the socket is dead. A subscription bootstrap timeout closes its source to clear any unknown server-owned registration; the failed handle is released before other surviving handles reconnect.
+Client liveness checks use the top-level JSON `ping`/`pong` envelope, not a session RPC or RFC6455 control ping. Current clients ping every 10 seconds, beginning one interval after connecting. The first ping claims an application-ownership lease for that physical socket, all later inbound activity renews it, and the daemon forcibly terminates the socket if the lease expires. A legacy or raw socket that never sends an application ping never enters this lease and is not closed for omitting one. Session RPC timeouts are operation failures, not proof that the socket is dead. A subscription bootstrap timeout closes its source to clear any unknown server-owned registration; the failed handle is released before other surviving handles reconnect.
 
 Every physical send path enforces an 8 MiB outbound high-water mark, including JSON broadcasts, binary terminal frames, and the encrypted relay adapter's asynchronous queue. This sits above the terminal stream's 4 MiB soft backpressure threshold, leaving room for snapshot catch-up before the hard cutoff. JSON is serialized once per broadcast after sockets already at the limit are removed, then its exact byte length is checked for every remaining socket. A frame that would cross the limit is not sent; that physical socket is forcibly terminated without disturbing other sockets attached to the same logical session. Multiple tabs and simultaneous direct and relay paths may legitimately share a client id.
 

docs/data-model.md

@@ -26,10 +26,6 @@ checkout root. They intentionally differ for an exact subproject inside a worktr
 restore, branch auto-name, and descriptor flows consume those persisted facts rather than
 rediscovering ownership from a directory that may already be gone. Reconciliation may refresh
 mutable placement facts, but never changes `projectId`, `cwd`, `displayName`, or `baseBranch`.
-An explicit base selection is stored in the checkout's Git-directory Paseo metadata and
-mirrored to `baseBranch` in every workspace record sharing that checkout. The record keeps
-recovery possible after the checkout metadata is deleted. A newly opened workspace inherits
-the checkout's selected base; separate worktrees keep separate bases.
 Workspace archive runs lifecycle teardown from the exact `cwd` but removes only the backing
 `worktreeRoot` after its last active reference disappears. Worktree recovery recreates that backing
 checkout from `mainRepoRoot`, then restores the relative path from `worktreeRoot` to `cwd`.
@@ -475,7 +471,7 @@ Array of workspace records. A workspace is a specific working directory within a
 | `title`                        | `string \| null`                                             | User-set name override layered over `displayName`. Null means "use `displayName`".                                                                                                            |
 | `branch`                       | `string \| null`                                             | The current Git branch for git-backed workspaces. Separate from `displayName`/`title`; a background branch refresh never rewrites the name.                                                   |
 | `worktreeRoot`                 | `string \| null`                                             | Backing checkout/worktree root. May differ from `cwd` for exact subprojects and remains persisted after the worktree is deleted so restore can reproduce the placement.                       |
-| `baseBranch`                   | `string \| null`                                             | Current base retained across archive and restore. Explicit selections and branch-off creation store exact refs; older records may store branch names. Null means no recorded base.            |
+| `baseBranch`                   | `string \| null`                                             | Comparison base retained across archive and restore. Branch-off creation stores the resolved ref; legacy and PR-checkout records hold a bare name. Null means no recorded base.               |
 | `isPaseoOwnedWorktree`         | `boolean`                                                    | Whether Paseo owns and may remove/recreate the backing `worktreeRoot`                                                                                                                         |
 | `mainRepoRoot`                 | `string \| null`                                             | Main repository root for worktree checkouts, independent of both exact `cwd` and backing `worktreeRoot`                                                                                       |
 | `createdAt`                    | `string` (ISO 8601)                                          |                                                                                                                                                                                               |

docs/design.md

@@ -68,15 +68,9 @@ 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 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()`.
+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()`.
 
-Dense toolbar rows, such as the composer's, are the exception to the 44pt control. Touch-sized the row is 44pt tall and each control is a 36pt circle (`TOOLBAR_DISC_SIZE`): send and stop fill it, and every other control's pressed highlight fills it, so every highlight is the same fully rounded shape. Labelled pickers are 36pt pills. A control lays out at the width of what it paints (`toolbarSlot`, `toolbarContentSlot`) and its circle reaches into the gaps, so `TOOLBAR_CONTROL_GAP`, 20pt, is the visible space between glyphs. Toolbar glyphs match the header icons: 20pt, the app's 1.5px stroke, resting at `foreground` (`toolbarGlyphsFor`). The context ring is 18pt with a 2px stroke (`TOOLBAR_RINGS`): a circle fills its box where an outline glyph does not, and a thin circle reads lighter than a glyph at the same stroke. A disc's solid glyph, such as the stop square, stays at the `md` size (`TOOLBAR_DISC_GLYPH_SIZES`). Pointer-sized toolbars keep 28px controls, a 4px gap, and a 16pt muted glyph that brightens on hover.
-
-In the composer, the first glyph's ink starts on the text column's edge, and the trailing control is always a disc, so the row does not shift as it changes between voice mode, send and stop. The disc nests into the corner, as far from the right edge as from the bottom, and touch-sized the composer's corner radius is concentric with it (`packages/app/src/composer/input/toolbar-rails.ts`).
-
-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.
+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.
 
 A `<Pressable>` wrapping a `<Text>` is a sixth variant. It is wrong. `<Button>` accepts `style`, `textStyle`, `leftIcon`, `disabled`, `size`, and `variant`.
 
@@ -144,7 +138,7 @@ Things align to their glyphs, not to their boxes. A row's leading icon, its titl
 
 Pick the rails from the content, then hold them. A settings card establishes a leading rail at the icon's left edge and a trailing rail at the last glyph's right edge; every row in that card uses the same two. A row whose icon is absent still starts its title on the leading rail. Indentation is a new rail, not an arbitrary offset.
 
-The pressable is bigger than the glyph, and that is fine. Hit areas grow outward from the aligned content — they never move it. A button that looks two pixels off because its padding is asymmetric is misaligned even though its box is correct. The composer toolbar is the worked example: its outermost ink, the attach `+` on the left and the trailing glyph or send/stop disc on the right, sits on the text column's edges, and the 44pt touch slots overhang into the composer padding by each end control's ink inset (`composerToolbarOverhang`).
+The pressable is bigger than the glyph, and that is fine. Hit areas grow outward from the aligned content — they never move it. A button that looks two pixels off because its padding is asymmetric is misaligned even though its box is correct.
 
 Optical alignment beats arithmetic when a glyph disagrees with its bounding box. Icons with visual weight on one side, chevrons, and single-character labels usually need a small nudge to look centered. Trust the eye, then leave a comment saying the offset is optical.
 
@@ -156,7 +150,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 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.
+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.
 
 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:
 
@@ -173,8 +167,6 @@ Electron window controls are top-corner obstructions, not a compact-layout condi
 
 Windows and Linux controls are fixed window chrome, outside scrolling header content. A tab rail that reaches them ends at their obstruction and shows the shared overflow fade. On macOS, the Explorer toggle occupies a fixed top-right window slot so opening and closing Explorer does not move the pointer target.
 
-Each window edge has one safe-area owner. `WindowLayoutProvider` publishes the bottom inset that every surface reads through `useSafeAreaInsets()`: on iOS 27.1 and later it is UIKit's bottom-bar clearance, which refines the rectangular home-indicator inset to the screen's corners, and elsewhere the system inset. Surfaces apply that value once and never stack their own spacing under it; `WindowLayoutSurface` owns the horizontal insets the same way.
-
 A new list+detail feature copies the settings shell. A new workspace-shaped feature copies the workspace shell. Inventing a third shape happens in design review, not in a PR.
 
 ---

docs/development.md

@@ -594,16 +594,7 @@ rerun passes only by landing elsewhere.
 To confirm, fetch the URL from several runners and compare `content-length`, the `cf-ray` colo
 suffix, and the number of `attestations` entries (#7730 has the probe). To fix, remove or
 replace that version in the lockfile. If the dependent’s range cannot be changed, pin a clean
-version in root `overrides`. Report the URL to npm so they purge it.
-
-A lockfile regeneration is itself how new bad versions enter: the pkijs fix re-resolved the
-electron-builder tree and pulled in `semver` 5.7.3 and 6.3.2, published two days earlier, and
-5.7.3 then failed the same way. After editing `overrides`, run `npm install --package-lock-only`
-and check that the changed `resolved` lines in `package-lock.json` are only the ones you meant.
-
-A per-parent override such as `"tiny-async-pool": { "semver": "5.7.2" }` applies to that
-parent's whole subtree, so it can also downgrade a grandchild that needs a different major. Key
-the child by range (`{ "semver@^5": "5.7.2" }`) so only matching edges are replaced.
+version in root `overrides` and regenerate the lockfile. Report the URL to npm so they purge it.
 
 ## ACP provider catalog versions
 

docs/expo-router.md

@@ -68,7 +68,7 @@ When app-wide routes such as `/new`, `/settings`, or `/sessions` navigate back
 into a host workspace, use `navigateToWorkspace()`. Do not make the caller
 branch on its current route.
 
-Pass only `serverId` and `workspaceId` to restore the workspace’s selected tab.
+Pass only `serverId` and `workspaceId` for normal attention-aware navigation.
 When the action names a specific tab, pass it as `target`; that explicit choice
 is authoritative. Callers should not choose between separate route and tab
 navigation APIs.

docs/floating-panels.md

@@ -157,7 +157,8 @@ 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, and keyboard anchor. Its contexts and reconciliation stay private. Keep `KeyboardShiftProvider`
+shift hooks, shift style, translate view, keyboard anchor, settled stream inset, and explorer padding
+policy. 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
@@ -170,19 +171,15 @@ 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 stream list updates its viewport.
-
-The docked composer rests at the larger of the safe-area bottom and 16pt. With
-the keyboard open it keeps 16pt above the keyboard through the translate view's
-`keyboardGap`, which rises further than the keyboard's safe-area overlap. Do not
-grow the composer's bottom padding with the keyboard instead.
+band or a paused transition when the inverted 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. The stream list gets no keyboard inset either; see
-[who owns the offset](agent-stream-disclosure.md#who-owns-the-offset).
+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.
 
 The translated dock's height is not the composer's available height. Bound the
 composer against the stationary space below the header inside

docs/hover.md

@@ -135,7 +135,7 @@ Heuristic: if your hover state is going to be `useState`'d and read by anything
 
 Sometimes the revealed content can't live inside the trigger — a hover card portals into a different layer, a tooltip floats above other content, a popover renders into a `Portal`. There's a real visual gap the user has to cross with the cursor.
 
-For a card whose content the user can point at or press, use `HoverCard` (`packages/app/src/components/ui/hover-card.tsx`). It is built on `useHoverSafeZone` (`packages/app/src/hooks/use-hover-safe-zone.ts`), which computes a rectangular "bridge" across the gap between the trigger and the content, whether the card sits beside, above, or below the trigger. While the pointer is inside trigger, content, or the bridge, the card stays open. A short grace timer absorbs jitter at the edges. Only one card per overlay layer is open: pointing at another trigger replaces the open card at once, so a sweep down a list never shows two cards or leaves one behind. `Tooltip` takes no pointer events and closes as soon as the pointer leaves the trigger. If the trigger has no focusable child, give `HoverCardTrigger` `focusable` and an accessible label so keyboard users can open the same content.
+For a card whose content the user can point at or press, use `HoverCard` (`packages/app/src/components/ui/hover-card.tsx`). It is built on `useHoverSafeZone` (`packages/app/src/hooks/use-hover-safe-zone.ts`), which computes a rectangular "bridge" across the gap between the trigger and the content, whether the card sits beside, above, or below the trigger. While the pointer is inside trigger, content, or the bridge, the card stays open. A short grace timer absorbs jitter at the edges. `Tooltip` takes no pointer events and closes as soon as the pointer leaves the trigger. If the trigger has no focusable child, give `HoverCardTrigger` `focusable` and an accessible label so keyboard users can open the same content.
 
 Don't roll your own. The math is annoying, the edge cases (pointer leaves window, drag in progress, content unmounts) are subtle, and we already paid for the hook.
 

docs/keyboard-shortcuts.md

@@ -84,10 +84,3 @@ its DOM-derived scope.
 Escape interrupts an agent only in the message input or an unclaimed surface.
 A focused terminal excludes that binding. The source leaves terminal Escape alone;
 terminal Escape/Ctrl forwarding is a separate feature.
-
-## Keys shared with text editing
-
-A binding on a key the platform already uses for editing, such as Cmd/Ctrl+Z for
-workspace archive undo, declares `editable: false` and registers its handler with
-`isActive` true only while it has work. An inactive handler leaves the key
-unhandled, so the pipeline skips `preventDefault` and the platform's own undo runs.

docs/markdown-renderer.md

@@ -26,8 +26,6 @@ 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/menus.md

@@ -226,8 +226,7 @@ its own.
   inactive. An async action can navigate before its menu closes; a hidden panel must not leave a
   portal backdrop blocking the destination. On web the chat suspends one commit after it goes
   inactive, and that inactive commit is where the surface unmounts.
-- Anchoring, flipping, edge clamping, and capping a surface's width to the display live in
-  `components/ui/anchor.ts`, shared with the hover card, and are unit-tested. Clamping moves a
-  surface but cannot shrink it, so the width cap is what keeps a wide menu on a narrow screen. Fix positioning bugs there, not at a call site.
+- Anchoring, flipping, and edge clamping live in `components/ui/anchor.ts`, shared with the hover
+  card, and are unit-tested. Fix positioning bugs there, not at a call site.
 - Everything else about floating surfaces on Android — Portal/Modal escape, lifecycle gates,
   status-bar offset, the open flash — is in [floating-panels.md](floating-panels.md).

docs/mobile-panels.md

@@ -9,10 +9,6 @@ Compact layouts have three mutually exclusive destinations:
 They are one interaction, not two independent drawers. The implementation lives in
 `packages/app/src/mobile-panels/`.
 
-Wide layouts reuse `agent-list` for the navigation overlay. When the left dock is collapsed or
-yields its width, a touch swipe reveals the same sidebar over the workspace at the resolved sidebar
-width. The workspace does not move, and the saved dock preference does not change.
-
 ## Ownership
 
 React/Zustand owns the durable intent:
@@ -27,12 +23,6 @@ interface MobilePanelSelection {
 Every semantic target change increments `revision`. Repeating the current target is idempotent.
 Compact panel selection is not persisted; a cold start begins at `agent`.
 
-Only an overlay sidebar holds `agent-list`, and only a compact layout holds `file-explorer`. App
-chrome publishes the layout (compact or wide, and the left sidebar presentation `overlay`, `dock`, or
-`hidden`) to `panel-store`, which drops any target the layout does not present. A stale
-`agent-list` would reopen the overlay on the next collapse; a stale `file-explorer` after widening
-would block the navigation swipe, which begins only from `agent`.
-
 The UI worklet owns transient motion:
 
 - one normalized position (`-1` left, `0` center, `1` right)
@@ -42,10 +32,8 @@ The UI worklet owns transient motion:
 
 React publishes the active panel only when the canonical target and the UI-thread position agree at
 the final anchor. Retained content never observes gesture previews, progress, or an unsettled target.
-The gesture hosts stay mounted. A pointer capture on a paragraph confines browser selection to that
-paragraph, so the Gesture Handler web patch keeps it off: initially disabled hosts register no
-pointer listeners, and an enabled host captures only a pointer its handler still tracks after
-pointer-down. The touch-only navigation pans fail a mouse at pointer-down and never capture it.
+The gesture hosts stay mounted. The Gesture Handler web patch keeps initially disabled hosts
+from capturing paragraph pointers; that capture confines browser selection to its starting paragraph.
 Native worklets own overlay opacity and pointer events while
 React owns settled panel activity and accessibility. Keep hidden native overlays laid out: collapsing
 their scroll ranges makes Android spring retained offsets back to zero during touch cancellation or
@@ -55,11 +43,8 @@ appearance keys; see [Unistyles appearance boundaries](unistyles.md#runtime-them
 
 ## Why one position
 
-Both transforms and both backdrop opacities are derived from the same normalized position. Panel
-width is only a projection input: the window width on the right, and on the left the width
-`MobilePanelsProvider` resolves (the full window on compact layouts, the saved sidebar width
-clamped to the viewport on wide ones). The dock, the overlay, and their gestures read that one
-value. Rotation changes the projection, not the panel state.
+Both transforms and both backdrop opacities are derived from the same normalized position. Window
+width is only a projection input. Rotation changes the projection, not the panel state.
 
 This makes these invalid states unrepresentable:
 
@@ -77,9 +62,7 @@ A gesture captures the current revision when it becomes active. Per-frame update
 while that revision still owns the gesture.
 
 When a React command arrives during a drag, its newer revision clears gesture ownership and starts
-motion toward its target, even an unchanged one: docking mid-swipe keeps `agent` and still returns
-the dragged position to its anchor. The older gesture's remaining updates and finish callback are
-ignored.
+motion toward the new target. The older gesture's remaining updates and finish callback are ignored.
 Canceled gestures return to the latest canonical target. A successful gesture starts its finishing
 motion immediately; the matching React command adopts that motion instead of restarting it. Position
 settlement and command acceptance may arrive in either order. Activity changes after both agree on
@@ -97,12 +80,6 @@ definition, no longer eligible to begin.
 
 - Callers request semantic targets through `panel-store`; they never write shared values.
 - Gesture behavior comes from the four explicit hooks in `mobile-panels/gestures.ts`.
-- Navigation gestures accept touch pointers only. Mouse and pen fail at touch-down, so dragging a
-  mouse to select text on a hybrid laptop never moves a panel. Browsers without a touch screen
-  (`hooks/pointer-capabilities`) never enable them.
-- Phone web opens a drawer only from the 32px edge it slides in from, so interior swipes stay with
-  terminals, code blocks, and diff scrollers. Native drawers and the wide overlay open from anywhere.
-  Horizontal-scroll ownership and the open-gesture blocker still take precedence.
 - A focused interactive surface may block panel-opening gestures through
   `useBlockMobilePanelOpenGestures`. Register only while the conflicting interaction is active and
   unregister when the surface is hidden or unfocused. The blocker never disables gestures that close
@@ -110,17 +87,11 @@ definition, no longer eligible to begin.
 - Keep `SidebarModelProvider` outside `MobileGestureWrapper`. The provider shares sidebar derivation
   across consumers, while Gesture Handler requires the wrapper's direct child to be a native `View`
   so its injected `collapsable={false}` reaches Android/Fabric.
-- Sidebars render through `MobilePanelOverlay`; do not duplicate overlay lifecycle or motion styles
-  in sidebar components. The wide left sidebar keeps the same content and gesture hosts when switching
-  between dock and overlay. App chrome owns mounting and presentation; settled panel activity owns
-  overlay work. A hidden dock is inactive with `display: none`; the sidebar tree stays mounted. Keep
-  the native overlay laid out while hidden, as on compact layouts. Give the switching host no
-  Reanimated layout props: a width keyed on the presentation reaches Android after React commits the
-  switch, and a lost update left the workspace at the dock width. The dock sizes to its content and
-  the overlay host fills the window.
-- The overlay's backdrop covers the whole window; safe-area padding applies to the sidebar and
-  workspace content only. It closes by swiping back, tapping the backdrop, or picking a destination:
-  every sidebar destination closes the overlay before it navigates.
+- Mobile sidebars render through `MobilePanelOverlay`; do not duplicate overlay lifecycle or motion
+  styles in sidebar components.
+- The desktop left sidebar is retained too. App chrome owns separate mounted and visible decisions:
+  closing it or yielding its width marks it inactive and applies `display: none` without conditionally
+  removing the sidebar tree.
 - Animated panel nodes use React Native static styles plus inline theme values. Do not attach
   Unistyles-generated styles to those nodes; Unistyles and Reanimated patching the same Fabric node
   has caused native crashes.

docs/mobile-testing.md

@@ -452,9 +452,18 @@ 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`. 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.
+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
 
 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,6 +2,15 @@
 
 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

@@ -118,7 +118,7 @@ appear in the plugin catalog. Editing one in development requires a daemon resta
 Directory, Git, and npm installs cannot use a built-in ID.
 
 A provider registration with `requiresConfiguration: true` participates only while its ID exists
-under `agents.providers`. Hoplite and fx use this for catalog opt-in. Add writes `{ "enabled": true }`
+under `agents.providers`. Hoplite uses this for catalog opt-in. Add writes `{ "enabled": true }`
 without `extends`, so it selects the bundled adapter. Remove deletes the config entry; setting
 `enabled: false` keeps the entry. The bundled JavaScript still loads at startup, but an absent
 provider does not enter executable resolution or catalog discovery.
@@ -474,10 +474,9 @@ 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` or
-`agent.create.before` hook that awaits a write to the agent being opened (`setMetadata`, `setLabels`,
-an option, model, thinking or mode change) waits on the open, which waits on the hook. The hooks
-reference tells plugin authors to start such a write without awaiting it.
+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
 
@@ -582,13 +581,6 @@ Register a usage source from `index.server.ts` with `server.registerUsageSource(
 
 When the host’s **Check usage** switch is off, the daemon rejects usage requests before discovery, without reading logins or calling vendors. Otherwise, the daemon calls discovery for `usage.list_reports`; the client gates this RPC on `server_info.features.usageSources`. The old `provider.usage.list` RPC maps discovered reports for older clients.
 
-## Replace sidebar content
-
-The sidebar view slot is global across hosts, while header and footer contributions retain their
-host selection. The slot owns selection loading, fallback and the error boundary; the plugin owns
-its layout. This keeps plugin failures from removing navigation or recovery controls. The
-[sidebar view guide](../public-docs/plugins/sidebar-views.md) owns the author API.
-
 ## Contribute sidebar items
 
 Sidebar header and footer items are plugin components, not descriptors. The
@@ -678,53 +670,12 @@ work inside it. See the maintained [composer pill example](../plugin-examples/lo
 `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).
 
-A plugin reads one `ComposerModel` (`packages/app/src/composer/model.ts`): state, subscribe and
-commands. `toPluginComposer` (`packages/app/src/plugins/composer-items/`) turns its state into the
-`PluginComposer` an item reads, and the host never learns which kind of composer it got. Two
-implementations provide it:
-
-- A running agent's `agentComposer(serverId, agentId)` (`composer/agent-composer/`). It exists
-  without a mounted tab: the prompt and attachments are the agent's draft in the draft store, the
-  settings are the session store's agent, and `model` and `thinking` resolve through the provider
-  catalog with `resolveAgentModelSelection`, the picker's own function, so a read equals what the
-  picker shows. The model loads the catalog itself and resolves with no models until it lands, as the picker does,
-  so a read never differs from what the picker shows. While anything watches the model it holds a
-  `QueryObserver` on the agent's catalog: that is what lets reconnect repair, which refetches only
-  active queries, refresh a catalog nobody has a picker open for, and retry one that failed.
-  `PluginComposersSource.subscribe(selector, listener)` is what holds it for `useComposers`, so
-  the subscription must go through the model's own `subscribe`. Watching again after the catalog
-  was invalidated or failed refetches it, and a read with no watcher starts one deduplicated
-  refresh and shows the cached catalog until it lands. The model keeps one pair of store
-  subscriptions however many components watch it. It is shared for as long as its agent is in the
-  session and not archived, so a command a plugin saved keeps reaching the composer a later tab
-  mounts; it is dropped when the agent is gone or archived and nothing watches it or has one
-  mounted, checked on session changes and when the last holder lets go. The mounted
-  `AgentControls` plugs its input in with `attachInput` so `insertText` lands at the cursor.
-  Without a live input the model writes the stored prompt with `replaceDraftText`, which also asks
-  a mounted input to show it. A workspace the user left stays mounted, display none. Web
-  drops the input ref there; native keeps the input, with a stale cursor and selection.
-  `ComposerInput.isLive()` is how the model tells: it needs the ref and a retained panel that is
-  showing (`useRetainedPanelActive`). Closing a root agent's tab archives
-  it, so a running agent with no mounted composer at all only exists as a subagent whose tab was
-  closed. The daemon does not check `setModel` and `setThinking` against a catalog; the provider
-  decides and its refusal rejects the call.
-- A draft or New workspace screen's `composerModelFromHalves`, an adapter over the two contexts
-  in `composer/session.tsx`: `Composer` provides `ComposerInput` (prompt, attachments),
-  `DraftAgentControls` provides `ComposerAgent` (settings), and the adapter enforces the lock.
-
-`ComposerAgent` stays for the built-in controls. Add a capability to the `ComposerModel`, both
-implementations and `toPluginComposer`; never branch on `context` in the host.
-
-`useComposers` and `composers()` reach an agent's model by reference (`plugins/composer-items/source.ts`):
-`PluginInstallationProvider` provides the plugin's source to every surface, and
-`createPluginCapabilities` puts `composers` on every command context. `{ focused: true }` is the
-agent Command Center registration hands to agent items, published through `plugins/focused-agent.ts`
-(null outside a workspace route). The source reads that module, not the navigation or layout
-stores, so the plugin runtime does not import them. The remembered workspace selection is
-navigation restore state and is not the focused agent. The query-cache subscriptions react to
-`updated` events only: a `useQuery` in another component's render announces `added`, and a
-subscriber that updates then triggers React's "update a component while rendering a different one"
-warning.
+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`),
@@ -735,8 +686,8 @@ item that renders nothing still counts for density; there is no registration for
 
 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. It passes a model id to the form
-as the picker does, with no catalog check; for a running agent the provider decides. `ComposerControl` owns the pending state and the error toast for callbacks that
+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

docs/providers.md

@@ -53,18 +53,12 @@ or without a control.
   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. 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.
-- **One change at a time per agent.** `AgentManager` runs every option, model, thinking and mode
-  change inside the agent's lifecycle lane, the same queue that opens, reopens, closes and
-  archives it. `applyOptions`, `setModel`, `setThinkingOption` and `setMode` are never in flight
-  together on one session, and none of them overlaps an open or reopen. Providers do no
-  sequencing of their own: no queues, no "apply over the options as they are now" handling. A
-  change that arrives while another runs waits for it and then reads the agent's stored options
-  as that one left them.
+  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
@@ -180,7 +174,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. It returns `{ controls, options }`: the options a session opened from the draft would run with, so a value the provider resolves natively (an ACP select nobody set) shows in the draft the same way it would on the agent.
+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.
 
 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.
 

docs/release.md

@@ -281,26 +281,23 @@ Drafts do not appear in GitHub's releases feed. Updater clients continue to see
 
 The `rollout_hours` input on `desktop-release.yml` is **only read on `workflow_dispatch`** — tag-push runs always default to 36. To get any other rollout duration on a fresh release, use the post-publish flip below.
 
-### Instant-admit release (rollout_hours=0)
+### Instant-admit release (rollout_hours=0 from publish)
 
-`npm run release:patch` and `npm run release:minor` tag-push, and tag-push runs always stamp 36 hours. To admit everyone immediately (hotfix, doc-only change, a release you want out fast), cut the release normally, wait for it to publish, then flip the manifests:
+For a fresh release that should admit everyone immediately (low-risk change, doc-only, hotfix, or just a release you want out fast), cut the release normally and queue the rollout flip immediately after:
 
 ```bash
-# 1. Cut and publish (36h ramp from tag push).
+# 1. Cut and publish (default 36h ramp from tag push).
 npm run release:patch
 
-# 2. Wait for Desktop Release to publish the GitHub Release.
-gh run watch <desktop-release-run-id> --exit-status
-
-# 3. Flip the published manifests to instant admit.
+# 2. Immediately queue the flip — runs as soon as finalize-rollout completes.
 gh workflow run desktop-rollout.yml \
   -f tag=v0.1.64 \
   -f rollout_hours=0
 ```
 
-Dispatch only after `finalize-rollout` has published the release. Until then the release is a draft, and a draft has no tag: `desktop-rollout.yml` looks the release up by tag and fails with `release not found`. The concurrency group `desktop-rollout-<tag>` that the two workflows share orders them only once both are queued; it does not hold an early dispatch until the draft is published.
+**Why this is gap-free:** `desktop-release.yml`'s `finalize-rollout` job and `desktop-rollout.yml` share the concurrency group `desktop-rollout-<tag>`. Dispatching `desktop-rollout.yml` while the tag-push pipeline is still running queues it safely behind `finalize-rollout`. The first public manifests already carry `rolloutHours=36`, then `desktop-rollout.yml` flips them to `rolloutHours=0` shortly afterward. The renderer polls every 30 minutes, so active stable users pick up the new manifest on their next check.
 
-The first public manifests carry `rolloutHours=36` for the minutes between publish and the flip. The renderer polls every 30 minutes, so active stable users pick up the new manifest on their next check.
+Run the dispatch right after `release:patch` or `release:minor` returns. Don't wait for the tag-push CI to finish.
 
 ### Adjusting an already-published release
 

docs/terminal-worker.md

@@ -15,20 +15,17 @@ supervisor (paseo.pid) ──► daemon worker ──► launcher ──► term
 - The worker exits on its own when it has no controller and no terminals, on `shutdown`, on SIGTERM (killing its terminals), and when its record disappears (a deleted `$PASEO_HOME`: nobody can ever reach it again).
 - Its stderr goes to `$PASEO_HOME/terminal-worker.log`. No pipe to the daemon survives the daemon.
 
-The worker retains a fixed 10,000 history rows plus the screen in its existing xterm. Replay uses `@xterm/addon-serialize` 0.14 against headless xterm 6; no second cell grid or lifetime byte log is retained. The serializer boundary owns cursor position, visibility and explicit program-selected presentation; the addon alone does not preserve all three. An unset program style leaves each client’s configured cursor defaults intact. It also restores SGR mouse encoding: the addon preserves mouse tracking but omits its encoding, so switching away and back otherwise sends legacy wheel reports that Copilot CLI cannot use. These missing modes require xterm's internal services because its public modes API omits them. Standard modes come from the serializer; the existing input-mode tracker retains protocol modes such as Kitty and Win32 input. Commit that tracker with parsed output so replay bytes and metadata describe the same cut.
+The worker retains a fixed 10,000 history rows plus the screen in its existing xterm. Replay uses `@xterm/addon-serialize` 0.14 against headless xterm 6; no second cell grid or lifetime byte log is retained. The serializer boundary owns cursor position, visibility and explicit program-selected presentation; the addon alone does not preserve all three. An unset program style leaves each client’s configured cursor defaults intact. Standard modes come from the serializer; the existing input-mode tracker retains protocol modes such as Kitty and Win32 input. Commit that tracker with parsed output so replay bytes and metadata describe the same cut.
 
 Which triggers keep terminals and which close them is owned by the stop reason (`keepTerminals`) that flows from the request through the supervisor to `stop()`. The kill side always ends in the reaper (`terminal-worker-reaper.ts`), the only path that signals terminal processes outside a connected daemon.
 
 ## Record, socket and secret
 
-The worker writes `$PASEO_HOME/terminal-worker/<pid>.json` (owner-only) with its pid, protocol version, socket path, random secret, runtime copy and terminal programs. One daemon holds the home's pid lock. Its records and sockets belong to that home.
+The worker writes `$PASEO_HOME/terminal-worker/<pid>.json` (owner-only) with its identity (birth time + command line carrying `--paseo-terminal-worker <recordId>`), protocol version, socket path, a random secret, the copy it runs from, and each terminal program's pid and birth time.
 
-- The first frame must be `hello` with the secret; anything else closes the connection. Anyone authenticated can type into every shell, so the record and Unix socket are `0600` inside a `0700` directory.
-- New socket names include the record id. A stale record whose pid belongs to a newer worker cannot reach that newer worker. Existing records keep their recorded paths. Legacy paths use only the home and pid, so force-killing through one also requires successful authentication. A legacy socket that cannot authenticate stays unconfirmed.
-- A missing pid or refused socket retires the record without signaling the worker. An accepting socket identifies the live worker. Cleanup asks it to shut down, then probes again before force-killing it after the grace period (`taskkill /T` on Windows). An inconclusive probe counts toward the worker limit and is retried on the next start or stop without signaling it.
-- Workers never query their own birth time or command line. Readers accept legacy identity fields but ignore them. Daemons through 0.15.1 report new records unreadable and cannot adopt them.
-- Windows terminal programs have no recorded birth time and terminal lifecycle operations never launch PowerShell. Linux and macOS retain program birth-time checks through `ps` with `LC_ALL=C`; Linux also walks sessions to find surviving jobs.
-- Unix socket paths have a byte budget (103 on macOS, 107 on Linux). Long dev homes use an owner-only fallback under `$TMPDIR/paseo-<uid>/` or `/tmp/paseo-<uid>/`. An existing directory must be a real `0700` directory owned by you; a shared root is never chmodded.
+- The first frame on the socket must be `hello` with the secret; anything else closes the connection. Anyone who connects can type into every shell, so the record is `0600`, the unix socket `0600` in a `0700` directory.
+- Unix socket paths have a byte budget (103 on macOS, 107 on Linux). Dev homes under worktrees blow it, so `terminal-worker-socket-path.ts` tries `$PASEO_HOME/terminal-worker/sock/`, then `$TMPDIR/paseo-<uid>/`, then `/tmp/paseo-<uid>/`, and accepts an existing directory only if it is a real `0700` directory owned by you. It never chmods a shared root.
+- Cleanup signals a process only when its birth time matches the record. Birth times come from `ps -o lstart` with `LC_ALL=C` (it follows `LC_TIME` otherwise) and from `Win32_Process.CreationDate`. A missing birth time is "unknown", never matched by command text: a shell that ran `exec` keeps its pid and birth time but not its argv.
 - A kill cleanup that cannot confirm every process gone writes `closing-<recordId>.json` beside the worker record. The worker rewrites its own record whenever a terminal starts or exits, so the kill intent has to live in a file it never writes. A closing record is never adopted; the next stop or start retries it.
 - An unreadable record of either kind makes `daemon status` and a kill restart fail with its path: a kill cleanup that met it could not check what it names, and leaves nothing else behind. A read that fails with `EPERM`, `EBUSY` or `EACCES` is retried for 250ms first: on Windows, opening a record while the worker renames its new copy over it fails that way for a moment.
 
@@ -43,7 +40,7 @@ The worker writes `$PASEO_HOME/terminal-worker/<pid>.json` (owner-only) with its
 | two or more older                  | shuts it down; its terminals close (logged)                                                                                                                 |
 | newer, or a version it cannot read | leaves it running, undriven; `list_terminals` and `create_terminal` answer `rpc_error` `terminal_worker_incompatible`, and `paseo daemon status` prints why |
 
-Never more than two workers run. A new worker launches only when none is current, none is incompatible and fewer than two run. The count comes from the records, so an unreachable worker counts, as does one whose socket probe is inconclusive, and one a cleanup could not confirm gone. When two run, the daemon starts with no current worker, and the first terminal created after one of them exits launches it.
+Never more than two workers run. A new worker launches only when none is current, none is incompatible and fewer than two run. The count comes from the records, so an unreachable or unidentified worker counts, and so does one a cleanup could not confirm gone. When two run, the daemon starts with no current worker, and the first terminal created after one of them exits launches it.
 
 **The frozen envelope never changes across versions:** the frame format (4-byte length + `v8.serialize`), `hello`/`helloAck`, the `listTerminals` info fields and `shutdown`. That is what lets any daemon close any worker: a kill stop sends `shutdown` to a newer worker it cannot otherwise drive. Protocol 5 hard cuts unreleased protocols 1 through 4, including the acknowledgement-based replay contract: those workers are obsolete and close. For future versions, keep a previous-version adapter so the draining worker can still be driven, and drop the adapter for the version before that.
 

docs/timeline-sync.md

@@ -69,8 +69,8 @@ Source coverage still includes interleaved tool updates.
 
 Canonical IDs define runs. With missing IDs, human prompts, heartbeats and typed received
 agent messages each start a fallback turn. This deterministic fallback is shared by paging
-and presentation; it cannot recover historical batching or steering. An underfilled viewport
-loads older history until it fills or history is exhausted. Further history is user-driven.
+and presentation; it cannot recover historical batching or steering. Older history remains
+user-driven by scrolling upward.
 
 A failed catch-up or subscription reconcile retries on its own, doubling from 1s to a 30s ceiling.
 A fixed 1s retry turned a persistent daemon-side refusal — a Codex thread that already has an active
@@ -95,52 +95,21 @@ 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 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.
+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.
 
 ## Resume behavior
 
-Opening, reconnecting, and returning from app background establish whether the chat is current.
-Switching between continuously subscribed open chats needs no fetch. Focus alone does not mutate
-timeline state; the response is compared with the local authoritative range first.
+Opening, reconnecting, and returning from app background establish the current timeline through
+bounded catch-up. Switching between continuously subscribed open chats needs no fetch.
+Focus alone does not mutate timeline state; the response is compared with the local
+authoritative range first.
 
-A chat with a cached cursor asks the daemon first. The `agent.timeline.set_subscription.request`
-that attaches the chat carries its `{ epoch, seq }`, and the response answers `current` or `behind`
-per chat. The daemon attaches before it compares, so an entry committed in between arrives live or
-counts as behind. `current` means the agent is loaded, the epoch matches, and the cursor is at the
-head; it completes catch-up with no fetch. The response carries the agent row for each `current`
-chat, because the timeline fetch is also what refreshes that row and the replica cache stores only
-part of it. `behind`, or no entry, runs the bounded catch-up. The subscribe handler never loads an
-agent, so an agent the daemon has not loaded answers `behind` and resumes in that fetch. Hosts without `features.timelineFreshnessCheck` get no cursors and always fetch.
-
-Cached history remains readable during recovery. The chat shows Reconnecting to host while the host
-is offline and until a reconnected chat's check answers, so an unchanged chat never shows a second
-toast. A check on cached content shows nothing. Updating messages appears for a chat that is behind,
-until the fetch completes, and for a check still unanswered `FRESHNESS_CHECK_QUIET_MS` after it was
-sent. That delay measures the daemon, so it starts at the request: on a cold start the cache read
-alone can take longer. Socket connectivity alone cannot certify that the displayed conversation is
-current. The timeline owner publishes freshness; the view renders it without a toast timer or a
-separate resume workflow.
-
-The turn footer in a chat follows its messages, not the agent status. Turn activity comes from the
-agent directory and messages from the chat's own catch-up, and either can land first. So the
-timeline owner keeps an unsettled turn per chat: the turn its messages were captured during. It is
-set when a check or catch-up becomes owed while the turn is open, or when cached messages are
-painted that were saved while one was, and it is saved with those messages in the replica. It
-carries the turn's start time. While it is set and the agent reads idle, the chat keeps showing that
-running turn, with its loader and elapsed timer unchanged, and there is no separate catching-up
-footer. The commit that brings the chat current clears it, in the same store write as the rows, so
-the final messages and the completed footer land together. A `current` answer is that commit with no
-rows. A check in flight keeps the hold, and `behind` keeps it until the fetched rows land. A failed
-catch-up clears it too, and the footer takes the true status. Losing the connection is not a failed
-catch-up: none can run or fail until the host returns, so the running footer stays beside
-"Reconnecting to host" and the check on reconnect resolves it. Releasing it offline would put a
-completed footer under messages known to be behind. Surfaces outside the timeline (the sidebar,
-tabs, the composer's stop and send controls) read the true status and never see this state. Live
-delivery needs no hold because `applyStreamEvent` commits queued rows before it applies turn
-liveness.
+Cached history remains readable during recovery. The chat shows Reconnecting to host while the host is
+offline, then Updating messages until authoritative catch-up completes. Socket connectivity alone cannot
+certify that the displayed conversation is current. The timeline owner publishes freshness; the
+view renders it without a toast timer or a separate resume workflow.
 
 The draft-create handoff has the same lifetime: the viewed-timeline owner releases it when the sync
 stops owing that chat a catch-up, not when the first authoritative page lands. Releasing it at the

fastlane/metadata/android/en-US/changelogs/150011.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150012.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150013.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150014.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150021.txt

@@ -1,8 +0,0 @@
-Added
-- Added a first-run setup on Paseo Desktop and web that walks new users through theme, providers, projects, agent orchestration and the mobile app, with Settings → General → Show setup again to reopen it
-- Added project suggestions from the folders where you ran Claude Code, Codex, OpenCode or Pi, shown in the setup Projects step
-
-Improved
-- Changed the theme picker to a grid of tiles with a preview of each theme
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150022.txt

@@ -1,8 +0,0 @@
-Added
-- Added a first-run setup on Paseo Desktop and web that walks new users through theme, providers, projects, agent orchestration and the mobile app, with Settings → General → Show setup again to reopen it
-- Added project suggestions from the folders where you ran Claude Code, Codex, OpenCode or Pi, shown in the setup Projects step
-
-Improved
-- Changed the theme picker to a grid of tiles with a preview of each theme
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150023.txt

@@ -1,8 +0,0 @@
-Added
-- Added a first-run setup on Paseo Desktop and web that walks new users through theme, providers, projects, agent orchestration and the mobile app, with Settings → General → Show setup again to reopen it
-- Added project suggestions from the folders where you ran Claude Code, Codex, OpenCode or Pi, shown in the setup Projects step
-
-Improved
-- Changed the theme picker to a grid of tiles with a preview of each theme
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150024.txt

@@ -1,8 +0,0 @@
-Added
-- Added a first-run setup on Paseo Desktop and web that walks new users through theme, providers, projects, agent orchestration and the mobile app, with Settings → General → Show setup again to reopen it
-- Added project suggestions from the folders where you ran Claude Code, Codex, OpenCode or Pi, shown in the setup Projects step
-
-Improved
-- Changed the theme picker to a grid of tiles with a preview of each theme
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150031.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed conversation text becoming blurred when opening or dismissing the keyboard on iOS 26+
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150032.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed conversation text becoming blurred when opening or dismissing the keyboard on iOS 26+
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150033.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed conversation text becoming blurred when opening or dismissing the keyboard on iOS 26+
-
-Full notes: https://paseo.sh/changelog

fastlane/metadata/android/en-US/changelogs/150034.txt

@@ -1,4 +0,0 @@
-Fixed
-- Fixed conversation text becoming blurred when opening or dismissing the keyboard on iOS 26+
-
-Full notes: https://paseo.sh/changelog

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-vwivjBU5VFpM9VD7Wx4IKHN6xEVlg/KBMJCCMuA1JEw=
+sha256-p97CaALgkY+x9XVvS4/ILqmbwYSX0fSbVUgQl35BjiU=

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "paseo",
-  "version": "0.15.3",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "paseo",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "workspaces": [
@@ -8142,26 +8142,6 @@
         "@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",
@@ -15088,9 +15068,9 @@
       }
     },
     "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "version": "6.3.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.2.tgz",
+      "integrity": "sha512-GYrCADwpu6yV5OAvchkQ27Z5wwMxWAEMg5NNWjyHh/5DboFFqbdbvYNIvZouQpxXyeMPoTOh0vdPYKlf0ZswdQ==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -35100,9 +35080,9 @@
       }
     },
     "node_modules/tiny-async-pool/node_modules/semver": {
-      "version": "5.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
-      "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
+      "version": "5.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.3.tgz",
+      "integrity": "sha512-kM18BPOqTi0+TB68703/GJRpAML5Me+IDQsR1J26YB3EFKKNEyHIVZuWDX7+WKQB3tHwDwgk24BfhdpWUbytvQ==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -37468,7 +37448,7 @@
     },
     "packages/app": {
       "name": "@getpaseo/app",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "dependencies": {
         "@codemirror/commands": "6.10.4",
         "@codemirror/language": "6.12.4",
@@ -37486,7 +37466,6 @@
         "@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",
@@ -39637,13 +39616,13 @@
     },
     "packages/cli": {
       "name": "@getpaseo/cli",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@clack/prompts": "^1.0.0",
-        "@getpaseo/client": "0.15.3",
-        "@getpaseo/protocol": "0.15.3",
-        "@getpaseo/server": "0.15.3",
+        "@getpaseo/client": "0.15.0",
+        "@getpaseo/protocol": "0.15.0",
+        "@getpaseo/server": "0.15.0",
         "chalk": "^5.3.0",
         "commander": "^12.0.0",
         "mime-types": "^2.1.35",
@@ -39890,11 +39869,11 @@
     },
     "packages/client": {
       "name": "@getpaseo/client",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
-        "@getpaseo/protocol": "0.15.3",
-        "@getpaseo/relay": "0.15.3",
+        "@getpaseo/protocol": "0.15.0",
+        "@getpaseo/relay": "0.15.0",
         "ws": "^8.20.0",
         "zod": "^4.4.3"
       },
@@ -39906,7 +39885,7 @@
     },
     "packages/desktop": {
       "name": "@getpaseo/desktop",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@getpaseo/cli": "*",
@@ -40149,7 +40128,7 @@
     },
     "packages/expo-two-way-audio": {
       "name": "@getpaseo/expo-two-way-audio",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "MIT",
       "devDependencies": {
         "@types/jest": "^29.5.14",
@@ -40195,7 +40174,7 @@
     },
     "packages/highlight": {
       "name": "@getpaseo/highlight",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@codemirror/language": "6.12.4",
@@ -40225,7 +40204,7 @@
     },
     "packages/plugin": {
       "name": "@getpaseo/plugin",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@agentclientprotocol/sdk": "^1.4.0",
@@ -40233,8 +40212,8 @@
         "use-sync-external-store": "^1.6.0"
       },
       "devDependencies": {
-        "@getpaseo/client": "0.15.3",
-        "@getpaseo/protocol": "0.15.3",
+        "@getpaseo/client": "0.15.0",
+        "@getpaseo/protocol": "0.15.0",
         "@types/node": "^20.9.0",
         "@types/react": "~19.2.0",
         "react": "19.2.3",
@@ -40244,8 +40223,8 @@
         "zod": "^4.4.3"
       },
       "peerDependencies": {
-        "@getpaseo/client": "0.15.3",
-        "@getpaseo/protocol": "0.15.3",
+        "@getpaseo/client": "0.15.0",
+        "@getpaseo/protocol": "0.15.0",
         "react": ">=19.1.0 <20",
         "react-native": ">=0.81.5",
         "zod": "^4.4.3"
@@ -40267,7 +40246,7 @@
     },
     "packages/protocol": {
       "name": "@getpaseo/protocol",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "semver": "^7.8.5",
@@ -40295,7 +40274,7 @@
     },
     "packages/relay": {
       "name": "@getpaseo/relay",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@noble/ciphers": "^2.4.0",
@@ -40517,17 +40496,17 @@
     },
     "packages/server": {
       "name": "@getpaseo/server",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@agentclientprotocol/sdk": "^0.17.1",
         "@anthropic-ai/claude-agent-sdk": "0.3.246",
         "@anthropic-ai/sdk": "^0.104.2",
-        "@getpaseo/client": "0.15.3",
-        "@getpaseo/highlight": "0.15.3",
-        "@getpaseo/plugin": "0.15.3",
-        "@getpaseo/protocol": "0.15.3",
-        "@getpaseo/relay": "0.15.3",
+        "@getpaseo/client": "0.15.0",
+        "@getpaseo/highlight": "0.15.0",
+        "@getpaseo/plugin": "0.15.0",
+        "@getpaseo/protocol": "0.15.0",
+        "@getpaseo/relay": "0.15.0",
         "@isaacs/ttlcache": "^2.1.4",
         "@modelcontextprotocol/sdk": "1.29.0",
         "@opencode-ai/sdk": "1.14.46",
@@ -41474,7 +41453,7 @@
     },
     "packages/website": {
       "name": "@getpaseo/website",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "dependencies": {
         "@cloudflare/vite-plugin": "^1.29.1",
         "@cloudflare/workers-types": "^4.20260317.1",
@@ -43084,7 +43063,7 @@
     },
     "plugins": {
       "name": "@getpaseo/builtin-plugins",
-      "version": "0.15.3",
+      "version": "0.15.0",
       "dependencies": {
         "@getpaseo/plugin": "*",
         "zod": "^4.4.3"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo",
-  "version": "0.15.3",
+  "version": "0.15.0",
   "private": true,
   "description": "Paseo: voice-controlled development environment for local AI coding agents",
   "keywords": [
@@ -149,9 +149,6 @@
   "overrides": {
     "@codemirror/language": "6.12.4",
     "@codemirror/view": "6.43.6",
-    "@electron/get@^3.0.0": {
-      "semver@^6": "6.3.1"
-    },
     "expo": "~57.0.30",
     "expo-router": "~57.0.28",
     "lightningcss": "1.30.1",
@@ -161,9 +158,6 @@
     "react-native": "0.86.3",
     "react-native-gesture-handler": "~2.32.0",
     "react-native-reanimated": "4.5.5",
-    "react-native-worklets": "0.10.4",
-    "tiny-async-pool": {
-      "semver@^5": "5.7.2"
-    }
+    "react-native-worklets": "0.10.4"
   }
 }

packages/app/e2e/browser/acp-provider-catalog.spec.ts

@@ -28,7 +28,7 @@ const ACP_PROVIDER = {
 
 interface ProviderCatalogDaemonClient {
   getLastServerInfoMessage(): {
-    features?: { fxProvider?: boolean; hopliteProvider?: boolean; plugins?: boolean };
+    features?: { hopliteProvider?: boolean; plugins?: boolean };
   } | null;
   connect(): Promise<void>;
   close(): Promise<void>;
@@ -58,31 +58,6 @@ test.describe("ACP provider catalog", () => {
   });
 });
 
-test("adds fx from the catalog with only a config entry", async ({ page }, testInfo) => {
-  const client = await connectDaemonClient<ProviderCatalogDaemonClient>({
-    clientIdPrefix: "fx-catalog-e2e",
-  });
-  try {
-    expect(client.getLastServerInfoMessage()?.features?.fxProvider).toBe(true);
-    await client.patchDaemonConfig({ removeProviders: ["fx"] });
-    await gotoAppShell(page);
-    await openSettings(page);
-    await openSettingsHost(page, getServerId());
-    await openSettingsHostSection(page, getServerId(), "providers");
-    await openAddProviderArea(page);
-
-    await findAcpCatalogProvider(page, "fx");
-    await page.screenshot({ path: testInfo.outputPath("fx-catalog.png") });
-    await installAcpCatalogProvider(page, "fx");
-    await expectProviderInstalledInSettings(page, "fx");
-    await page.screenshot({ path: testInfo.outputPath("fx-installed.png") });
-    expect((await client.getDaemonConfig()).config.providers?.fx).toEqual({ enabled: true });
-  } finally {
-    await client.patchDaemonConfig({ removeProviders: ["fx"] }).catch(() => undefined);
-    await client.close().catch(() => undefined);
-  }
-});
-
 for (const theme of ["light", "dark"] as const) {
   test(`adds Hoplite from the catalog in ${theme} theme`, async ({ page }, testInfo) => {
     const client = await connectDaemonClient<ProviderCatalogDaemonClient>({

packages/app/e2e/browser/agent-message-submission.spec.ts

@@ -235,7 +235,6 @@ async function beginTimelineRowStabilityCheck(
       lastTop: initialRow.getBoundingClientRect().top,
       largestDownwardShift: 0,
       sawMissing: false,
-      sawHidden: false,
     };
     const windowState = window as unknown as Record<string, unknown>;
     windowState.__messageSubmissionTimelineRowStability = state;
@@ -246,9 +245,6 @@ async function beginTimelineRowStabilityCheck(
         requestAnimationFrame(checkFrame);
         return;
       }
-      if (!initialRow.checkVisibility({ opacityProperty: true, visibilityProperty: true })) {
-        state.sawHidden = true;
-      }
       const top = initialRow.getBoundingClientRect().top;
       state.largestDownwardShift = Math.max(state.largestDownwardShift, top - state.lastTop);
       state.lastTop = top;
@@ -261,24 +257,14 @@ async function beginTimelineRowStabilityCheck(
     const result = await page.evaluate(() => {
       const windowState = window as unknown as Record<string, unknown>;
       const state = windowState.__messageSubmissionTimelineRowStability as
-        | {
-            active: boolean;
-            largestDownwardShift: number;
-            sawMissing: boolean;
-            sawHidden: boolean;
-          }
+        | { active: boolean; largestDownwardShift: number; sawMissing: boolean }
         | undefined;
       if (!state) throw new Error("Timeline-row stability check was not started");
       state.active = false;
       delete windowState.__messageSubmissionTimelineRowStability;
-      return {
-        largestDownwardShift: state.largestDownwardShift,
-        sawMissing: state.sawMissing,
-        sawHidden: state.sawHidden,
-      };
+      return { largestDownwardShift: state.largestDownwardShift, sawMissing: state.sawMissing };
     });
     expect(result.sawMissing).toBe(false);
-    expect(result.sawHidden).toBe(false);
     expect(result.largestDownwardShift).toBeLessThanOrEqual(2);
   };
 }
@@ -1192,13 +1178,7 @@ test.describe("Agent message submission", () => {
     test.setTimeout(120_000);
     const toasts = await recordPanelToasts(page);
     const pending = await beginDraftCreateSubmission(page, draftCreateScenario);
-    // The created agent takes over the draft's timeline: the same row stays mounted and painted.
-    const finishTimelineRowStabilityCheck = await beginTimelineRowStabilityCheck(
-      page,
-      pending.userMessage,
-    );
     await completeDraftCreateSubmission(page, draftCreateScenario, pending);
-    await finishTimelineRowStabilityCheck();
     // A chat this client just created is current by construction; it is never out of date.
     await toasts.expectNeverShown("agent-updating-toast");
   });

packages/app/e2e/browser/agent-timeline-resume.spec.ts

@@ -13,17 +13,10 @@ import {
 import {
   commitTimelineTurnsWhileDisconnected,
   disconnectViewedTimeline,
-  expectResumeAnsweredWithoutFetch,
+  expectOneResumeCheckWithoutTail,
   expectResumeOverflowFallsBackToOneTail,
-  hideTabAndReturn,
   rememberTimelineRequestCounts,
-  releaseHeldCatchUp,
-  restoreUnchangedViewedTimeline,
-  restoreViewedTimelineHoldingCatchUp,
   restoreViewedTimelineWithHeldResponse,
-  waitForResumeAnswer,
-  reopenAppWatchingForUpdatingToast,
-  watchForUpdatingToast,
 } from "../support/helpers/timeline-resume";
 
 test.describe("Agent timeline resume", () => {
@@ -49,9 +42,7 @@ test.describe("Agent timeline resume", () => {
     }
   });
 
-  test("returning to an unchanged chat shows no update and leaves it untouched", async ({
-    page,
-  }) => {
+  test("an unchanged resume leaves a scrolled-up timeline untouched", async ({ page }) => {
     test.setTimeout(120_000);
     const gate = await installDaemonWebSocketGate(page);
     const agent = await seedLongMockAgentTimeline({ turns: 30 });
@@ -60,65 +51,13 @@ test.describe("Agent timeline resume", () => {
       await expectTimelinePromptVisible(page, agent.newestPrompt);
       await scrollTimelinePromptIntoView(page, agent.initialTailAnchorPrompt);
       const presentation = await rememberTimelinePresentation(page, agent.initialTailAnchorPrompt);
-
-      await test.step("back from the background", async () => {
-        const requests = rememberTimelineRequestCounts(gate);
-        const expectNoUpdatingToast = await watchForUpdatingToast(page);
-
-        await hideTabAndReturn(page);
-        await waitForResumeAnswer(gate, requests);
-
-        await expectNoUpdatingToast();
-        await expectTimelinePresentationUnchanged(page, presentation);
-        expectResumeAnsweredWithoutFetch(gate, requests);
-      });
-
-      await test.step("back from a dropped connection", async () => {
-        const requests = rememberTimelineRequestCounts(gate);
-        const expectNoUpdatingToast = await watchForUpdatingToast(page);
-
-        await disconnectViewedTimeline(page, gate);
-        await restoreUnchangedViewedTimeline(page, gate);
-
-        await expectNoUpdatingToast();
-        await expectTimelinePresentationUnchanged(page, presentation);
-        expectResumeAnsweredWithoutFetch(gate, requests);
-      });
-
-      await test.step("back from reopening the app", async () => {
-        const requests = rememberTimelineRequestCounts(gate);
-
-        const expectNoUpdatingToast = await reopenAppWatchingForUpdatingToast(page);
-        await waitForResumeAnswer(gate, requests);
-        await expectTimelinePromptVisible(page, agent.newestPrompt);
-
-        await expectNoUpdatingToast();
-        expectResumeAnsweredWithoutFetch(gate, requests);
-      });
-    } finally {
-      gate.restore();
-      await agent.cleanup();
-    }
-  });
-
-  test("returning to a changed chat reports the update and shows the new messages", async ({
-    page,
-  }) => {
-    test.setTimeout(120_000);
-    const gate = await installDaemonWebSocketGate(page);
-    const agent = await seedLongMockAgentTimeline({ turns: 3 });
-    try {
-      await openAgentTimeline(page, agent);
-      await expectTimelinePromptVisible(page, agent.newestPrompt);
-      const presentation = await rememberTimelinePresentation(page, agent.newestPrompt);
+      const requests = rememberTimelineRequestCounts(gate);
 
       await disconnectViewedTimeline(page, gate);
-      const background = await commitTimelineTurnsWhileDisconnected(agent, 1);
-      await restoreViewedTimelineHoldingCatchUp(page, gate);
+      await restoreViewedTimelineWithHeldResponse(page, gate);
 
       await expectTimelinePresentationUnchanged(page, presentation);
-      await releaseHeldCatchUp(page, gate);
-      await expectTimelinePromptVisible(page, background.newestPrompt);
+      expectOneResumeCheckWithoutTail(gate, requests);
     } finally {
       gate.restore();
       await agent.cleanup();

packages/app/e2e/browser/agent-timeline-sync-retry.spec.ts

@@ -6,7 +6,6 @@ import {
   seedLongMockAgentTimeline,
 } from "../support/helpers/timeline-pagination";
 import {
-  commitTimelineTurnsWhileDisconnected,
   disconnectViewedTimeline,
   restoreViewedTimelineWithHeldResponse,
 } from "../support/helpers/timeline-resume";
@@ -19,14 +18,11 @@ test.describe("Agent timeline sync retry", () => {
     const gate = await installDaemonWebSocketGate(page);
     const agent = await seedLongMockAgentTimeline({ turns: 2 });
     try {
-      gate.holdNextClientRequest("clear_agent_attention");
       await openAgentTimeline(page, agent);
       await expectTimelinePromptVisible(page, agent.newestPrompt);
-      await gate.waitForHeldClientRequest();
 
       gate.failTimelineResponses(agent.agentId);
       await disconnectViewedTimeline(page, gate);
-      await commitTimelineTurnsWhileDisconnected(agent, 1);
       await restoreViewedTimelineWithHeldResponse(page, gate);
 
       const callout = page.getByTestId("agent-timeline-sync-error");

packages/app/e2e/browser/agent-turn-end.spec.ts

@@ -1,525 +0,0 @@
-import type { Page } from "@playwright/test";
-import { expect, test as baseTest } from "../support/fixtures";
-import { expectAgentIdle } from "../support/helpers/agent-stream";
-import { submitMessage } from "../support/helpers/composer";
-import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
-import {
-  openAgentRoute,
-  seedMockAgentWorkspace,
-  type MockAgentWorkspace,
-} from "../support/helpers/mock-agent";
-
-// A turn ends with its final reply, `turn_completed`, and the idle status snapshot arriving
-// within a few milliseconds of each other. These tests hold all three, let the running
-// turn paint, then release them together and sample every painted frame.
-
-interface Box {
-  top: number;
-  height: number;
-}
-
-interface TurnEndFrame {
-  at: number;
-  running: boolean;
-  replyLength: number;
-  footer: Box | null;
-  footerText: string;
-  elapsed: string | null;
-  userRow: Box | null;
-  replyVisible: boolean;
-}
-
-declare global {
-  interface Window {
-    __turnEndFrames?: { active: boolean; frames: TurnEndFrame[] };
-  }
-}
-
-const test = baseTest.extend<{ agent: MockAgentWorkspace }>({
-  agent: async ({ page: _page }, provide) => {
-    const agent = await seedMockAgentWorkspace({
-      repoPrefix: "turn-end-",
-      title: "Turn end",
-      initialPrompt: "emit 4 tool agent stream updates",
-    });
-    await agent.client.waitForFinish(agent.agentId, 15_000);
-    await provide(agent);
-    await agent.cleanup();
-  },
-});
-
-async function recordTurnEndFrames(
-  page: Page,
-  input: { prompt: string; reply: string | null },
-): Promise<void> {
-  await page.evaluate(({ prompt, reply }) => {
-    const state = { active: true, frames: [] as TurnEndFrame[] };
-    const isVisible = (element: Element | null | undefined) => Boolean(element?.checkVisibility());
-    const boxOf = (element: Element | null | undefined): Box | null => {
-      if (!element || !isVisible(element)) return null;
-      const rect = element.getBoundingClientRect();
-      return rect.height > 0 ? { top: rect.top, height: rect.height } : null;
-    };
-    const sample = () => {
-      const viewport = Array.from(
-        document.querySelectorAll('[data-testid="agent-chat-scroll"]'),
-      ).find((candidate) => isVisible(candidate));
-      const footer = Array.from(viewport?.querySelectorAll('[data-testid="turn-footer"]') ?? [])
-        .map((element) => ({ element, box: boxOf(element) }))
-        .filter((row): row is { element: Element; box: Box } => row.box !== null)
-        .sort((left, right) => left.box.top - right.box.top)
-        .at(-1);
-      const elapsed =
-        viewport?.querySelector('[data-testid="turn-working-elapsed"]')?.textContent ?? null;
-      const userRow = Array.from(
-        viewport?.querySelectorAll('[data-testid="user-message"]') ?? [],
-      ).find((candidate) => candidate.textContent?.includes(prompt));
-      const replyRow =
-        reply === null
-          ? undefined
-          : Array.from(viewport?.querySelectorAll('[data-testid="assistant-message"]') ?? []).find(
-              (candidate) => candidate.textContent?.includes(reply),
-            );
-      const assistantRows = Array.from(
-        viewport?.querySelectorAll('[data-testid="assistant-message"]') ?? [],
-      );
-      state.frames.push({
-        at: performance.now(),
-        running: Boolean(viewport?.querySelector('[data-testid="turn-working-indicator"]')),
-        replyLength: assistantRows.reduce((sum, row) => sum + (row.textContent?.length ?? 0), 0),
-        footer: footer?.box ?? null,
-        footerText: (footer?.element.textContent ?? "").replace(elapsed ?? "", ""),
-        elapsed,
-        userRow: boxOf(userRow),
-        replyVisible: boxOf(replyRow) !== null,
-      });
-      if (state.active) requestAnimationFrame(() => setTimeout(sample, 0));
-    };
-    window.__turnEndFrames = state;
-    requestAnimationFrame(() => setTimeout(sample, 0));
-  }, input);
-}
-
-async function recordPaintsFor(page: Page, durationMs: number): Promise<void> {
-  const until = await page.evaluate((duration) => performance.now() + duration, durationMs);
-  await expect
-    .poll(() => page.evaluate(() => window.__turnEndFrames?.frames.at(-1)?.at ?? 0))
-    .toBeGreaterThanOrEqual(until);
-}
-
-async function stopRecording(page: Page): Promise<TurnEndFrame[]> {
-  return page.evaluate(() => {
-    const state = window.__turnEndFrames;
-    if (!state) throw new Error("Turn end frames were not recorded");
-    state.active = false;
-    return state.frames;
-  });
-}
-
-async function recordTurnEnd(
-  page: Page,
-  agent: MockAgentWorkspace,
-  input: { prompt: string; reply: string | null },
-): Promise<TurnEndFrame[]> {
-  const gate = await installDaemonWebSocketGate(page);
-  await openAgentRoute(page, { workspaceId: agent.workspaceId, agentId: agent.agentId });
-  await expectAgentIdle(page);
-
-  if (input.reply === null) {
-    gate.setAgentStreamItemSuppressed("assistant_message", true);
-  } else {
-    gate.holdNextAgentStreamItem("assistant_message");
-  }
-  gate.holdNextAgentStreamEvent("turn_completed");
-  // The daemon sends more than one idle snapshot; hold the first and drop the rest until release.
-  gate.holdNextAgentUpdate(agent.agentId, "idle");
-  gate.setServerMessageSuppressed("agent_update", true);
-  await recordTurnEndFrames(page, input);
-  await submitMessage(page, input.prompt);
-  await Promise.all([
-    input.reply === null ? Promise.resolve() : gate.waitForHeldAgentStreamItem("assistant_message"),
-    gate.waitForHeldAgentStreamEvent("turn_completed"),
-    gate.waitForHeldAgentUpdate(agent.agentId, "idle"),
-  ]);
-  await expect(page.getByTestId("turn-working-indicator")).toBeVisible();
-  await recordPaintsFor(page, 200);
-
-  if (input.reply !== null) gate.releaseHeldAgentStreamItem("assistant_message");
-  gate.releaseHeldAgentStreamEvent("turn_completed");
-  gate.releaseHeldAgentUpdate(agent.agentId, "idle");
-  gate.setServerMessageSuppressed("agent_update", false);
-  await expectAgentIdle(page);
-  await recordPaintsFor(page, 300);
-  return stopRecording(page);
-}
-
-function describeFrames(frames: TurnEndFrame[]): string {
-  return frames
-    .map(
-      (frame, index) =>
-        `${index}: ${frame.running ? "running " : "complete"} footer=${
-          frame.footer ? `${frame.footer.top.toFixed(1)}+${frame.footer.height.toFixed(1)}` : "none"
-        } timer=${frame.elapsed ?? "none"} prompt=${frame.userRow?.top.toFixed(1) ?? "none"} reply=${frame.replyVisible}`,
-    )
-    .join("\n");
-}
-
-function expectSteadyTurnEnd(frames: TurnEndFrame[], input: { reply: string | null }): void {
-  const firstRunning = frames.findIndex((frame) => frame.running && frame.footer !== null);
-  const firstComplete = frames.findIndex((frame, index) => index > firstRunning && !frame.running);
-  const record = `frames:\n${describeFrames(frames)}`;
-  expect(firstRunning, record).toBeGreaterThanOrEqual(0);
-  expect(firstComplete, record).toBeGreaterThan(firstRunning);
-
-  const transition = frames.slice(firstRunning);
-  const runningHeight = transition[0].footer?.height;
-  expect(
-    transition.map((frame) => frame.footer?.height ?? null),
-    `the footer must stay painted at one height\n${record}`,
-  ).toEqual(transition.map(() => runningHeight));
-  if (input.reply !== null) {
-    expect(
-      frames.slice(firstComplete).every((frame) => frame.replyVisible),
-      `a completed turn must show its reply in the same frame\n${record}`,
-    ).toBe(true);
-  }
-  // Tool rows land while the turn runs; only the turn end itself must be one step.
-  const ending = frames.slice(firstComplete - 1);
-  const promptMoves = ending
-    .slice(1)
-    .filter((frame, index) => frame.userRow?.top !== ending[index].userRow?.top);
-  expect(
-    promptMoves.length,
-    `the prompt must move at most once as the turn ends\n${record}`,
-  ).toBeLessThanOrEqual(1);
-}
-
-interface ReturnedTurn {
-  frames: TurnEndFrame[];
-  reconnectedAt: number;
-  finalReplyLength: number;
-}
-
-// The agent finishes while the socket is down, then the catch-up is held so the idle status
-// reaches the chat first. Painted frames are sampled from the running footer until everything
-// has settled.
-async function returnAfterTurnFinished(input: {
-  page: Page;
-  agent: MockAgentWorkspace;
-  prompt: string;
-  leaveWhile: (gate: DaemonWebSocketGate) => Promise<void>;
-}): Promise<ReturnedTurn> {
-  const { page, agent, prompt, leaveWhile } = input;
-  const gate = await installDaemonWebSocketGate(page);
-  await openAgentRoute(page, { workspaceId: agent.workspaceId, agentId: agent.agentId });
-  await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeVisible();
-
-  await recordTurnEndFrames(page, { prompt, reply: "" });
-  await leaveWhile(gate);
-  gate.holdTimelineResponses(agent.agentId);
-  const reconnectedAt = await page.evaluate(() => performance.now());
-  gate.restore();
-  await gate.waitForHeldTimelineResponse();
-  await expectAgentIdle(page);
-
-  await recordPaintsFor(page, 2_000);
-  gate.releaseHeldTimelineResponses();
-  await expect(page.getByTestId("turn-working-indicator")).toHaveCount(0);
-  await expect(page.getByTestId("turn-footer").last()).toBeVisible();
-  await recordPaintsFor(page, 500);
-  const frames = await stopRecording(page);
-  return { frames, reconnectedAt, finalReplyLength: frames.at(-1)?.replyLength ?? 0 };
-}
-
-type DaemonWebSocketGate = Awaited<ReturnType<typeof installDaemonWebSocketGate>>;
-
-async function leaveWithOnlyThePromptOnScreen(
-  page: Page,
-  agent: MockAgentWorkspace,
-  gate: DaemonWebSocketGate,
-  prompt: string,
-): Promise<void> {
-  gate.setAgentStreamItemSuppressed("assistant_message", true);
-  gate.holdNextAgentStreamEvent("turn_completed");
-  gate.holdNextAgentUpdate(agent.agentId, "idle");
-  gate.setServerMessageSuppressed("agent_update", true);
-  await submitMessage(page, prompt);
-  await Promise.all([
-    gate.waitForHeldAgentStreamEvent("turn_completed"),
-    gate.waitForHeldAgentUpdate(agent.agentId, "idle"),
-  ]);
-  await expect(page.getByTestId("turn-working-indicator")).toBeVisible();
-  await gate.drop();
-  await agent.client.waitForFinish(agent.agentId, 15_000);
-  gate.setAgentStreamItemSuppressed("assistant_message", false);
-  gate.setServerMessageSuppressed("agent_update", false);
-}
-
-async function leaveWithAPartialReplyOnScreen(
-  page: Page,
-  agent: MockAgentWorkspace,
-  gate: DaemonWebSocketGate,
-  prompt: string,
-): Promise<void> {
-  await agent.client.sendAgentMessage(agent.agentId, prompt);
-  await expect(page.getByTestId("turn-working-indicator")).toBeVisible();
-  await expect(page.getByTestId("assistant-message").first()).toBeVisible();
-  await gate.drop();
-  await agent.client.waitForFinish(agent.agentId, 30_000);
-}
-
-function elapsedSeconds(frame: TurnEndFrame): number {
-  const units: Record<string, number> = { h: 3600, m: 60, s: 1 };
-  return [...(frame.elapsed ?? "").matchAll(/(\d+)([hms])/g)].reduce(
-    (total, [, value, unit]) => total + Number(value) * units[unit],
-    0,
-  );
-}
-
-function expectFooterUnchangedUntilMessagesLand(
-  { frames, reconnectedAt }: ReturnedTurn,
-  record: string,
-): void {
-  const held = frames.slice(
-    frames.findIndex((frame) => frame.at >= reconnectedAt),
-    frames.findIndex((frame) => frame.at >= reconnectedAt && !frame.running),
-  );
-  expect(
-    held.length,
-    `the running footer must hold until the messages land\n${record}`,
-  ).toBeGreaterThan(0);
-  expect(
-    new Set(held.map((frame) => `${frame.footer?.top}+${frame.footer?.height}`)).size,
-    `the held footer must not move or resize\n${record}`,
-  ).toBe(1);
-  expect(
-    new Set(held.map((frame) => frame.footerText)).size,
-    `the held footer's content must not change\n${record}`,
-  ).toBe(1);
-  expect(
-    held.filter((frame) => frame.elapsed === null).map((frame) => frame.at),
-    `the timer must stay on screen\n${record}`,
-  ).toEqual([]);
-  const seconds = held.map(elapsedSeconds);
-  expect(seconds, `the timer must keep counting up\n${record}`).toEqual(
-    seconds.toSorted((left, right) => left - right),
-  );
-}
-
-function expectReturnLandsWhole(returned: ReturnedTurn): void {
-  const { frames, finalReplyLength } = returned;
-  const record = `frames:\n${describeFrames(frames)}`;
-  const firstRunning = frames.findIndex((frame) => frame.running && frame.footer !== null);
-  expect(firstRunning, record).toBeGreaterThanOrEqual(0);
-  const fromRunning = frames.slice(firstRunning);
-
-  expect(
-    fromRunning.filter((frame) => frame.footer === null).map((frame) => frame.at),
-    `the footer must never disappear\n${record}`,
-  ).toEqual([]);
-
-  const completed = fromRunning.filter((frame) => !frame.running);
-  expect(completed.length, record).toBeGreaterThan(0);
-  // The first Markdown on a page paints an empty row until the web parser loads. Only text that
-  // is present and short of the final reply is stale.
-  expect(
-    completed
-      .filter((frame) => frame.replyLength > 0 && frame.replyLength !== finalReplyLength)
-      .map((frame) => frame.at),
-    `a completed footer must never sit under stale messages\n${record}`,
-  ).toEqual([]);
-
-  expectFooterUnchangedUntilMessagesLand(returned, record);
-}
-
-async function withFirstTurnAgent(
-  model: string,
-  run: (agent: MockAgentWorkspace) => Promise<void>,
-): Promise<void> {
-  const agent = await seedMockAgentWorkspace({
-    repoPrefix: "turn-return-",
-    title: "Turn return",
-    model,
-  });
-  try {
-    await run(agent);
-  } finally {
-    await agent.cleanup();
-  }
-}
-
-test.describe("Returning to a turn that finished while away", () => {
-  test("keeps the running footer until the messages land when only the prompt was on screen", async ({
-    page,
-  }) => {
-    await withFirstTurnAgent("e2e-fast-stream", async (agent) => {
-      const prompt = "emit 1 coalesced agent stream updates";
-      const returned = await returnAfterTurnFinished({
-        page,
-        agent,
-        prompt,
-        leaveWhile: (gate) => leaveWithOnlyThePromptOnScreen(page, agent, gate, prompt),
-      });
-      expectReturnLandsWhole(returned);
-    });
-  });
-
-  test("keeps the running footer until the messages land under a partial reply", async ({
-    page,
-  }) => {
-    await withFirstTurnAgent("ten-second-stream", async (agent) => {
-      const prompt = "Return partial prompt";
-      const returned = await returnAfterTurnFinished({
-        page,
-        agent,
-        prompt,
-        leaveWhile: (gate) => leaveWithAPartialReplyOnScreen(page, agent, gate, prompt),
-      });
-      expectReturnLandsWhole(returned);
-    });
-  });
-});
-
-test.describe("Turn end", () => {
-  test("ends a plain reply without moving or dropping its footer", async ({ page, agent }) => {
-    const input = { prompt: "emit 1 coalesced agent stream updates", reply: "stress-update-0" };
-    expectSteadyTurnEnd(await recordTurnEnd(page, agent, input), input);
-  });
-
-  test("ends a tool turn with its reply and completed footer together", async ({ page, agent }) => {
-    const input = { prompt: "emit 3 tool agent stream updates", reply: "Completed 3 commands" };
-    expectSteadyTurnEnd(await recordTurnEnd(page, agent, input), input);
-  });
-
-  test("keeps the footer height when a turn ends on a tool call", async ({ page, agent }) => {
-    const input = { prompt: "emit 2 tool agent stream updates", reply: null };
-    expectSteadyTurnEnd(await recordTurnEnd(page, agent, input), input);
-  });
-});
-
-async function expectTimingInsideFooter(page: Page): Promise<void> {
-  const label = page.getByRole("button", { name: /^Worked for/ }).last();
-  const paintedLines = await label.getByTestId("turn-footer-timing-label").evaluate((element) => {
-    const labelBounds = element.parentElement!.getBoundingClientRect();
-    const rowBounds = element.closest('[data-testid="turn-footer"]')!.getBoundingClientRect();
-    const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
-    const lines: boolean[] = [];
-    while (walker.nextNode()) {
-      const range = document.createRange();
-      range.selectNodeContents(walker.currentNode);
-      for (const rect of range.getClientRects()) {
-        lines.push(
-          rect.left >= Math.max(rowBounds.left, labelBounds.left) - 0.5 &&
-            rect.right <= Math.min(rowBounds.right, labelBounds.right) + 0.5 &&
-            rect.top >= Math.max(rowBounds.top, labelBounds.top) - 0.5 &&
-            rect.bottom <= Math.min(rowBounds.bottom, labelBounds.bottom) + 0.5,
-        );
-      }
-    }
-    return lines;
-  });
-  expect(paintedLines.length).toBeGreaterThan(0);
-  expect(paintedLines.every(Boolean)).toBe(true);
-}
-
-async function expectFooterWithinWidth(page: Page, width: number): Promise<void> {
-  const footer = page.getByTestId("turn-footer").last();
-  await footer.evaluate((element, availableWidth) => {
-    element.style.width = `${availableWidth}px`;
-  }, width);
-  const label = page.getByRole("button", { name: /^Worked for/ }).last();
-  await expect(label).toBeVisible();
-  await expectTimingInsideFooter(page);
-  const controls = footer.getByRole("button", { name: /Copy turn|Fork chat/ });
-  const before = await controls.evaluateAll((elements) =>
-    elements.map((element) => {
-      const rect = element.getBoundingClientRect();
-      return { x: rect.x, y: rect.y };
-    }),
-  );
-  const footerBefore = await footer.boundingBox();
-  const labelBefore = await label.boundingBox();
-  await label.hover({ position: { x: labelBefore!.width - 2, y: labelBefore!.height - 2 } });
-  await expect(label.getByTestId("turn-footer-timing-label")).toContainText(/\d:\d\d/);
-  expect(await label.boundingBox()).toMatchObject({
-    x: labelBefore!.x,
-    width: labelBefore!.width,
-    height: labelBefore!.height,
-  });
-  expect(
-    await controls.evaluateAll((elements) =>
-      elements.map((element) => {
-        const rect = element.getBoundingClientRect();
-        return { x: rect.x, y: rect.y };
-      }),
-    ),
-  ).toEqual(before);
-  expect(await footer.boundingBox()).toMatchObject({
-    x: footerBefore!.x,
-    y: footerBefore!.y,
-    width: footerBefore!.width,
-  });
-  await expectTimingInsideFooter(page);
-  await page.mouse.move(0, 0);
-  await expect(label.getByTestId("turn-footer-timing-label")).toContainText("Worked for");
-}
-
-test("footer timing fits the chat column and swapping labels keeps controls in place", async ({
-  page,
-  agent,
-}) => {
-  await openAgentRoute(page, agent);
-  await expectFooterWithinWidth(page, 140);
-  await expectFooterWithinWidth(page, 150);
-  await expectFooterWithinWidth(page, 300);
-  await expectFooterWithinWidth(page, 880);
-});
-
-async function visibleFooterLeftEdges(page: Page): Promise<number[]> {
-  return page.evaluate(() => {
-    const viewport = Array.from(
-      document.querySelectorAll('[data-testid="agent-chat-scroll"]'),
-    ).find((candidate) => candidate.checkVisibility());
-    return Array.from(viewport?.querySelectorAll('[data-testid="turn-footer"]') ?? [])
-      .filter((footer) => footer.checkVisibility())
-      .map((footer) => Math.round(footer.getBoundingClientRect().left));
-  });
-}
-
-async function expectFootersInOneColumn(page: Page): Promise<void> {
-  await expect
-    .poll(async () => {
-      const edges = await visibleFooterLeftEdges(page);
-      return edges.length >= 2 && new Set(edges).size === 1 ? "one column" : edges;
-    })
-    .toBe("one column");
-}
-
-test("keeps the latest turn's footer in the chat column while it runs and after it ends", async ({
-  page,
-  agent,
-}) => {
-  // Wider than the chat's max width, so the column is centered with space on both sides.
-  await page.setViewportSize({ width: 1600, height: 1000 });
-  const gate = await installDaemonWebSocketGate(page);
-  await openAgentRoute(page, agent);
-  await expectAgentIdle(page);
-
-  gate.holdNextAgentStreamEvent("turn_completed");
-  gate.holdNextAgentUpdate(agent.agentId, "idle");
-  gate.setServerMessageSuppressed("agent_update", true);
-  await submitMessage(page, "emit 1 coalesced agent stream updates");
-  await Promise.all([
-    gate.waitForHeldAgentStreamEvent("turn_completed"),
-    gate.waitForHeldAgentUpdate(agent.agentId, "idle"),
-  ]);
-  await expect(page.getByTestId("turn-working-indicator")).toBeVisible();
-  await expectFootersInOneColumn(page);
-
-  gate.releaseHeldAgentStreamEvent("turn_completed");
-  gate.releaseHeldAgentUpdate(agent.agentId, "idle");
-  gate.setServerMessageSuppressed("agent_update", false);
-  await expectAgentIdle(page);
-  await expect(page.getByTestId("turn-working-indicator")).toHaveCount(0);
-  await expectFootersInOneColumn(page);
-});

packages/app/e2e/browser/appearance-font-family.spec.ts

@@ -13,30 +13,25 @@ async function setFontFamily(page: Page, name: string, family: string) {
   await input.press("Tab");
 }
 
-test("keeps settings usable while editing code and interface font families", async ({
-  page,
-}, testInfo) => {
-  await openAppearance(page);
+for (const name of ["Code font family", "Interface font family"]) {
+  test(`keeps settings usable after an unfinished quote in ${name}`, async ({ page }, testInfo) => {
+    await openAppearance(page);
+    await setFontFamily(page, name, "'Fira Code', monospace");
+    await expect(page.getByRole("textbox", { name })).toHaveValue("'Fira Code', monospace");
 
-  for (const name of ["Code font family", "Interface font family"]) {
-    await test.step(`reject an unfinished quote in ${name} and restore the default`, async () => {
-      await setFontFamily(page, name, "'Fira Code', monospace");
-      await expect(page.getByRole("textbox", { name })).toHaveValue("'Fira Code', monospace");
+    await setFontFamily(page, name, "'foo");
+    await expect(page.getByRole("textbox", { name })).toHaveValue("'Fira Code', monospace");
+    await expect(page.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport();
+    await expect(page.getByText("Theme", { exact: true }).first()).toHaveCSS("font-size", "12px");
 
-      await setFontFamily(page, name, "'foo");
-      await expect(page.getByRole("textbox", { name })).toHaveValue("'Fira Code', monospace");
-      await expect(page.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport();
-      await expect(page.getByText("Theme", { exact: true }).first()).toHaveCSS("font-size", "12px");
-
-      await page.screenshot({ path: testInfo.outputPath(`rejected-${name}.png`) });
-      await page.reload();
-      await expect(page.getByRole("textbox", { name })).toHaveValue("'Fira Code', monospace");
-      await expect(page.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport();
-      await setFontFamily(page, name, "");
-      await expect(page.getByRole("textbox", { name })).toHaveValue("");
-    });
-  }
-});
+    await page.screenshot({ path: testInfo.outputPath("rejected-font.png") });
+    await page.reload();
+    await expect(page.getByRole("textbox", { name })).toHaveValue("'Fira Code', monospace");
+    await expect(page.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport();
+    await setFontFamily(page, name, "");
+    await expect(page.getByRole("textbox", { name })).toHaveValue("");
+  });
+}
 
 test("opens settings with defaults when a malformed font was already saved", async ({ page }) => {
   await page.addInitScript(() => {

packages/app/e2e/browser/archive-tab.spec.ts

@@ -6,7 +6,6 @@ import { connectSeedClient } from "../support/helpers/seed-client";
 import { createTempGitRepo } from "../support/helpers/workspace";
 import { buildHostWorkspaceRoute } from "@/utils/host-routes";
 import {
-  closeActiveAgentWithShortcut,
   archiveAgentFromDaemon,
   archiveAgentFromSessions,
   clickSessionRow,
@@ -21,12 +20,8 @@ import {
   openWorkspaceWithAgents,
   primeAdditionalPage,
   resetSeededPageState,
-  unarchiveAgentFromConversation,
   reloadWorkspace,
 } from "../support/helpers/archive-tab";
-import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
-import { expectComposerDraft, fillComposerDraft, submitMessage } from "../support/helpers/composer";
-import { awaitAssistantMessage, expectAgentIdle } from "../support/helpers/agent-stream";
 import { expectAgentTabActive } from "../support/helpers/launcher";
 
 test.describe("Archive tab reconciliation", () => {
@@ -56,34 +51,6 @@ test.describe("Archive tab reconciliation", () => {
     await tempRepo?.cleanup();
   });
 
-  test("restoring a closed agent retains its unsent composer draft after reload", async ({
-    page,
-  }) => {
-    const agent = await seedMockAgentWorkspace({
-      repoPrefix: "archived-composer-",
-      title: "Restore unsent draft",
-    });
-    try {
-      await openAgentRoute(page, agent);
-      await submitMessage(page, "A completed conversation before closing");
-      await awaitAssistantMessage(page);
-      await expectAgentIdle(page);
-      await fillComposerDraft(page, "Keep this unsent message after closing");
-      await expectComposerDraft(page, "Keep this unsent message after closing");
-      await closeActiveAgentWithShortcut(page, agent.agentId);
-      await expect.poll(() => fetchAgentArchivedAt(agent.client, agent.agentId)).not.toBeNull();
-      await page.reload();
-      await openSessions(page);
-      await expectSessionRowArchived(page, "Restore unsent draft");
-      await clickSessionRow(page, "Restore unsent draft");
-      await expectArchivedAgentFocused(page, agent.agentId);
-      await unarchiveAgentFromConversation(page);
-      await expectComposerDraft(page, "Keep this unsent message after closing");
-    } finally {
-      await agent.cleanup();
-    }
-  });
-
   test("non-UI archive prunes the archived tab across open pages and reload", async ({ page }) => {
     const archived = await createIdleAgent(client, {
       cwd: tempRepo.path,

packages/app/e2e/browser/assistant-selection-copy.spec.ts

@@ -723,46 +723,3 @@ test("copying a selection across an assistant image keeps its Markdown source an
     await agent.cleanup();
   }
 });
-
-test.describe("on a touch-capable desktop browser", () => {
-  // A touch screen registers the navigation pan's pointer listeners over the whole workspace.
-  // The pan accepts touch only, and a mouse drag must still extend the browser's selection.
-  test.use({ hasTouch: true });
-
-  test("a mouse drag selects across assistant paragraphs", async ({ page }) => {
-    const agent = await seedMockAgentWorkspace({
-      repoPrefix: "assistant-selection-drag-",
-      title: "Assistant selection drag",
-      initialPrompt: "Render three paragraphs.",
-      featureValues: {
-        mockAssistantResponse: "First paragraph.\n\nSecond paragraph.\n\nThird paragraph.",
-      },
-    });
-
-    try {
-      await agent.client.waitForAgentUpsert(
-        agent.agentId,
-        (snapshot) => snapshot.status === "idle",
-        30_000,
-      );
-      await openAgentRoute(page, agent);
-      const blocks = assistantMessageBlocks(page);
-      const first = await blocks.getByText("First paragraph.").boundingBox();
-      const third = await blocks.getByText("Third paragraph.").boundingBox();
-      if (!first || !third) {
-        throw new Error("Expected rendered paragraphs");
-      }
-
-      await page.mouse.move(first.x + 1, first.y + first.height / 2);
-      await page.mouse.down();
-      await page.mouse.move(third.x + third.width - 1, third.y + third.height / 2, { steps: 20 });
-      await page.mouse.up();
-
-      const selected = await page.evaluate(() => window.getSelection()?.toString() ?? "");
-      expect(selected).toContain("First paragraph.");
-      expect(selected).toContain("Third paragraph.");
-    } finally {
-      await agent.cleanup();
-    }
-  });
-});

packages/app/e2e/browser/background-reconnect.spec.ts

@@ -5,7 +5,6 @@ import {
   type IsolatedHostDaemon,
 } from "../support/helpers/isolated-host-daemon";
 import { seedSavedSettingsHosts } from "../support/helpers/settings";
-import { setTabVisibility } from "../support/helpers/workspace-ui";
 
 const test = base.extend<{ reconnectHost: IsolatedHostDaemon }>({
   reconnectHost: async ({ e2eWorker }, provide) => {
@@ -38,6 +37,17 @@ async function refocusConnectedTab(page: Page): Promise<void> {
   await expect(page.getByText("Online", { exact: true })).toBeVisible();
 }
 
+async function setTabVisibility(page: Page, visibility: DocumentVisibilityState): Promise<void> {
+  await page.evaluate((state) => {
+    Object.defineProperty(document, "visibilityState", { configurable: true, get: () => state });
+    Object.defineProperty(document, "hidden", {
+      configurable: true,
+      get: () => state === "hidden",
+    });
+    document.dispatchEvent(new Event("visibilitychange"));
+  }, visibility);
+}
+
 async function openHostOverview(page: Page, daemon: IsolatedHostDaemon): Promise<void> {
   await page.goto("/");
   await seedSavedSettingsHosts(page, [

packages/app/e2e/browser/branch-switcher.spec.ts

@@ -1,7 +1,4 @@
-import { writeFile, unlink } from "node:fs/promises";
-import path from "node:path";
 import { expect, test, type Page } from "../support/fixtures";
-import { daemonWsRoutePattern } from "../support/helpers/daemon-port";
 import { gotoAppShell } from "../support/helpers/app";
 import {
   expectNoBranchSwitcherInWorkspaceHeader,
@@ -17,95 +14,6 @@ import {
   waitForSidebarHydration,
 } from "../support/helpers/workspace-ui";
 
-// Hold the real daemon response until the test has observed the pending UI.
-async function holdBranchSuggestions(page: Page) {
-  let requestCount = 0;
-  let release!: () => void;
-  let gate = new Promise<void>((resolve) => {
-    release = resolve;
-  });
-  await page.routeWebSocket(daemonWsRoutePattern(), (browser) => {
-    const server = browser.connectToServer();
-    browser.onMessage((message) => {
-      if (typeof message === "string") {
-        const envelope = JSON.parse(message);
-        if (envelope.type === "session" && envelope.message?.type === "branch_suggestions_request")
-          requestCount++;
-      }
-      server.send(message);
-    });
-    server.onMessage(async (message) => {
-      if (typeof message === "string") {
-        const envelope = JSON.parse(message);
-        if (
-          envelope.type === "session" &&
-          envelope.message?.type === "branch_suggestions_response"
-        ) {
-          await gate;
-        }
-      }
-      browser.send(message);
-    });
-  });
-  return {
-    release: () => release(),
-    holdNextResponse: () => {
-      gate = new Promise<void>((resolve) => {
-        release = resolve;
-      });
-    },
-    requestCount: () => requestCount,
-  };
-}
-
-async function expectInitialBranchLoading(page: Page, release: () => void): Promise<void> {
-  await page.getByRole("button", { name: "Current branch: main. Press to switch branch." }).click();
-  const picker = page.getByTestId("combobox-desktop-container");
-  await expect(picker.getByText("Loading...", { exact: true })).toBeVisible();
-  await expect(picker.getByText("No branches found.", { exact: true })).toHaveCount(0);
-  release();
-  await expect(picker.getByText("dev", { exact: true })).toBeVisible();
-  await page.keyboard.press("Escape");
-  await expect(picker).not.toBeVisible();
-}
-
-async function expectFailedRefreshRecovery(
-  page: Page,
-  repoPath: string,
-  responses: Awaited<ReturnType<typeof holdBranchSuggestions>>,
-) {
-  // Expire the actual query freshness window before reopening the cached picker.
-  const started = Date.now();
-  await expect.poll(() => Date.now() - started, { timeout: 20_000 }).toBeGreaterThan(15_000);
-  const picker = page.getByTestId("combobox-desktop-container");
-  const packedRefs = path.join(repoPath, ".git", "packed-refs");
-  await writeFile(packedRefs, "invalid packed refs\n");
-  try {
-    await page
-      .getByRole("button", { name: "Current branch: dev. Press to switch branch." })
-      .click();
-    await expect(picker.getByRole("alert")).toHaveText(
-      "Could not load branches. Reopen the picker to try again.",
-    );
-  } finally {
-    await unlink(packedRefs);
-  }
-  await expect(picker.getByText("No branches found.", { exact: true })).toHaveCount(0);
-  responses.holdNextResponse();
-  const beforeRetry = responses.requestCount();
-  await page.keyboard.press("Escape");
-  await page.getByRole("button", { name: "Current branch: dev. Press to switch branch." }).click();
-  await expect(picker.getByRole("alert")).toHaveText("Loading...");
-  await expect.poll(responses.requestCount).toBe(beforeRetry + 1);
-  await expect(picker).toBeVisible();
-  responses.release();
-  await expect(picker.getByRole("alert")).toHaveCount(0);
-  await expect(picker.getByText("main", { exact: true })).toBeVisible();
-  await page.keyboard.press("Escape");
-  await expectWorkspaceBranch(page, "dev");
-  expect(responses.requestCount()).toBe(beforeRetry + 1);
-}
-
 async function renameWorkspaceViaSidebar(
   page: Page,
   input: { workspaceId: string; title: string },
@@ -151,7 +59,6 @@ test.describe("Branch switcher", () => {
     try {
       expect(workspace.workspaceName).toBe("main");
 
-      const releaseBranches = await holdBranchSuggestions(page);
       await gotoAppShell(page);
       await waitForSidebarHydration(page);
       await switchWorkspaceViaSidebar({ page, serverId, workspaceId: workspace.workspaceId });
@@ -175,10 +82,8 @@ test.describe("Branch switcher", () => {
       // and switching it checks out the real branch on disk.
       await openChangesPanel(page);
       await expectWorkspaceBranch(page, "main");
-      await expectInitialBranchLoading(page, releaseBranches.release);
       await switchBranchFromChangesPanel(page, { from: "main", to: "dev" });
       await expectWorkspaceBranch(page, "dev");
-      await expectFailedRefreshRecovery(page, workspace.repoPath, releaseBranches);
 
       // The custom title is unaffected by the branch switch.
       await expect(headerTitle).toHaveText(customTitle, { timeout: 30_000 });

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

@@ -8,11 +8,7 @@ import { daemonWsRoutePattern } from "../support/helpers/daemon-port";
 import { getServerId } from "../support/helpers/server-id";
 import { connectSeedClient } from "../support/helpers/seed-client";
 import { createTempGitRepo } from "../support/helpers/workspace";
-import {
-  openChangesPanel,
-  openChangesTreePanel,
-  waitForWorkspaceTabsVisible,
-} from "../support/helpers/workspace-tabs";
+import { openChangesPanel, waitForWorkspaceTabsVisible } from "../support/helpers/workspace-tabs";
 
 interface DirtyWorkspace {
   id: string;
@@ -266,126 +262,6 @@ test.afterEach(async () => {
   }
 });
 
-test("Changes without a comparison base explains how to view pending changes", async ({ page }) => {
-  const workspace = await createWorkspaceWithManyTinyDiffs(2, "dev");
-  await openWorkspaceChangesTree(page, workspace);
-  await expect(
-    page.getByText("Comparison base is unavailable. Select Uncommitted to view pending changes."),
-  ).toBeVisible();
-  await selectChangesComparison(page, "Uncommitted");
-  await expect(changesTree(page).getByText("file-0000.ts", { exact: true })).toBeVisible();
-});
-async function openWorkspaceChangesTree(page: Page, workspace: DirtyWorkspace): Promise<void> {
-  await page.setViewportSize({ width: 1400, height: 900 });
-  await page.goto(buildHostWorkspaceRoute(getServerId(), workspace.id));
-  await waitForWorkspaceTabsVisible(page);
-  await openChangesTreePanel(page);
-}
-
-test("streamed Changes shows the tree before completion and applies a one-file refresh", async ({
-  page,
-}, testInfo) => {
-  test.setTimeout(120_000);
-  const workspace = await createLargeStreamedWorkspace();
-  await addOversizedSibling(workspace);
-  const stream = await holdDiffCompletion(page);
-  await openWorkspaceChangesSurface(page, workspace, 90_000);
-  await expectAnnouncedTreeAndLoader(page);
-  await page.screenshot({ path: testInfo.outputPath("tree-loading.png") });
-  stream.finish();
-  await expect.poll(() => stream.completed, { timeout: 60_000 }).toBeGreaterThan(0);
-  await expect(page.getByRole("progressbar", { name: "Loading..." })).toHaveCount(0);
-  const connections = stream.connections;
-  const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
-  await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName("src/file-0000.ts, +90, -1");
-  await addOneLineToFirstFile(workspace);
-  await expect.poll(() => stream.changedBodies.at(-1), { timeout: 30_000 }).toBe(1);
-  await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName("src/file-0000.ts, +91, -1");
-  await expect(page.getByRole("progressbar", { name: "Loading..." })).toHaveCount(0);
-  expect(stream.connections).toBe(connections);
-  await page.screenshot({ path: testInfo.outputPath("refreshed.png") });
-});
-
-async function createLargeStreamedWorkspace(): Promise<DirtyWorkspace> {
-  const workspace = await createWorkspaceWithManyTinyDiffs(252);
-  await Promise.all(
-    Array.from({ length: 252 }, (_, file) =>
-      writeFile(
-        path.join(workspace.repoPath, `src/file-${String(file).padStart(4, "0")}.ts`),
-        Array.from(
-          { length: 90 },
-          (_unused, line) =>
-            `export const fn${line} = (param: string) => ({ key: param, value: ${file} });`,
-        ).join("\n") + "\n",
-      ),
-    ),
-  );
-  return workspace;
-}
-async function addOversizedSibling(workspace: DirtyWorkspace): Promise<void> {
-  await writeFile(path.join(workspace.repoPath, "zz-too-large.txt"), "x".repeat(1024 * 1024 + 1));
-}
-async function addOneLineToFirstFile(workspace: DirtyWorkspace): Promise<void> {
-  const file = path.join(workspace.repoPath, "src/file-0000.ts");
-  await writeFile(file, (await readFile(file, "utf8")) + "export const refreshed = true;\n");
-}
-async function holdDiffCompletion(page: Page) {
-  const { decodeDiffFrame, DiffOpcode } = await import("@getpaseo/protocol/binary-frames/index");
-  let holding = true;
-  let connections = 0;
-  let completed = 0;
-  const completions: Array<() => void> = [];
-  const changedBodies: number[] = [];
-  const bodyCounts = new Map<number, number>();
-  await page.routeWebSocket(daemonWsRoutePattern(), (browserSocket) => {
-    connections++;
-    const serverSocket = browserSocket.connectToServer();
-    browserSocket.onMessage((message) => serverSocket.send(message));
-    serverSocket.onMessage((message) => {
-      if (
-        typeof message !== "string" &&
-        message[0] >= DiffOpcode.Begin &&
-        message[0] <= DiffOpcode.End
-      ) {
-        const frame = decodeDiffFrame(message);
-        if (frame.opcode === DiffOpcode.Begin) bodyCounts.set(frame.slot, 0);
-        else if (frame.opcode === DiffOpcode.Bodies)
-          bodyCounts.set(frame.slot, (bodyCounts.get(frame.slot) ?? 0) + frame.files.length);
-        else {
-          completed++;
-          changedBodies.push(bodyCounts.get(frame.slot) ?? 0);
-        }
-      }
-      if (holding && typeof message !== "string" && message[0] === DiffOpcode.End) {
-        completions.push(() => browserSocket.send(message));
-        return;
-      }
-      browserSocket.send(message);
-    });
-  });
-  return {
-    changedBodies,
-    get connections() {
-      return connections;
-    },
-    get completed() {
-      return completed;
-    },
-    finish: () => {
-      holding = false;
-      completions.splice(0).forEach((send) => send());
-    },
-  };
-}
-async function expectWorkingDiffLoaded(page: Page, timeout: number): Promise<void> {
-  const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
-  await expect(panel.getByTestId("diff-file-0")).toBeAttached({ timeout });
-}
-async function expectAnnouncedTreeAndLoader(page: Page): Promise<void> {
-  await expect(changesTree(page).first()).toBeVisible();
-  await expect(page.getByRole("progressbar", { name: "Loading..." }).first()).toBeVisible();
-}
-
 test("Changes opens All changes for a clean checkout", async ({ page }) => {
   const workspace = await createWorkspaceWithCommittedDiff();
 
@@ -447,119 +323,6 @@ test("All changes combines committed and pending edits and preserves an unfinish
   });
 });
 
-test("Changes selects exact local and remote bases and retains the selection after reload", async ({
-  page,
-}, testInfo) => {
-  const workspace = await createWorktreeWithCommittedDiff();
-  execFileSync("git", ["branch", "release"], { cwd: workspace.repoPath });
-  execFileSync("git", ["update-ref", "refs/remotes/upstream/release", "main"], {
-    cwd: workspace.repoPath,
-  });
-  const head = execFileSync("git", ["rev-parse", "HEAD"], { cwd: workspace.repoPath }).toString();
-  await openWorkspaceChangesSurface(page, workspace);
-  const tree = page.getByTestId("changes-tree-panel").filter({ visible: true });
-  const picker = tree.getByTestId("workspace-base-branch-trigger");
-  await expect(picker).toBeVisible();
-  await picker.click();
-  await expect(page.getByRole("button", { name: "release", exact: true })).toBeVisible();
-  await page.screenshot({ path: testInfo.outputPath("base-picker.png") });
-  await page.getByRole("button", { name: "release", exact: true }).click();
-  await expect(picker).toContainText("release");
-  await expect(tree.getByText("No changes to display", { exact: true })).toBeVisible();
-  await picker.click();
-  await page.getByRole("button", { name: "upstream/release", exact: true }).click();
-  await expect(picker).toContainText("upstream/release");
-  await expect(tree.getByText("committed-only.ts", { exact: true })).toBeVisible();
-  await page.screenshot({ path: testInfo.outputPath("base-selected.png") });
-  await page.reload();
-  await waitForWorkspaceTabsVisible(page);
-  await expect(picker).toContainText("upstream/release");
-  expect(execFileSync("git", ["rev-parse", "HEAD"], { cwd: workspace.repoPath }).toString()).toBe(
-    head,
-  );
-});
-
-test("Changes lets a compact workspace change its base in a sheet", async ({ page }, testInfo) => {
-  const workspace = await createWorktreeWithCommittedDiff();
-  execFileSync("git", ["branch", "release"], { cwd: workspace.repoPath });
-  await openCompactChanges(page, workspace);
-  const picker = page.getByRole("button", { name: "Change base" }).filter({ visible: true });
-  await picker.click();
-  await expect(page.getByText("Change base", { exact: true })).toBeVisible();
-  const release = page.getByRole("button", { name: "release", exact: true });
-  await expect(release).toBeVisible();
-  await page.screenshot({ path: testInfo.outputPath("compact-base-picker.png") });
-  await release.click();
-  await expect(picker).toContainText("release");
-  await page.screenshot({ path: testInfo.outputPath("compact-base-selected.png") });
-});
-
-test("Changes shows a failed base selection and lets the user retry", async ({ page }) => {
-  const workspace = await createWorktreeWithCommittedDiff();
-  execFileSync("git", ["branch", "release"], { cwd: workspace.repoPath });
-  await openWorkspaceChangesSurface(page, workspace);
-  const picker = page
-    .getByTestId("workspace-base-branch-trigger")
-    .filter({ visible: true })
-    .first();
-  await picker.click();
-  const option = page.getByRole("button", { name: "release", exact: true });
-  await expect(option).toBeVisible();
-  execFileSync("git", ["branch", "-D", "release"], { cwd: workspace.repoPath });
-  await option.click();
-  await expect(page.getByTestId("workspace-base-branch-error")).toContainText(
-    "Base branch not found",
-  );
-  await expect(picker).toContainText("main");
-  execFileSync("git", ["branch", "release"], { cwd: workspace.repoPath });
-  await option.click();
-  await expect(page.getByTestId("workspace-base-branch-error")).toHaveCount(0);
-  await expect(picker).toContainText("release");
-});
-
-test("Changes shows the base as text on a host without the base-branch capability", async ({
-  page,
-}) => {
-  let baseRequests = 0;
-  await page.routeWebSocket(daemonWsRoutePattern(), (browser) => {
-    const server = browser.connectToServer();
-    browser.onMessage((frame) => {
-      if (typeof frame === "string") {
-        const envelope = JSON.parse(frame) as { message?: { type?: string } };
-        if (envelope.message?.type === "workspace.base_branch.set.request") baseRequests += 1;
-      }
-      server.send(frame);
-    });
-    server.onMessage((frame) => {
-      if (typeof frame === "string") {
-        const envelope = JSON.parse(frame) as {
-          message?: { payload?: { status?: string; features?: Record<string, unknown> } };
-        };
-        const payload = envelope.message?.payload;
-        if (payload?.status === "server_info" && payload.features) {
-          delete payload.features.workspaceBaseBranch;
-          browser.send(JSON.stringify(envelope));
-          return;
-        }
-      }
-      browser.send(frame);
-    });
-  });
-  const workspace = await createWorktreeWithCommittedDiff();
-  await openWorkspaceChangesSurface(page, workspace);
-  await expect(page.getByTestId("workspace-base-branch-trigger")).toHaveCount(0);
-  expect(baseRequests).toBe(0);
-});
-
-test("Changes shows no base on a checkout that is not a Paseo worktree", async ({ page }) => {
-  const workspace = await createWorkspaceWithCommittedDiff();
-  await openWorkspaceChangesSurface(page, workspace);
-  const header = page.getByTestId("changes-repository-header").filter({ visible: true });
-  await expect(header).toContainText("feature");
-  await expect(header).not.toContainText("main");
-  await expect(page.getByTestId("workspace-base-branch-trigger")).toHaveCount(0);
-});
-
 test("Changes keeps a manual comparison when checkout dirtiness changes", async ({ page }) => {
   const workspace = await createWorkspaceWithMountedTabDiff();
   await openWorkspaceChanges(page, workspace);
@@ -623,35 +386,6 @@ test("an empty Changes comparison links to the populated comparison", async ({ p
   await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName("committed-only.ts, +1, -0");
 });
 
-test("legacy diff hosts keep All, Committed and Uncommitted comparisons", async ({ page }) => {
-  await useLegacyDiffHost(page);
-  const workspace = await createWorkspaceWithScrollableComparisons();
-  await openWorkspaceChangesSurface(page, workspace);
-  await expect(changesTree(page).getByText("committed", { exact: true })).toBeVisible();
-  await expect(changesTree(page).getByText("uncommitted", { exact: true })).toBeVisible();
-  await selectChangesComparison(page, "Committed");
-  await expectWorkingComparisonFiles(page, "committed");
-  await selectChangesComparison(page, "Uncommitted");
-  await expectWorkingComparisonFiles(page, "uncommitted");
-});
-async function useLegacyDiffHost(page: Page): Promise<void> {
-  await page.routeWebSocket(daemonWsRoutePattern(), (browserSocket) => {
-    const serverSocket = browserSocket.connectToServer();
-    browserSocket.onMessage((message) => serverSocket.send(message));
-    serverSocket.onMessage((message) => {
-      if (typeof message === "string") {
-        const envelope = JSON.parse(message);
-        if (envelope.message?.payload?.status === "server_info") {
-          delete envelope.message.payload.features.diffSubscription;
-          browserSocket.send(JSON.stringify(envelope));
-          return;
-        }
-      }
-      browserSocket.send(message);
-    });
-  });
-}
-
 test("Changes comparison controls the working diff and tree selection focuses its file", async ({
   page,
 }) => {
@@ -1194,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(32);
-  expect(optionsBox.width).toBe(44);
-  expect(optionsBox.height).toBe(44);
-  expect(glyphBox.width).toBe(20);
-  expect(glyphBox.height).toBe(20);
+  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);
 
   await expect(actions).not.toContainText("Commit");
   await expect(actions.locator("svg")).toHaveCount(2);
@@ -1464,13 +1198,11 @@ test("canvas diff uses the overlay scrollbar and its thumb controls vertical scr
 test("canvas headers keep a many-file diff bounded while scrolling end to end", async ({
   page,
 }) => {
-  test.setTimeout(300_000);
+  test.setTimeout(180_000);
   const workspace = await createWorkspaceWithManyTinyDiffs(2_000);
   await useUnwrappedDiffLines(page);
   await openWorkspaceChangesSurface(page, workspace, 90_000);
 
-  // Measure document bounds after delivery, independently of the cold Git read.
-  await expectWorkingDiffLoaded(page, 240_000);
   const root = page.getByTestId("git-diff-canvas-root");
   const scroller = page.getByTestId("git-diff-scroll");
   await expect(root.locator('[data-testid^="git-diff-sticky-header-"]')).toHaveCount(2);
@@ -1925,28 +1657,6 @@ async function expectRenderedAddedLine(page: Page, contents: string): Promise<vo
   }).toPass({ timeout: 15_000 });
 }
 
-async function createWorktreeWithCommittedDiff(): Promise<DirtyWorkspace> {
-  const repo = await createTempGitRepo("changes-base-worktree-", {
-    files: [{ path: "tracked.ts", content: "export const tracked = 1;\n" }],
-  });
-  const client = await connectSeedClient();
-  cleanupTasks.push({
-    run: async () => {
-      await client.close();
-      await repo.cleanup();
-    },
-  });
-  const created = await client.createWorkspace({
-    source: { kind: "worktree", cwd: repo.path, worktreeSlug: "base-picker", baseBranch: "main" },
-  });
-  if (!created.workspace) throw new Error(created.error ?? "Failed to create worktree");
-  const cwd = created.workspace.workspaceDirectory;
-  await writeFile(path.join(cwd, "committed-only.ts"), "export const committed = true;\n");
-  execFileSync("git", ["add", "committed-only.ts"], { cwd });
-  execFileSync("git", ["commit", "-m", "Add committed-only file"], { cwd });
-  return { id: created.workspace.id, repoPath: cwd };
-}
-
 async function createWorkspaceWithCommittedDiff(): Promise<DirtyWorkspace> {
   const repo = await createTempGitRepo("changes-committed-", {
     files: [{ path: "tracked.ts", content: "export const tracked = 1;\n" }],
@@ -2049,16 +1759,12 @@ async function createWorkspaceWithTwoSelectionDiffs(): Promise<DirtyWorkspace> {
   return { id: created.workspace.id, repoPath: repo.path };
 }
 
-async function createWorkspaceWithManyTinyDiffs(
-  fileCount: number,
-  branch = "main",
-): Promise<DirtyWorkspace> {
+async function createWorkspaceWithManyTinyDiffs(fileCount: number): Promise<DirtyWorkspace> {
   const files = Array.from({ length: fileCount }, (_, index) => ({
     path: `src/file-${String(index).padStart(4, "0")}.ts`,
     content: "export const value = 0;\n",
   }));
   const repo = await createTempGitRepo("changes-canvas-many-files-", { files });
-  if (branch !== "main") execFileSync("git", ["branch", "-m", branch], { cwd: repo.path });
   await Promise.all(
     files.map((file, index) =>
       writeFile(path.join(repo.path, file.path), `export const value = ${index + 1};\n`),

packages/app/e2e/browser/command-center-file-search.spec.ts

@@ -5,10 +5,8 @@ import {
   holdDirectorySuggestionResponses,
   expectOneLineTruncatedFileResult,
   expectStableCommandCenterLayout,
-  expectLayoutObservationToCatchPanelShift,
   failDirectorySuggestionRequests,
   startCommandCenterLayoutObservation,
-  shiftOutsideCommandCenter,
 } from "../support/helpers/command-center-file-search";
 import {
   scrollCommandCenterAwayFromSelection,
@@ -86,9 +84,7 @@ test("workspace file search stays geometrically stable through delayed loading a
     await expect(panel.getByTestId("command-center-file-search-loading")).toBeVisible();
     await expect(panel.getByText("Searching files...", { exact: true })).toHaveCount(0);
     await expect(panel.getByTestId("command-center-file-search-loading")).toBeHidden();
-    await shiftOutsideCommandCenter(page);
     await expectStableCommandCenterLayout(page);
-    await expectLayoutObservationToCatchPanelShift(page);
 
     await row.click();
     await expectFileTabOpen(page, FILE_PATH);

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

@@ -1,6 +1,5 @@
 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";
@@ -191,49 +190,3 @@ 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-autocomplete.spec.ts

@@ -105,21 +105,7 @@ interface PopoverFrameRecorderWindow extends Window {
   __stopComposerAutocompleteFrameRecorder?: () => void;
 }
 
-interface ListCommandsReply {
-  commands: readonly { name: string; description: string; argumentHint: string }[];
-  error: string | null;
-}
-
-const TEST_COMMANDS_REPLY: ListCommandsReply = { commands: TEST_COMMANDS, error: null };
-
-/**
- * Rewrites every `list_commands_response` with `reply()`. A reply that returns a promise holds
- * the response until it settles, standing in for a slow host.
- */
-async function installListCommandsStub(
-  page: Page,
-  reply: () => ListCommandsReply | Promise<ListCommandsReply> = () => TEST_COMMANDS_REPLY,
-): Promise<void> {
+async function installListCommandsStub(page: Page): Promise<void> {
   await page.routeWebSocket(daemonWsRoutePattern(), (ws) => {
     const server = ws.connectToServer();
 
@@ -144,20 +130,14 @@ async function installListCommandsStub(
             };
           };
         };
-        const payload = parsed.message?.payload;
         if (
           parsed.type === "session" &&
           parsed.message?.type === "list_commands_response" &&
-          payload
+          parsed.message.payload
         ) {
-          const send = (result: ListCommandsReply) => {
-            payload.commands = result.commands;
-            payload.error = result.error;
-            ws.send(JSON.stringify(parsed));
-          };
-          const result = reply();
-          if (result instanceof Promise) void result.then(send);
-          else send(result);
+          parsed.message.payload.commands = TEST_COMMANDS;
+          parsed.message.payload.error = null;
+          ws.send(JSON.stringify(parsed));
           return;
         }
       } catch {
@@ -169,17 +149,6 @@ async function installListCommandsStub(
   });
 }
 
-function createHeldReply(): {
-  reply: () => Promise<ListCommandsReply>;
-  release: () => void;
-} {
-  let release = () => {};
-  const held = new Promise<ListCommandsReply>((resolve) => {
-    release = () => resolve(TEST_COMMANDS_REPLY);
-  });
-  return { reply: () => held, release };
-}
-
 async function openAppWideNewWorkspace(page: Page): Promise<void> {
   await page.getByTestId("sidebar-global-new-workspace").first().click();
   await page.waitForURL((url) => url.pathname === "/new", { timeout: 30_000 });
@@ -576,17 +545,16 @@ test.describe("Composer autocomplete", () => {
       const input = composerLocator(page);
       await expect(input).toBeEditable({ timeout: 30_000 });
 
-      // `/hea` lists two commands and `/he` enough to reach the height cap, so the list grows.
-      await input.fill("/hea");
+      await input.fill("/he");
       const popover = page.getByTestId("composer-autocomplete-popover");
-      await expect(popover.getByText("/heapdump", { exact: true }).first()).toBeVisible({
+      await expect(popover.getByText("/help", { exact: true }).first()).toBeVisible({
         timeout: 30_000,
       });
       const beforeDelete = await visiblePopoverBox(page);
 
       await input.press("Backspace");
-      await expect(input).toHaveValue("/he");
-      await expect(popover.getByText("/hello", { exact: true }).first()).toBeVisible({
+      await expect(input).toHaveValue("/h");
+      await expect(popover.getByText("/history", { exact: true }).first()).toBeVisible({
         timeout: 30_000,
       });
       const afterDelete = await visiblePopoverBox(page);
@@ -765,116 +733,6 @@ test.describe("Composer autocomplete", () => {
     }
   });
 
-  test("forgets an arrow-key choice once the search changes", async ({ page }) => {
-    await installListCommandsStub(page);
-    const session = await seedMockAgentWorkspace({
-      repoPrefix: "autocomplete-stale-choice-",
-      title: "Autocomplete stale choice",
-    });
-
-    try {
-      await openAgentRoute(page, session);
-      await expectWorkspaceTabVisible(page, session.agentId);
-      const input = composerLocator(page);
-      await expect(input).toBeEditable({ timeout: 30_000 });
-      await input.fill("/");
-      const popover = page.getByTestId("composer-autocomplete-popover");
-      await expect(popover.getByText("/tdd", { exact: true }).first()).toBeVisible({
-        timeout: 30_000,
-      });
-
-      // Down wraps from the default bottom row to the top: /clear, then /exit.
-      await input.press("ArrowDown");
-      await input.press("ArrowDown");
-      await input.press("h");
-      await expect(popover.getByText("/help", { exact: true }).first()).toBeVisible();
-      await input.press("Backspace");
-      await expect(input).toHaveValue("/");
-      await input.press("Enter");
-
-      await expect(input).toHaveValue("/tdd ");
-      await expectWorkspaceTabVisible(page, session.agentId);
-    } finally {
-      await session.cleanup();
-    }
-  });
-
-  test("shows loading inside the popover until a slow host answers", async ({ page }) => {
-    const host = createHeldReply();
-    await installListCommandsStub(page, host.reply);
-    const agent = await openReadyMockAgent(page);
-
-    try {
-      const input = composerLocator(page);
-      await expect(input).toBeEditable({ timeout: 30_000 });
-      await input.fill("/");
-
-      const popover = page.getByTestId("composer-autocomplete-popover");
-      await expect(popover.getByTestId("composer-autocomplete-loading")).toBeVisible({
-        timeout: 30_000,
-      });
-      const loading = await visiblePopoverBox(page);
-
-      host.release();
-      await expect(popover.getByText("/help", { exact: true }).first()).toBeVisible({
-        timeout: 30_000,
-      });
-      await expect(popover.getByTestId("composer-autocomplete-loading")).toHaveCount(0);
-      const results = await visiblePopoverBox(page);
-
-      expect(Math.abs(results.bottom - loading.bottom)).toBeLessThanOrEqual(4);
-    } finally {
-      await agent.cleanup();
-    }
-  });
-
-  test("shows why commands failed, keeps Enter from choosing a hidden command, and retries", async ({
-    page,
-  }) => {
-    let reply: () => ListCommandsReply | Promise<ListCommandsReply> = () => ({
-      commands: [],
-      error: "Timed out waiting for the agent session",
-    });
-    await installListCommandsStub(page, () => reply());
-    const session = await seedMockAgentWorkspace({
-      repoPrefix: "autocomplete-failing-host-",
-      title: "Autocomplete failing host",
-    });
-
-    try {
-      await openAgentRoute(page, session);
-      await expectWorkspaceTabVisible(page, session.agentId);
-      const input = composerLocator(page);
-      await expect(input).toBeEditable({ timeout: 30_000 });
-      await input.fill("/");
-
-      const popover = page.getByTestId("composer-autocomplete-popover");
-      const errorRow = popover.getByTestId("composer-autocomplete-error");
-      await expect(errorRow).toContainText("Timed out waiting for the agent session", {
-        timeout: 30_000,
-      });
-
-      await input.press("Enter");
-      await page.waitForTimeout(500);
-      await expectWorkspaceTabVisible(page, session.agentId);
-
-      await input.fill("/");
-      await expect(errorRow).toBeVisible({ timeout: 30_000 });
-
-      const host = createHeldReply();
-      reply = host.reply;
-      await errorRow.getByRole("button", { name: "Retry" }).click();
-      await expect(popover.getByTestId("composer-autocomplete-loading")).toBeVisible();
-
-      host.release();
-      await expect(popover.getByText("/help", { exact: true }).first()).toBeVisible({
-        timeout: 30_000,
-      });
-    } finally {
-      await session.cleanup();
-    }
-  });
-
   test.describe("compact sidebar layering", () => {
     test.use({ viewport: { width: 390, height: 844 }, isMobile: true, hasTouch: true });
 

packages/app/e2e/browser/composer-bottom-spacing.spec.ts

@@ -1,53 +0,0 @@
-import type { Locator } from "@playwright/test";
-import { expect, test } from "../support/fixtures";
-import { gotoAppShell } from "../support/helpers/app";
-import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
-import { openNewWorkspaceComposer } from "../support/helpers/new-workspace";
-import { seedWorkspace } from "../support/helpers/seed-client";
-import { waitForSidebarHydration } from "../support/helpers/workspace-ui";
-
-async function box(locator: Locator) {
-  await expect(locator).toBeVisible({ timeout: 30_000 });
-  const rect = await locator.boundingBox();
-  expect(rect).not.toBeNull();
-  return { top: rect!.y, bottom: rect!.y + rect!.height };
-}
-
-test.describe("Composer bottom spacing", () => {
-  test("the chat composer rests one content spacing above the window edge", async ({ page }) => {
-    const agent = await seedMockAgentWorkspace({
-      repoPrefix: "composer-bottom-spacing-",
-      title: "Bottom spacing",
-    });
-    try {
-      await openAgentRoute(page, { workspaceId: agent.workspaceId, agentId: agent.agentId });
-      const surface = await box(
-        page.getByTestId("message-input-root").filter({ visible: true }).first(),
-      );
-      const viewportHeight = await page.evaluate(() => window.innerHeight);
-      expect(viewportHeight - surface.bottom).toBe(16);
-    } finally {
-      await agent.cleanup();
-    }
-  });
-
-  test("the wide new workspace form keeps one content spacing above Import session", async ({
-    page,
-  }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "composer-bottom-spacing-form-" });
-    try {
-      await page.setViewportSize({ width: 1440, height: 900 });
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-      await openNewWorkspaceComposer(page, {
-        projectKey: workspace.projectKey,
-        projectDisplayName: workspace.projectDisplayName,
-      });
-      const composer = await box(page.locator('[data-testid="message-input-root"]:visible'));
-      const importButton = await box(page.getByTestId("new-workspace-import-session"));
-      expect(importButton.top - composer.bottom).toBe(16);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-});

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

@@ -1,30 +1,13 @@
 import { test, expect } from "../support/fixtures";
 import { openWorkspaceWithAgents } from "../support/helpers/archive-tab";
 import {
-  composerLocator,
-  expectComposerVisible,
-  fillComposerDraft,
-} from "../support/helpers/composer";
-import {
-  expectComposerToolbarOnTextRails,
-  expectTrailingActionSwap,
   expectNoCollapsedComposerToolbarFrame,
-  expectNoFrameTruncatesModelBesideThinking,
-  readSettledModelTriggerLabels,
-  readTrailingActionFrames,
   recordComposerToolbarFrames,
-  recordModelTriggerFramesFromLoad,
-  recordTrailingActionFrames,
-  sweepModelTriggerLabels,
 } 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;
-const TRAILING_ACTION_SETTLE_MS = 500;
-const VOICE_MODE = "Enable Voice mode";
-const SEND = "Send message";
 
 async function seedSettledMockAgent(workspace: SeededWorkspace, title: string) {
   const agent = await workspace.client.createAgent({
@@ -47,52 +30,6 @@ function visibleAgentTab(page: import("@playwright/test").Page, agentId: string)
   return page.getByTestId(`workspace-tab-agent_${agentId}`).filter({ visible: true }).first();
 }
 
-test.describe("Composer trailing action", () => {
-  test.describe.configure({ timeout: 120_000 });
-
-  for (const viewport of [
-    { name: "wide", width: 1280, height: 800 },
-    { name: "compact", width: 390, height: 844 },
-  ]) {
-    test(`swaps in place between voice mode and Send at ${viewport.name} width`, async ({
-      page,
-    }) => {
-      await page.setViewportSize({ width: viewport.width, height: viewport.height });
-      const agent = await seedMockAgentWorkspace({
-        repoPrefix: "composer-trailing-action-",
-        title: "Trailing action",
-      });
-      try {
-        await openAgentRoute(page, agent);
-        await expectComposerVisible(page);
-        await expect(page.getByRole("button", { name: VOICE_MODE, exact: true })).toBeVisible();
-        const composer = composerLocator(page);
-        await composer.focus();
-
-        await recordTrailingActionFrames(page);
-        await composer.press("x");
-        await expect(composer).toHaveValue("x");
-        await page.waitForTimeout(TRAILING_ACTION_SETTLE_MS);
-        expectTrailingActionSwap(await readTrailingActionFrames(page), {
-          from: VOICE_MODE,
-          to: SEND,
-        });
-
-        await recordTrailingActionFrames(page);
-        await composer.press("Backspace");
-        await expect(composer).toHaveValue("");
-        await page.waitForTimeout(TRAILING_ACTION_SETTLE_MS);
-        expectTrailingActionSwap(await readTrailingActionFrames(page), {
-          from: SEND,
-          to: VOICE_MODE,
-        });
-      } finally {
-        await agent.cleanup();
-      }
-    });
-  }
-});
-
 test.describe("Composer control density across tab switches", () => {
   test.describe.configure({ timeout: 180_000 });
 
@@ -155,159 +92,3 @@ 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();
-    }
-  });
-});
-
-test.describe("Folded model control on a phone", () => {
-  // Wide enough for "Ten second stream" and "Low" side by side; narrower, they no longer fit.
-  test.use({ viewport: { width: 480, height: 844 }, isMobile: true, hasTouch: true });
-  test.describe.configure({ timeout: 180_000 });
-
-  test("hides the thinking label before the model label truncates", async ({ page }) => {
-    const session = await seedMockAgentWorkspace({
-      repoPrefix: "composer-density-labels-",
-      title: "Label priority chat",
-      model: "ten-second-stream",
-    });
-    try {
-      await recordModelTriggerFramesFromLoad(page);
-      await openAgentRoute(page, session);
-      await expect(
-        page.getByTestId("combined-model-selector-thinking-label").filter({ visible: true }),
-      ).toHaveText("Low");
-      await readSettledModelTriggerLabels(page);
-      // From the first frame on, the control never guesses: it paints both labels only once it
-      // has measured that they fit.
-      await expectNoFrameTruncatesModelBesideThinking(page);
-
-      const sweep = await sweepModelTriggerLabels(page, {
-        from: 480,
-        to: 280,
-        step: 4,
-        height: 844,
-      });
-
-      expect(sweep.widest).toMatchObject({
-        modelText: "Ten second stream",
-        thinkingShown: true,
-        modelTruncated: false,
-      });
-      expect(sweep.thinkingHidden).toMatchObject({
-        modelText: "Ten second stream",
-        modelTruncated: false,
-      });
-      expect(sweep.modelTruncated.width).toBeLessThan(sweep.thinkingHidden.width);
-      // A clean tail: the label ends on a whole word and the ellipsis, never on a space.
-      expect(sweep.modelTruncated).toMatchObject({
-        modelText: "Ten second…",
-        thinkingShown: false,
-      });
-    } finally {
-      await session.cleanup();
-    }
-  });
-});
-
-test.describe("Composer toolbar rails on touch", () => {
-  test.use({ isMobile: true, hasTouch: true });
-  test.describe.configure({ timeout: 180_000 });
-
-  for (const viewport of [
-    { device: "phone", width: 390, height: 844 },
-    { device: "tablet", width: 1024, height: 1366 },
-  ]) {
-    test(`the toolbar starts on the text rail and ends in a disc nested in the corner on a ${viewport.device}`, async ({
-      page,
-    }) => {
-      await page.setViewportSize({ width: viewport.width, height: viewport.height });
-      const idle = await seedMockAgentWorkspace({
-        repoPrefix: "composer-rails-idle-",
-        title: "Rails idle chat",
-      });
-      let running: Awaited<ReturnType<typeof seedMockAgentWorkspace>> | null = null;
-      try {
-        await openAgentRoute(page, idle);
-        await expect(page.getByTestId("message-input-root").filter({ visible: true })).toBeVisible({
-          timeout: 30_000,
-        });
-        await test.step("empty composer: attach on the left, voice mode on the right", async () => {
-          await expectComposerToolbarOnTextRails(page);
-        });
-        await test.step("draft: the send disc on the right", async () => {
-          await fillComposerDraft(page, "Refactor the composer toolbar");
-          await expect(page.getByRole("button", { name: /send/i }).first()).toBeVisible();
-          await expectComposerToolbarOnTextRails(page);
-        });
-
-        running = await seedMockAgentWorkspace({
-          repoPrefix: "composer-rails-running-",
-          title: "Rails running chat",
-          model: "one-minute-stream",
-          initialPrompt: "stream for a while",
-        });
-        await openAgentRoute(page, running);
-        await test.step("running agent: the stop disc on the right", async () => {
-          await expect(page.getByRole("button", { name: /stop agent/i }).first()).toBeVisible({
-            timeout: 30_000,
-          });
-          await expectComposerToolbarOnTextRails(page);
-        });
-      } finally {
-        await idle.cleanup();
-        await running?.cleanup();
-      }
-    });
-  }
-});
-
-test.describe("Composer trailing disc on a new chat", () => {
-  test.use({ isMobile: true, hasTouch: true, viewport: { width: 1024, height: 1366 } });
-
-  test("an empty draft holds a disabled send disc until there is something to send", async ({
-    page,
-  }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "composer-placeholder-send-" });
-    try {
-      await gotoWorkspace(page, workspace.workspaceId);
-      await clickNewChat(page);
-      const send = page
-        .getByTestId("message-input-root")
-        .filter({ visible: true })
-        .getByRole("button", { name: "Send message", exact: true });
-      await expect(send).toBeDisabled({ timeout: 30_000 });
-      await fillComposerDraft(page, "Refactor the composer toolbar");
-      await expect(send).toBeEnabled();
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-});

packages/app/e2e/browser/composer-diff-stat.spec.ts

@@ -1,9 +1,7 @@
-import type { CDPSession, Locator } from "@playwright/test";
+import type { Locator } from "@playwright/test";
 import { writeFile } from "node:fs/promises";
 import path from "node:path";
 import { expect, test, type Page } from "../support/fixtures";
-import { seedSubagent } from "../support/helpers/subagents";
-import { submitMessage } from "../support/helpers/composer";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
 import { gateNextAgentMessage } from "../support/helpers/agent-message-gate";
 import {
@@ -80,8 +78,7 @@ test("composer diff stat reveals Changes, then opens the diff in the configured
   const workspace = await seedChangedAgent("composer-diff-stat-side-");
 
   try {
-    // Keep both workspace rails visible alongside app navigation and Explorer.
-    await page.setViewportSize({ width: 1900, height: 900 });
+    await page.setViewportSize({ width: 1400, height: 900 });
     await openAgentRoute(page, {
       workspaceId: workspace.workspaceId,
       agentId: workspace.agentId,
@@ -862,91 +859,3 @@ async function expectReviewEditorBody(page: Page, body: string) {
     body,
   );
 }
-
-async function swipeComposerTracks(page: Page, client: CDPSession, direction: "left" | "right") {
-  const track = page.getByTestId("composer-track-scroll");
-  const box = await track.boundingBox();
-  if (!box) throw new Error("Composer tracks are not visible");
-  const start = direction === "left" ? box.x + box.width - 5 : box.x + 5;
-  const end = direction === "left" ? box.x + 5 : box.x + box.width - 5;
-  await swipeTouch(client, start, end, box.y + box.height / 2);
-}
-
-async function swipeTouch(client: CDPSession, start: number, end: number, y: number) {
-  await client.send("Input.dispatchTouchEvent", {
-    type: "touchStart",
-    touchPoints: [{ x: start, y }],
-  });
-  for (let step = 1; step <= 8; step++) {
-    await client.send("Input.dispatchTouchEvent", {
-      type: "touchMove",
-      touchPoints: [{ x: start + ((end - start) * step) / 8, y }],
-    });
-  }
-  await client.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
-}
-
-async function trackScrollOffset(track: Locator): Promise<number> {
-  return track.evaluate((node) => node.scrollLeft);
-}
-
-test.describe("touch composer tracks", () => {
-  test.use({ hasTouch: true, isMobile: true });
-  test("compact composer scrolls its task, subagent and changes tracks without squeezing them", async ({
-    page,
-  }) => {
-    const workspace = await seedChangedAgent("composer-tracks-overflow-");
-    const touch = await page.context().newCDPSession(page);
-    try {
-      await seedSubagent(
-        { client: workspace.client, repoPath: workspace.cwd, workspaceId: workspace.workspaceId },
-        { parentId: workspace.agentId, title: "Track child" },
-      );
-      await page.setViewportSize({ width: 1000, height: 844 });
-      await openAgentRoute(page, {
-        workspaceId: workspace.workspaceId,
-        agentId: workspace.agentId,
-      });
-      await submitMessage(page, "emit 1 agent stream updates");
-      const tasks = page.getByTestId("agent-task-list-header");
-      const subagents = page.getByTestId("subagents-track-header");
-      const changes = page.getByTestId("composer-diff-stat-pill");
-      await expect(tasks).toBeVisible();
-      await expect(subagents).toBeVisible();
-      await expect(changes).toBeVisible();
-      const wideWidths = await Promise.all(
-        [tasks, subagents, changes].map(async (pill) => (await pill.boundingBox())!.width),
-      );
-      await page.setViewportSize({ width: 200, height: 844 });
-      const narrowWidths = await Promise.all(
-        [tasks, subagents, changes].map(async (pill) => (await pill.boundingBox())!.width),
-      );
-      for (const [index, width] of wideWidths.entries())
-        expect(narrowWidths[index]).toBeGreaterThanOrEqual(width - 1);
-      const track = page.getByTestId("composer-track-scroll");
-      expect(await track.evaluate((node) => node.scrollWidth)).toBeGreaterThan(
-        await track.evaluate((node) => node.clientWidth),
-      );
-      await swipeComposerTracks(page, touch, "left");
-      await expect.poll(() => trackScrollOffset(track)).toBeGreaterThan(0);
-      await swipeComposerTracks(page, touch, "right");
-      await expect.poll(() => trackScrollOffset(track)).toBeLessThanOrEqual(1);
-      await swipeComposerTracks(page, touch, "left");
-      await expect.poll(() => trackScrollOffset(track)).toBeGreaterThan(0);
-      await expect(page.getByTestId("sidebar-sessions")).not.toBeInViewport();
-      await expect(page.getByTestId("workspace-explorer-sidebar")).not.toBeInViewport();
-      await page.getByRole("button", { name: "Open menu" }).click();
-      await expect(page.getByTestId("sidebar-sessions")).toBeInViewport({ ratio: 1 });
-      await page.getByTestId("sidebar-close").click();
-      await expect(page.getByTestId("sidebar-sessions")).not.toBeInViewport();
-      await expect(changes).toBeInViewport();
-      await changes.click();
-      await expect(
-        page.getByTestId("changes-header").filter({ visible: true }).first(),
-      ).toBeVisible();
-    } finally {
-      await touch.detach();
-      await workspace.cleanup();
-    }
-  });
-});

packages/app/e2e/browser/composer-focus.spec.ts

@@ -1,11 +1,5 @@
 import { expect, test, type Page } from "../support/fixtures";
 import {
-  pasteRichTextIntoComposer,
-  fillComposerDraft,
-  copyLatestTurnIntoComposer,
-  selectComposerDraftRange,
-  undoComposerEdit,
-  redoComposerEdit,
   blurComposerInput,
   roundTripComposerTabBeforePaint,
   composerLocator,
@@ -19,7 +13,6 @@ import {
   expectWorkspaceHeaderVisible,
   resizeComposerViewport,
   submitMessage,
-  submitMessageWithButton,
   typeIntoFocusedComposer,
 } from "../support/helpers/composer";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
@@ -32,10 +25,9 @@ import {
   expectMobileAgentSidebarVisible,
   expectMobileExplorerHidden,
   expectMobileExplorerVisible,
-  openMobileAgentSidebarWithKeyboard,
+  swipeOpenMobileAgentSidebar,
   swipeOpenMobileExplorer,
 } from "../support/helpers/sidebar";
-import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
 import { readScrollMetrics } from "../support/helpers/agent-bottom-anchor";
 import {
   expectTimelinePromptPositionPreserved,
@@ -63,9 +55,7 @@ test("clicking chat text or background focuses the feed for keyboard paging", as
     await expect
       .poll(async () => (await readScrollMetrics(page)).offsetY)
       .toBeLessThan(beforePaging.offsetY - beforePaging.viewportHeight / 2);
-    await page.screenshot({
-      path: testInfo.outputPath("chat-keyboard-paging.png"),
-    });
+    await page.screenshot({ path: testInfo.outputPath("chat-keyboard-paging.png") });
     await page.keyboard.press("PageDown");
     await expect
       .poll(async () => (await readScrollMetrics(page)).distanceFromBottom)
@@ -134,86 +124,20 @@ test("focusing the feed preserves assistant text selection and code copy control
 });
 
 test("submitting a message leaves the composer ready for the next message", async ({ page }) => {
-  const copiedTable =
-    "| Resource | Status |\n| --- | --- |\n| [Unicode](https://example.com/日本語) | ~~closed~~ |\n| [Space](<https://example.com/a b>) | **open** |\n| [ASCII](https://example.com/1) | closed |";
   const agent = await seedMockAgentWorkspace({
     repoPrefix: "composer-focus-",
     title: "Composer focus",
-    featureValues: { mockAssistantResponse: copiedTable },
   });
 
-  const connection = await installDaemonWebSocketGate(page);
   try {
     await openAgentRoute(page, agent);
     await expectComposerVisible(page);
 
-    await submitMessageWithButton(page, "Pointer submission");
-    await expectComposerDraft(page, "");
-    await expectComposerFocused(page);
-    await typeIntoFocusedComposer(page, "Ready after Send");
-    await expectComposerDraft(page, "Ready after Send");
-    await agent.client.waitForFinish(agent.agentId, 15_000);
-    await expectComposerFocused(page);
-
     await submitMessage(page, "First message");
     await expectComposerFocused(page);
 
-    await typeIntoFocusedComposer(page, "Investigate: replace this. Thanks");
-    await selectComposerDraftRange(page, 13, 25);
-    await pasteRichTextIntoComposer({
-      page,
-      html: '<a href="https://example.com/issues/39150">this FR</a>',
-      text: "this FR",
-    });
-    await expectComposerDraft(
-      page,
-      "Investigate: [this FR](https://example.com/issues/39150). Thanks",
-    );
-    await undoComposerEdit(page);
-    await expectComposerDraft(page, "Investigate: replace this. Thanks");
-    await redoComposerEdit(page);
-    await expectComposerDraft(
-      page,
-      "Investigate: [this FR](https://example.com/issues/39150). Thanks",
-    );
-    await typeIntoFocusedComposer(page, " next");
-    await expectComposerDraft(
-      page,
-      "Investigate: [this FR](https://example.com/issues/39150) next. Thanks",
-    );
-    await agent.client.waitForFinish(agent.agentId, 15_000);
-    await expect(page.getByRole("button", { name: "Copy turn", exact: true }).last()).toBeVisible();
-    await connection.drop();
-    await connection.waitForBlockedConnection();
-    await pasteRichTextIntoComposer({
-      page,
-      html: '<a href="https://example.com/offline">offline link</a>',
-      text: "offline link",
-    });
-    await expectComposerDraft(
-      page,
-      "Investigate: [this FR](https://example.com/issues/39150) next[offline link](https://example.com/offline). Thanks",
-    );
-    await fillComposerDraft(page, "");
-    await pasteRichTextIntoComposer({
-      page,
-      html: '<table><thead><tr><th>Resource</th><th>Status</th></tr></thead><tbody><tr><td><a href="https://example.com/issue">Issue</a></td><td>closed</td></tr></tbody></table>',
-      text: "Resource\tStatus\nIssue\tclosed",
-    });
-    await expectComposerDraft(
-      page,
-      "| Resource | Status |\n| --- | --- |\n| [Issue](https://example.com/issue) | closed |",
-    );
-    await fillComposerDraft(page, "");
-    await pasteRichTextIntoComposer({
-      page,
-      html: '<a href="https://example.com/">Issue</a><table></table>',
-      text: "Issue",
-    });
-    await expectComposerDraft(page, "[Issue](https://example.com/)");
-    await copyLatestTurnIntoComposer(page);
-    await expectComposerDraft(page, copiedTable);
-    await expectComposerFocused(page);
+    await typeIntoFocusedComposer(page, "Second message");
+    await expectComposerDraft(page, "Second message");
   } finally {
     await agent.cleanup();
   }
@@ -244,11 +168,7 @@ async function waitForAnimationFrames(page: Page, count: number): Promise<void>
 test.describe("touch screen wide enough for the desktop layout", () => {
   // A tablet or an unfolded foldable gets the desktop layout, but focusing the
   // composer there raises the on-screen keyboard over the conversation.
-  test.use({
-    viewport: { width: 1024, height: 768 },
-    isMobile: true,
-    hasTouch: true,
-  });
+  test.use({ viewport: { width: 1024, height: 768 }, isMobile: true, hasTouch: true });
 
   test("remounting an inline composer does not restore focus on touch", async ({ page }) => {
     const agent = await seedMockAgentWorkspace({
@@ -272,9 +192,7 @@ test.describe("touch screen wide enough for the desktop layout", () => {
   test("returning to an inactive inline composer does not restore focus on touch", async ({
     page,
   }) => {
-    const workspace = await seedWorkspace({
-      repoPrefix: "composer-touch-retained-",
-    });
+    const workspace = await seedWorkspace({ repoPrefix: "composer-touch-retained-" });
     try {
       const first = await createMockIdleAgent(workspace.client, {
         cwd: workspace.repoPath,
@@ -322,9 +240,6 @@ test.describe("touch screen wide enough for the desktop layout", () => {
       // Autofocus makes its first attempt on the next animation frame.
       await waitForAnimationFrames(page, 4);
       await expectComposerNotFocused(page);
-      await submitMessageWithButton(page, "Touch submission");
-      await expectComposerDraft(page, "");
-      await expectComposerNotFocused(page);
     } finally {
       await agent.cleanup();
     }
@@ -334,7 +249,7 @@ test.describe("touch screen wide enough for the desktop layout", () => {
 const COMPACT_PANELS = [
   {
     name: "agent list",
-    open: openMobileAgentSidebarWithKeyboard,
+    open: swipeOpenMobileAgentSidebar,
     expectOpen: expectMobileAgentSidebarVisible,
     close: closeMobileAgentSidebar,
     expectClosed: expectMobileAgentSidebarHidden,

packages/app/e2e/browser/composer-whitespace.spec.ts

@@ -37,7 +37,7 @@ import {
   closeMobileAgentSidebar,
   expectMobileAgentSidebarHidden,
   expectMobileAgentSidebarVisible,
-  openMobileAgentSidebarWithKeyboard,
+  swipeOpenMobileAgentSidebar,
 } from "../support/helpers/sidebar";
 
 async function composerHeight(page: Page): Promise<number> {
@@ -541,8 +541,8 @@ test("the compact sidebar over a fullscreen editor leaves the exit action alone"
     await writeCompactDraft(page, draft);
     await enterComposerFullscreen(page);
     await expectWorkspaceHeaderHidden(page);
-    // Fullscreen hides the header's menu button; the keyboard shortcut opens the list over it.
-    await openMobileAgentSidebarWithKeyboard(page);
+    // Fullscreen hides the header's menu button; the edge swipe still opens the list over it.
+    await swipeOpenMobileAgentSidebar(page);
     await expectMobileAgentSidebarVisible(page);
     // The list covers the pane, so the editor's exit action is not armed.
     await page.keyboard.press("Escape");

packages/app/e2e/browser/context-window-meter.spec.ts

@@ -21,7 +21,6 @@ import {
   openAgent,
   pressContextWindowMeter,
   qaScreenshot,
-  recordContextWindowFrames,
   refreshUsageCard,
   reloadAgent,
   scriptAgentUsage,
@@ -300,10 +299,9 @@ for (const theme of ["light", "dark"] as const) {
       const slowSource = gate();
       usage.answerNext({ stream: [slowSource.promise, onWorkLogin(claude!)] });
       const closedEarly = await hoverContextWindowMeter(page);
-      await expect(usageCard(closedEarly, "claude:work").getByText(LOGIN_EXPIRED)).toBeVisible();
+      await expect(closedEarly.getByText("Loading usage...", { exact: true })).toBeVisible();
       await leaveContextWindowMeter(page);
 
-      await usage.resumeAgent(agent);
       const resumed = gate();
       const finished = gate();
       usage.answerNext({
@@ -387,58 +385,6 @@ for (const theme of ["light", "dark"] as const) {
   });
 }
 
-test("an open with loaded usage paints it in its first frame and never moves", async ({
-  page,
-  agent,
-}) => {
-  const [claude] = claudeAndCodexReports();
-  const usage = await scriptAgentUsage(page);
-  await page.setViewportSize(DESKTOP);
-  await openAgent(page, agent);
-  usage.answerNext([onWorkLogin(claude!)]);
-  const loaded = await hoverContextWindowMeter(page);
-  await expect(usageCard(loaded, "claude:work")).toBeVisible();
-  await leaveContextWindowMeter(page);
-
-  // The reopen's own request stays unanswered until the card has been on screen a while.
-  const refetch = gate();
-  usage.answerNext({ stream: [refetch.promise, onWorkLogin(claude!)] });
-  const recording = await recordContextWindowFrames(page);
-  const reopened = await hoverContextWindowMeter(page);
-  await page.waitForTimeout(300);
-  refetch.open();
-  await page.waitForTimeout(300);
-  await expect(usageCard(reopened, "claude:work")).toBeVisible();
-  const frames = (await recording.stop()).filter((frame) => frame.mounted);
-  await leaveContextWindowMeter(page);
-
-  expect(frames.filter((frame) => frame.loading)).toEqual([]);
-  expect(frames.filter((frame) => frame.usageCards !== 1)).toEqual([]);
-  expect(new Set(frames.map((frame) => frame.bottom)).size).toBe(1);
-});
-
-test("usage arriving after the card opens never moves its bottom edge", async ({ page, agent }) => {
-  const [claude] = claudeAndCodexReports();
-  const usage = await scriptAgentUsage(page);
-  await page.setViewportSize(DESKTOP);
-  await openAgent(page, agent);
-
-  const arrival = gate();
-  usage.answerNext({ stream: [arrival.promise, onWorkLogin(claude!)] });
-  const recording = await recordContextWindowFrames(page);
-  const card = await hoverContextWindowMeter(page);
-  await expect(card.getByText("Loading usage...", { exact: true })).toBeVisible();
-  arrival.open();
-  await expect(usageCard(card, "claude:work")).toBeVisible();
-  await page.waitForTimeout(300);
-  const frames = (await recording.stop()).filter((frame) => frame.mounted);
-  await leaveContextWindowMeter(page);
-
-  expect(frames.some((frame) => frame.loading)).toBe(true);
-  expect(frames.at(-1)?.usageCards).toBe(1);
-  expect(new Set(frames.map((frame) => frame.bottom)).size).toBe(1);
-});
-
 test("context details support keyboard entry and dismiss when the viewport moves", async ({
   page,
   agent,

packages/app/e2e/browser/direct-terminal-shortcut-pane-placement.spec.ts

@@ -1,5 +1,3 @@
-import { installLocalDesktopHost } from "../support/helpers/local-desktop-host";
-import type { Locator, Page } from "@playwright/test";
 import { expect, test } from "../support/fixtures";
 import { runWorkspaceActionFromCommandCenter } from "../support/helpers/command-center-workspace-actions";
 import {
@@ -11,7 +9,6 @@ import { seedWorkspace } from "../support/helpers/seed-client";
 import { waitForWorkspaceTabsVisible } from "../support/helpers/workspace-tabs";
 
 test.describe("Direct terminal shortcut pane placement", () => {
-  test.use({ viewport: { width: 1600, height: 900 } });
   test("opens a terminal in the focused pane", async ({ page }) => {
     const workspace = await seedWorkspace({ repoPrefix: "direct-terminal-shortcut-pane-" });
 
@@ -50,91 +47,3 @@ test.describe("Direct terminal shortcut pane placement", () => {
     }
   });
 });
-
-async function prepareNarrowSplit(page: Page, workspaceId: string) {
-  await page.setViewportSize({ width: 1600, height: 900 });
-  await gotoWorkspace(page, workspaceId);
-  await waitForWorkspaceTabsVisible(page);
-  await clickNewChat(page);
-  await runWorkspaceActionFromCommandCenter(page, "Split pane right");
-  const draftPane = page
-    .locator('[data-testid^="workspace-pane-"]')
-    .filter({ has: page.getByTestId("message-input-root") });
-  const emptyPane = page
-    .locator('[data-testid^="workspace-pane-"]')
-    .filter({ has: page.getByTestId("workspace-new-tab-panel") });
-  const draftPaneId = await draftPane.getAttribute("data-testid");
-  const emptyPaneId = await emptyPane.getAttribute("data-testid");
-  expect(draftPaneId).not.toBeNull();
-  expect(emptyPaneId).not.toBeNull();
-  await page.setViewportSize({ width: 760, height: 900 });
-  return {
-    originalPane: page.getByTestId(draftPaneId!),
-    otherPane: page.getByTestId(emptyPaneId!),
-  };
-}
-
-async function expectPanesKeepTabRails(page: Page, panes: Locator[]) {
-  for (const pane of panes) {
-    await expect(pane.getByTestId("workspace-tabs-row")).toBeVisible();
-  }
-  await expect(
-    page.getByTestId("workspace-tab-switcher-trigger").filter({ visible: true }),
-  ).toHaveCount(0);
-}
-
-async function launchTerminalFromPaneRail(page: Page, pane: Locator) {
-  await pane.getByTestId("workspace-new-tab-button").click();
-  await page.getByTestId("workspace-new-tab-menu-terminal").filter({ visible: true }).click();
-  await expect(pane.getByTestId("terminal-surface")).toBeVisible({ timeout: 30_000 });
-}
-
-async function maximizeAndRestorePane(pane: Locator) {
-  await pane.getByTestId("workspace-maximize-pane").click();
-  await pane.getByTestId("workspace-restore-pane").click();
-}
-
-test("narrow split panes keep their tab rails and launches stay in the owning pane", async ({
-  page,
-}) => {
-  const workspace = await seedWorkspace({ repoPrefix: "narrow-split-launch-" });
-  try {
-    const { originalPane, otherPane } = await prepareNarrowSplit(page, workspace.workspaceId);
-    await expectPanesKeepTabRails(page, [originalPane, otherPane]);
-    await launchTerminalFromPaneRail(page, originalPane);
-    await expect(otherPane.getByTestId("workspace-new-tab-panel")).toBeVisible();
-    await maximizeAndRestorePane(originalPane);
-    await expect(otherPane).toBeVisible();
-    await expectPanesKeepTabRails(page, [originalPane, otherPane]);
-  } finally {
-    await workspace.cleanup();
-  }
-});
-
-async function expectPaneHasWindowDragSurface(pane: Locator) {
-  await expect
-    .poll(() =>
-      pane.evaluate((element) =>
-        Array.from(element.querySelectorAll<HTMLElement>("div")).some(
-          (node) => node.style.getPropertyValue("-webkit-app-region") === "drag",
-        ),
-      ),
-    )
-    .toBe(true);
-}
-
-test("narrow desktop split panes retain window dragging with both sidebars closed", async ({
-  page,
-}) => {
-  const workspace = await seedWorkspace({ repoPrefix: "narrow-split-window-drag-" });
-  try {
-    await installLocalDesktopHost(page, workspace.repoPath);
-    const { originalPane, otherPane } = await prepareNarrowSplit(page, workspace.workspaceId);
-    await runWorkspaceActionFromCommandCenter(page, "Toggle left sidebar");
-    await expectPanesKeepTabRails(page, [originalPane, otherPane]);
-    await expectPaneHasWindowDragSurface(originalPane);
-    await expectPaneHasWindowDragSurface(otherPane);
-  } finally {
-    await workspace.cleanup();
-  }
-});

packages/app/e2e/browser/empty-pane-keyboard.spec.ts

@@ -56,9 +56,9 @@ test.describe("New tab keyboard launcher", () => {
       await expectLauncherSelection(launcher, "Diff");
       await page.keyboard.press("Enter");
 
-      await expect(page.getByTestId("working-diff-panel").filter({ visible: true })).toBeVisible({
-        timeout: 30_000,
-      });
+      await expect(
+        page.getByTestId("workspace-tab-working_diff").filter({ visible: true }),
+      ).toBeVisible({ timeout: 30_000 });
     } finally {
       await workspace.cleanup();
     }

packages/app/e2e/browser/explorer-pane-placement.spec.ts

@@ -105,9 +105,6 @@ function collectConsoleErrors(page: Page): string[] {
   return errors;
 }
 
-// These drag and tab-menu journeys need full rails beside the docked Explorer.
-test.use({ viewport: { width: 1900, height: 900 } });
-
 test.describe("explorer pane tab placement", () => {
   test("agents open in the main pane and New-tab splits keep the app usable", async ({
     page,

packages/app/e2e/browser/explorer-resize-performance.spec.ts

@@ -79,12 +79,6 @@ async function previewExplorerResize(page: Page, distance: number) {
   return { ...measurement, width: after };
 }
 
-async function expectCleanChangesLoaded(page: Page): Promise<void> {
-  await expect(
-    page.getByTestId("changes-tree-panel").getByText("No changes to display", { exact: true }),
-  ).toBeVisible();
-}
-
 async function expectExplorerWidthSurvivesReload(page: Page, width: number): Promise<void> {
   await page.reload();
   const explorer = page.getByTestId("workspace-explorer-sidebar");
@@ -106,7 +100,6 @@ test("Explorer drag previews without rerendering panes or rewriting the shared s
   await runWorkspaceActionFromCommandCenter(page, "Split pane right");
   await page.getByTestId("workspace-explorer-toggle").first().click();
   await expect(page.getByTestId("workspace-explorer-sidebar")).toBeVisible();
-  await expectCleanChangesLoaded(page);
   // Verify that direct pane renders are being counted before resetting them.
   expect(
     await page.evaluate(() =>

packages/app/e2e/browser/file-editing.spec.ts

@@ -435,8 +435,7 @@ test.describe("CodeMirror workspace file editing", () => {
     });
 
     try {
-      // Keep both tab rails available alongside the docked Explorer.
-      await page.setViewportSize({ width: 1900, height: 900 });
+      await page.setViewportSize({ width: 1280, height: 900 });
       await openAgentRoute(page, session);
 
       await openWorkspaceFile(page, "target.ts");

packages/app/e2e/browser/host-confirmation.spec.ts

@@ -9,7 +9,7 @@ import {
   expectHostInHostPicker,
   hostConfirmation,
   openPairingLink,
-  reopenPairingLinkWithSavedHosts,
+  saveLinkedHostBeforeLoad,
   type LinkedHost,
 } from "../support/helpers/host-confirmation";
 
@@ -20,9 +20,7 @@ const linkedHost: LinkedHost = {
   daemonPublicKeyB64: "bGlua0NvbmZpcm1hdGlvbktleQ",
 };
 
-test("a pairing link asks before saving a host and reconnects without asking again", async ({
-  page,
-}) => {
+test("a pairing link for a new host asks before saving it", async ({ page }) => {
   const link = buildPairingLink(linkedHost);
 
   await test.step("Cancel saves nothing and stays on the page", async () => {
@@ -41,10 +39,13 @@ test("a pairing link asks before saving a host and reconnects without asking aga
     await openSettings(page);
     await expectHostInHostPicker(page, linkedHost.serverId, "listed");
   });
+});
 
-  await test.step("reopening the saved host link connects without asking", async () => {
-    await reopenPairingLinkWithSavedHosts(page, link);
-    await expectAppRoute(page, "/open-project", { timeout: 30_000 });
-    await expect(hostConfirmation(page)).toHaveCount(0);
-  });
+test("a pairing link for a saved host connects without asking", async ({ page }) => {
+  await saveLinkedHostBeforeLoad(page, linkedHost);
+
+  await openPairingLink(page, buildPairingLink(linkedHost));
+
+  await expectAppRoute(page, "/open-project", { timeout: 30_000 });
+  await expect(hostConfirmation(page)).toHaveCount(0);
 });

packages/app/e2e/browser/mermaid-fullscreen.spec.ts

@@ -1,8 +1,6 @@
 import { test } from "../support/fixtures";
 import {
   closeDiagramFullscreen,
-  expectInlineDiagramFitsViewport,
-  toggleDiagramSourceAndVerifyControls,
   closeDiagramFullscreenFromOutside,
   expectCompletedDiagram,
   expectFullscreenDiagram,
@@ -23,36 +21,6 @@ const MERMAID_DIAGRAM = [
   "```",
 ].join("\n");
 
-test("bounds a tall inline diagram", async ({ page }) => {
-  test.setTimeout(120_000);
-  const diagram = [
-    "```mermaid",
-    "flowchart TD",
-    ...Array.from({ length: 30 }, (_, i) => `N${i} --> N${i + 1}`),
-    "```",
-  ].join("\n");
-  const agent = await seedMockAgentWorkspace({
-    repoPrefix: "mermaid-tall-",
-    title: "Tall Mermaid",
-    featureValues: {
-      mockStreamingAssistantResponse: diagram,
-      mockStreamingAssistantIntervalMs: 10,
-    },
-  });
-  try {
-    await openAgentRoute(page, agent);
-    await requestDiagram(agent);
-    await waitForDiagramTurnToComplete(agent);
-    await expectCompletedDiagram(page, ["N0", "N30"]);
-    await expectInlineDiagramFitsViewport(page);
-    await openDiagramFullscreen(page);
-    await expectFullscreenDiagram(page, ["N0", "N30"]);
-    await closeDiagramFullscreen(page);
-  } finally {
-    await agent.cleanup();
-  }
-});
-
 test("opens a Mermaid diagram fullscreen and closes it again", async ({ page }) => {
   test.setTimeout(120_000);
 
@@ -72,10 +40,6 @@ test("opens a Mermaid diagram fullscreen and closes it again", async ({ page })
       await expectCompletedDiagram(page, ["Start", "Ship"]);
     });
 
-    await test.step("Source toggles preserve the diagram and exclude hidden controls", async () => {
-      await toggleDiagramSourceAndVerifyControls(page);
-    });
-
     await test.step("The toolbar opens the diagram fullscreen", async () => {
       await openDiagramFullscreen(page);
       await expectFullscreenDiagram(page, ["Start", "Review", "Ship"]);

packages/app/e2e/browser/new-workspace-live-pin.spec.ts

@@ -1,7 +1,6 @@
 import type { Page } from "@playwright/test";
 import { expect, test } from "../support/fixtures";
 import { gotoAppShell } from "../support/helpers/app";
-import { expectComposerModel } from "../support/helpers/agent-profiles";
 import {
   delayBrowserAgentCreatedStatus,
   openNewWorkspaceComposer,
@@ -70,8 +69,6 @@ test.describe("New workspace live pin", () => {
       await gotoAppShell(page);
       await waitForSidebarHydration(page);
       await openNewWorkspaceComposer(page, seeded);
-      // The composer appears before its provider catalog has hydrated.
-      await expectComposerModel(page, "Ten second stream");
       await submitNewWorkspacePrompt(page, "Pin me while I start");
 
       await creation.waitForCreateRequest();

packages/app/e2e/browser/onboarding.spec.ts

@@ -12,15 +12,11 @@ import {
   openAppAsNewUser,
   openRelayPairingFromSetup,
   closeRelayPairing,
-  emptyHome,
-  loadingScreen,
   openTailscaleDocsFromSetup,
   paseoToolsSwitch,
   pickTheme,
   projectSuggestion,
   projectSuggestionRow,
-  readFirstLaunch,
-  recordFirstLaunch,
   setupModal,
   setupPrimaryButton,
   showSetupAgainFromSettings,
@@ -103,139 +99,6 @@ test("a new user is walked through setup once", async ({ page }, testInfo) => {
   }
 });
 
-test("a new user goes from the loading screen straight into setup", async ({ page }) => {
-  const host = await startSetupHost("first-launch");
-
-  try {
-    await recordFirstLaunch(page);
-    await openAppAsNewUser(page, host);
-    await expectSetupStep(page, "Welcome to Paseo");
-
-    const launch = await readFirstLaunch(page);
-    expect(launch.appBeforeSetup).toBe(false);
-    expect(launch.setupOpacityOnArrival).toBeLessThan(1);
-    await expect(setupModal(page)).toHaveCSS("opacity", "1");
-  } finally {
-    await host.close();
-  }
-});
-
-test("with reduced motion, setup appears without fading in", async ({ page }) => {
-  const host = await startSetupHost("reduced-motion");
-
-  try {
-    await page.emulateMedia({ reducedMotion: "reduce" });
-    await recordFirstLaunch(page);
-    await openAppAsNewUser(page, host);
-    await expectSetupStep(page, "Welcome to Paseo");
-
-    expect((await readFirstLaunch(page)).setupOpacityOnArrival).toBe(1);
-  } finally {
-    await host.close();
-  }
-});
-
-test("changing the theme keeps the setup window in place on every step", async ({ page }) => {
-  const host = await startSetupHost("theme-change");
-
-  try {
-    await openAppAsNewUser(page, host);
-    await expectSetupStep(page, "Welcome to Paseo");
-    const setupWindow = await setupModal(page).elementHandle();
-
-    for (const title of [
-      "Welcome to Paseo",
-      "Your agents",
-      "Add your projects",
-      "Let agents use Paseo",
-      "Take your agents with you",
-    ]) {
-      if (title !== "Welcome to Paseo") await continueSetup(page);
-      await expectSetupStep(page, title);
-      const heading = setupModal(page).getByRole("heading", { name: title });
-      const headingNode = await heading.elementHandle();
-      const lightColor = await heading.evaluate((node) => getComputedStyle(node).color);
-      await page.emulateMedia({ colorScheme: "dark" });
-      await expect(heading).not.toHaveCSS("color", lightColor);
-      await page.emulateMedia({ colorScheme: "light" });
-      await expect(heading).toHaveCSS("color", lightColor);
-      expect(await setupWindow?.evaluate((node) => node.isConnected), title).toBe(true);
-      expect(await headingNode?.evaluate((node) => node.isConnected), title).toBe(true);
-    }
-
-    await goToSetupStep(page, "Appearance");
-    await pickTheme(page, "Midnight");
-    await pickTheme(page, "Light");
-    expect(await setupWindow?.evaluate((node) => node.isConnected)).toBe(true);
-  } finally {
-    await host.close();
-  }
-});
-
-test("the loading screen stays up while the setup host loads its workspaces", async ({ page }) => {
-  const host = await startSetupHost("slow-workspaces");
-  const gate = await installDaemonWebSocketGate(page, { port: host.port });
-
-  try {
-    await recordFirstLaunch(page);
-    gate.holdNextClientRequest("fetch_workspaces_request");
-    await openAppAsNewUser(page, host);
-    await gate.waitForHeldClientRequest();
-    await expect(loadingScreen(page)).toBeVisible();
-    await expect(emptyHome(page)).toHaveCount(0);
-
-    gate.releaseHeldClientRequest();
-    await expectSetupStep(page, "Welcome to Paseo");
-    expect((await readFirstLaunch(page)).appBeforeSetup).toBe(false);
-  } finally {
-    await host.close();
-  }
-});
-
-test("a setup host that never loads its workspaces still lands on the home", async ({ page }) => {
-  const host = await startSetupHost("stuck-workspaces");
-  const gate = await installDaemonWebSocketGate(page, { port: host.port });
-
-  try {
-    gate.holdNextClientRequest("fetch_workspaces_request");
-    await openAppAsNewUser(page, host);
-    await gate.waitForHeldClientRequest();
-    await expect(emptyHome(page)).toBeVisible({ timeout: 15_000 });
-    await expect(setupModal(page)).toHaveCount(0);
-
-    // Setup still opens once the host answers.
-    gate.releaseHeldClientRequest();
-    await expectSetupStep(page, "Welcome to Paseo");
-  } finally {
-    await host.close();
-  }
-});
-
-test("a setup host that drops while loading still lands on the home", async ({ page }) => {
-  const host = await startSetupHost("dropped-workspaces");
-  const gate = await installDaemonWebSocketGate(page, { port: host.port });
-
-  try {
-    gate.holdNextClientRequest("fetch_workspaces_request");
-    await openAppAsNewUser(page, host);
-    await gate.waitForHeldClientRequest();
-    await gate.drop();
-    await expect(emptyHome(page)).toBeVisible({ timeout: 15_000 });
-    await expect(setupModal(page)).toHaveCount(0);
-  } finally {
-    await host.close();
-  }
-});
-
-test("an unreachable setup host lands on the home without setup", async ({ page }) => {
-  const host = await startSetupHost("unreachable");
-  await host.close();
-
-  await openAppAsNewUser(page, host);
-  await expect(emptyHome(page)).toBeVisible({ timeout: 15_000 });
-  await expect(setupModal(page)).toHaveCount(0);
-});
-
 test("setup suggests the repos the user already ran agents in", async ({ page }, testInfo) => {
   const repo = await createTempGitRepo("onboarding-history-");
   const repoName = path.basename(repo.path);

packages/app/e2e/browser/plugin-composers-by-reference.spec.ts

@@ -1,53 +0,0 @@
-import { test } from "../support/fixtures";
-import {
-  CHECKLIST,
-  withComposerToolsExample,
-  withPluginWritingToAnotherWorkspace,
-} from "../support/helpers/plugin-composers-by-reference";
-
-test("a panel in the Explorer inserts at the cursor of the focused agent's composer", async ({
-  page,
-}) => {
-  test.setTimeout(120_000);
-  await withComposerToolsExample(page, async (author) => {
-    await author.openComposerToolsInExplorer();
-    await author.typeInComposer("start end", 5);
-    await author.insertChecklistFromPanel();
-    await author.expectComposerText(`start${CHECKLIST} end`);
-  });
-});
-
-test("a Command Center item changes an agent's metadata through its composer", async ({ page }) => {
-  test.setTimeout(120_000);
-  await withComposerToolsExample(page, async (author) => {
-    await author.openComposerToolsInExplorer();
-    await author.expectPanelShowsReview(false);
-    await author.markForReviewFromCommandCenter();
-    await author.expectPanelShowsReview(true);
-  });
-});
-
-test("the panel follows which agent is focused", async ({ page }) => {
-  test.setTimeout(120_000);
-  await withComposerToolsExample(page, async (author) => {
-    await author.openComposerToolsInExplorer();
-    await author.expectPanelFocusedAgent(true);
-    await author.focusANewAgentTab();
-    await author.expectPanelFocusedAgent(false);
-    await author.focusTheAgentTab();
-    await author.expectPanelFocusedAgent(true);
-  });
-});
-
-test("a plugin writes to an agent's composer while its workspace is not on screen", async ({
-  page,
-}) => {
-  test.setTimeout(120_000);
-  await withPluginWritingToAnotherWorkspace(page, async (author) => {
-    await author.openTargetAgent();
-    await author.goToAnotherWorkspace();
-    await author.insertFromCommandCenter();
-    await author.returnToTargetWorkspace();
-    await author.expectComposerText("A note from a plugin");
-  });
-});

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

@@ -317,10 +317,7 @@ test.describe("Plugin sidebar items", () => {
       const compactSync = footerItem(page, SHOWCASE_PLUGIN_ID, "sync");
       await expect(compactSync).toBeInViewport();
       await expectFooterRow(page, compactSync);
-      // 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 expect(headerRow(page, SHOWCASE_PLUGIN_ID, "deploys")).toBeInViewport();
       await qaScreenshot(page, "phase2-compact-sidebar");
       await qaScreenshot(page, "phase5-compact-footer", sidebarFooter(page));
       await compactSync.click();

packages/app/e2e/browser/plugin-timeline.spec.ts

@@ -24,12 +24,11 @@ for (const width of [1100, 390]) {
       await expectWholeCompletedCard(page);
       // Local state is checked during growth; the viewport remounts on the history handoff.
       const recovery = trackPluginChatRecovery(page);
-      // A chat with a cached cursor answers current and never fetches, so hold the subscribe itself.
-      gate.holdNextClientRequest("agent.timeline.set_subscription.request");
+      gate.holdTimelineResponses(agent.agentId);
       await page.reload({ waitUntil: "domcontentloaded" });
-      await gate.waitForHeldClientRequest();
+      await gate.waitForHeldTimelineResponse();
       await recovery.expectCatalogWithoutRetransmission();
-      gate.releaseHeldClientRequest();
+      gate.releaseHeldTimelineResponses();
       await expectWholeCompletedCard(page);
       await recovery.expectRecoveredWithoutRetransmission();
       recovery.reset();

packages/app/e2e/browser/provider-task-list.real.spec.ts

@@ -1,8 +1,7 @@
-import { mkdirSync, mkdtempSync, realpathSync } from "node:fs";
+import { mkdtempSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import type { Locator } from "@playwright/test";
-import { expect, test, type Page } from "../support/fixtures";
+import { expect, test } from "../support/fixtures";
 import {
   cleanupRewindFlow,
   launchAgent,
@@ -15,11 +14,7 @@ import {
   expectTaskListEntries,
   openCompletedTaskList,
 } from "../support/helpers/task-list";
-import { submitMessage, submitMessageWithButton } from "../support/helpers/composer";
-import { waitForSettledPosition } from "../support/helpers/sheet-layout";
-import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
-import { getServerId } from "../support/helpers/server-id";
-import { gotoAppShell } from "../support/helpers/app";
+import { submitMessage } from "../support/helpers/composer";
 
 interface TaskScenario {
   provider: RewindFlowProvider;
@@ -119,425 +114,3 @@ test.describe("real provider composer task lists", () => {
     }
   });
 });
-
-async function openBackgroundInventory(
-  page: Page,
-  options: { compact: boolean; count: number; timeout: number },
-): Promise<Locator> {
-  const pill = page.getByRole("button", {
-    name: options.count === 1 ? "1 background task" : `${options.count} background tasks`,
-  });
-  await expect(pill).toBeVisible({ timeout: options.timeout });
-  await pill.click();
-  const panel = page.getByTestId(
-    options.compact ? "background-work-panel-content" : "background-work-panel",
-  );
-  if (options.compact) await waitForSettledPosition(panel);
-  return panel;
-}
-
-async function openBackgroundWork(page: Page, compact: boolean): Promise<void> {
-  const panel = await openBackgroundInventory(page, { compact, count: 1, timeout: 30_000 });
-  await expect(panel).toContainText(/sleep 120/);
-}
-
-async function expectBackgroundItems(
-  panel: Locator,
-  selected: string,
-  sibling: string,
-): Promise<void> {
-  await expect(panel).toContainText(selected);
-  await expect(panel).toContainText(sibling);
-}
-
-async function stopBackgroundItem(panel: Locator, selected: string): Promise<void> {
-  const escaped = selected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  await panel.getByRole("button", { name: new RegExp(`Stop .*${escaped}`) }).click();
-}
-
-async function expectStoppedItemAndSibling(
-  panel: Locator,
-  selected: string,
-  sibling: string,
-): Promise<void> {
-  await expect(panel).not.toContainText(selected, { timeout: 40_000 });
-  await expect(panel).toContainText(sibling);
-}
-
-async function closeBackgroundWork(page: Page, compact: boolean): Promise<void> {
-  const panel = page.getByTestId(
-    compact ? "background-work-panel-content" : "background-work-panel",
-  );
-  if (compact) {
-    await page
-      .getByRole("button", { name: "Bottom sheet backdrop" })
-      .click({ position: { x: 12, y: 12 } });
-  } else {
-    await page.keyboard.press("Escape");
-  }
-  await expect(panel).toBeHidden();
-}
-
-async function expectBackgroundAgentRunning(page: Page): Promise<void> {
-  await expect(page.getByTestId("workspace-status-indicator-running").first()).toBeVisible();
-  await expect(page.getByRole("button", { name: "Stop agent", exact: true })).toHaveCount(0);
-}
-
-async function expectAssistantReply(page: Page, text: string): Promise<void> {
-  await expect(page.getByTestId("assistant-message").filter({ hasText: text }).last()).toBeVisible({
-    timeout: 120_000,
-  });
-}
-
-async function expectBackgroundPill(page: Page): Promise<void> {
-  await expect(page.getByRole("button", { name: "1 background task" })).toBeVisible();
-}
-
-async function expectBackgroundWorkOnAnotherClient(page: Page): Promise<void> {
-  const another = await page.context().newPage();
-  try {
-    await another.goto(page.url());
-    await openBackgroundWork(another, false);
-  } finally {
-    await another.close();
-  }
-}
-
-async function startBackgroundWorkWithoutOpeningPane(workspace: SeededWorkspace): Promise<void> {
-  const agent = await workspace.client.createAgent({
-    provider: "claude",
-    model: "haiku",
-    modeId: "bypassPermissions",
-    cwd: workspace.workspaceDirectory,
-    workspaceId: workspace.workspaceId,
-    title: "Background work before opening",
-  });
-  await workspace.client.sendAgentMessage(
-    agent.id,
-    "Use Bash with run_in_background to run exactly sleep 120. Do not wait for it. Reply SPAWNED immediately.",
-  );
-  const result = await workspace.client.waitForFinish(agent.id, 120_000);
-  expect(result.status).toBe("idle");
-}
-
-async function expectWorkspaceRunning(page: Page, workspaceId: string): Promise<void> {
-  const row = page.getByTestId(`sidebar-workspace-row-${getServerId()}:${workspaceId}`);
-  await expect(row.getByTestId("workspace-status-indicator-running")).toBeVisible({
-    timeout: 30_000,
-  });
-}
-
-test("Claude keeps background work visible while accepting another turn", async ({ page }) => {
-  test.setTimeout(300_000);
-  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-background-work-")));
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({ page, provider: "claude", cwd, mode: "full-access" });
-    await sendMessage(
-      handle,
-      "Use Bash with run_in_background to run exactly sleep 120. Do not wait for it. Reply SPAWNED immediately.",
-    );
-    await expectBackgroundAgentRunning(page);
-    await openBackgroundWork(page, false);
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/phase1-claude-background.png"),
-      animations: "disabled",
-    });
-    await closeBackgroundWork(page, false);
-    await sendMessage(handle, "Reply exactly HELLO without stopping the background command.");
-    await expectBackgroundPill(page);
-    await expectBackgroundWorkOnAnotherClient(page);
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});
-
-test("Claude background work remains readable in dark mode", async ({ page }) => {
-  test.setTimeout(300_000);
-  await page.addInitScript(() => {
-    localStorage.setItem("@paseo:app-settings", JSON.stringify({ theme: "pureBlack" }));
-  });
-  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-background-dark-")));
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({ page, provider: "claude", cwd, mode: "full-access" });
-    await sendMessage(
-      handle,
-      "Use Bash with run_in_background to run exactly sleep 120. Do not wait for it. Reply SPAWNED immediately.",
-    );
-    await openBackgroundWork(page, false);
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/review-background-dark.png"),
-      animations: "disabled",
-    });
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});
-
-test("Claude background work opens in a compact sheet", async ({ page }) => {
-  test.setTimeout(300_000);
-  await page.setViewportSize({ width: 390, height: 844 });
-  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-background-compact-")));
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({ page, provider: "claude", cwd, mode: "full-access" });
-    await submitMessageWithButton(
-      page,
-      "Use Bash with run_in_background to run exactly sleep 120. Do not wait for it. Reply SPAWNED immediately.",
-    );
-    await expectAssistantReply(page, "SPAWNED");
-    await openBackgroundWork(page, true);
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/phase1-claude-compact.png"),
-      animations: "disabled",
-    });
-    await closeBackgroundWork(page, true);
-    await submitMessageWithButton(
-      page,
-      "Reply exactly HELLO without stopping the background command.",
-    );
-    await expectAssistantReply(page, "HELLO");
-    await expectBackgroundPill(page);
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});
-
-test("background work updates the sidebar before the agent is opened", async ({ page }) => {
-  test.setTimeout(300_000);
-  const workspace = await seedWorkspace({ repoPrefix: "background-unopened-" });
-  try {
-    await gotoAppShell(page);
-    await expect(
-      page.getByTestId(`sidebar-workspace-row-${getServerId()}:${workspace.workspaceId}`),
-    ).toBeVisible();
-    await startBackgroundWorkWithoutOpeningPane(workspace);
-    await expectWorkspaceRunning(page, workspace.workspaceId);
-  } finally {
-    await workspace.cleanup();
-  }
-});
-
-test("Codex keeps a live command visible after its turn", async ({ page }) => {
-  test.setTimeout(300_000);
-  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-codex-background-")));
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({
-      page,
-      provider: "codex",
-      cwd,
-      mode: "full-access",
-      providerConfig: { model: "gpt-6-astra" },
-    });
-    await sendMessage(
-      handle,
-      "Use exec_command to run sleep 120 with yield_time_ms 1000. Do not wait for or stop it. Reply SPAWNED immediately.",
-    );
-    await expectBackgroundAgentRunning(page);
-    await openBackgroundWork(page, false);
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/phase2-codex-background.png"),
-      animations: "disabled",
-    });
-    await closeBackgroundWork(page, false);
-    await sendMessage(handle, "Reply exactly HELLO without stopping the background command.");
-    await expectBackgroundPill(page);
-    await expectBackgroundWorkOnAnotherClient(page);
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});
-
-test("OpenCode keeps a live command visible after its turn", async ({ page }) => {
-  test.setTimeout(300_000);
-  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-opencode-background-")));
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({
-      page,
-      provider: "opencode",
-      cwd,
-      mode: "full-access",
-      providerConfig: { model: "openrouter/google/gemini-3.6-flash" },
-    });
-    await sendMessage(
-      handle,
-      "Use the shell tool with background true to run sleep 120. Do not wait or stop it. Reply SPAWNED immediately.",
-    );
-    await expectBackgroundAgentRunning(page);
-    await openBackgroundWork(page, false);
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/phase2-opencode-background.png"),
-      animations: "disabled",
-    });
-    await closeBackgroundWork(page, false);
-    await sendMessage(handle, "Reply exactly HELLO without stopping the background command.");
-    await expectBackgroundPill(page);
-    await expectBackgroundWorkOnAnotherClient(page);
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});
-
-for (const scenario of [
-  {
-    provider: "claude" as const,
-    prompt:
-      "Use Bash with run_in_background to start sleep 180 and sleep 181 as two separate background commands. Do not wait for them. Reply SPAWNED immediately.",
-    providerConfig: { model: "haiku" },
-  },
-  {
-    provider: "codex" as const,
-    prompt:
-      "Use exec_command twice to start sleep 180 and sleep 181 separately with yield_time_ms 1000. Do not wait for or stop either process. Reply SPAWNED immediately.",
-    providerConfig: { model: "gpt-6-astra" },
-  },
-  {
-    provider: "opencode" as const,
-    prompt:
-      "Use the shell tool twice with background true: start sleep 180, then start sleep 181. Do not wait for or stop either. Reply SPAWNED immediately.",
-    providerConfig: { model: "openrouter/google/gemini-3.6-flash" },
-  },
-]) {
-  test(`${scenario.provider} stops selected background work after the turn`, async ({ page }) => {
-    test.setTimeout(300_000);
-    mkdirSync(path.resolve("../../.artifacts"), { recursive: true });
-    const cwd = realpathSync(mkdtempSync(path.resolve("../../.artifacts/phase3-qa-workspace-")));
-    let handle: AgentHandle | undefined;
-    try {
-      handle = await launchAgent({
-        page,
-        provider: scenario.provider,
-        cwd,
-        mode: "full-access",
-        providerConfig: scenario.providerConfig,
-      });
-      await sendMessage(handle, scenario.prompt);
-      const panel = await openBackgroundInventory(page, {
-        compact: false,
-        count: 2,
-        timeout: 60_000,
-      });
-      await expectBackgroundItems(panel, "sleep 180", "sleep 181");
-      await stopBackgroundItem(panel, "sleep 180");
-      await expectStoppedItemAndSibling(panel, "sleep 180", "sleep 181");
-      await page.screenshot({
-        path: path.resolve(`../../.artifacts/phase3-${scenario.provider}-stop.png`),
-        animations: "disabled",
-      });
-      await page.keyboard.press("Escape");
-      await sendMessage(handle, "Reply exactly HELLO without stopping the background command.");
-      await expectBackgroundPill(page);
-    } finally {
-      await cleanupRewindFlow({ handle, cwd });
-    }
-  });
-}
-
-test("Claude stops a selected monitor in the compact sheet", async ({ page }) => {
-  test.setTimeout(300_000);
-  await page.setViewportSize({ width: 390, height: 844 });
-  mkdirSync(path.resolve("../../.artifacts"), { recursive: true });
-  const cwd = realpathSync(mkdtempSync(path.resolve("../../.artifacts/phase3-monitor-workspace-")));
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({
-      page,
-      provider: "claude",
-      cwd,
-      mode: "full-access",
-      providerConfig: { model: "opus" },
-    });
-    await submitMessageWithButton(
-      page,
-      'Use exactly two separate Monitor tool calls, each with command `sleep 150`, timeout_ms 150000, persistent false, descriptions "probe monitor one" and "probe monitor two". Launch both independently, do not wait, then reply SPAWNED. Do not use any other tools.',
-    );
-    await expectAssistantReply(page, "SPAWNED");
-    const panel = await openBackgroundInventory(page, { compact: true, count: 2, timeout: 30_000 });
-    await expectBackgroundItems(panel, "probe monitor one", "probe monitor two");
-    await expect(panel.getByText("sleep 150", { exact: true })).toHaveCount(2);
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/refinement-monitor-compact.png"),
-      animations: "disabled",
-    });
-    await stopBackgroundItem(panel, "probe monitor one");
-    await expectStoppedItemAndSibling(panel, "probe monitor one", "probe monitor two");
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/phase3-claude-monitor-compact.png"),
-      animations: "disabled",
-    });
-    await closeBackgroundWork(page, true);
-    await submitMessageWithButton(
-      page,
-      "Reply exactly HELLO without stopping the background monitor.",
-    );
-    await expectAssistantReply(page, "HELLO");
-    await expectBackgroundPill(page);
-    await handle.client.sendAgentMessage(
-      handle.agentId,
-      "Use Bash to run sleep 20 in the foreground, then reply WAITED.",
-    );
-    await expect(page.getByRole("button", { name: "Stop agent", exact: true })).toBeVisible({
-      timeout: 30_000,
-    });
-    await handle.client.sendAgentMessage(
-      handle.agentId,
-      "Reply exactly INTERRUPTED without stopping the background monitor.",
-      { activeTurnBehavior: "interrupt" },
-    );
-    expect((await handle.client.waitForFinish(handle.agentId, 120_000)).status).toBe("idle");
-    await expectBackgroundPill(page);
-    await expect
-      .poll(async () => handle!.client.listAgentBackgroundWork(handle!.agentId))
-      .toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({ description: "probe monitor two", kind: "monitor" }),
-        ]),
-      );
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});
-
-test("Claude shows monitor description and command in the wide track", async ({ page }) => {
-  test.setTimeout(300_000);
-  const cwd = realpathSync(
-    mkdtempSync(path.resolve("../../.artifacts/refinement-wide-workspace-")),
-  );
-  let handle: AgentHandle | undefined;
-  try {
-    handle = await launchAgent({
-      page,
-      provider: "claude",
-      cwd,
-      mode: "full-access",
-      providerConfig: { model: "opus" },
-    });
-    await sendMessage(
-      handle,
-      'Use Monitor with command `sleep 150`, timeout_ms 150000, persistent false, description "Watch the build". Do not wait; reply SPAWNED. Do not use other tools.',
-    );
-    await expectBackgroundAgentRunning(page);
-    const workspaceRow = page.getByTestId(
-      `sidebar-workspace-row-${getServerId()}:${handle.workspaceId}`,
-    );
-    await workspaceRow.scrollIntoViewIfNeeded();
-    await expect(workspaceRow.getByTestId("workspace-status-indicator-running")).toBeVisible();
-    const panel = await openBackgroundInventory(page, {
-      compact: false,
-      count: 1,
-      timeout: 30_000,
-    });
-    await expect(panel).toContainText("Watch the build");
-    await expect(panel).toContainText("sleep 150");
-    await expect(panel.getByRole("button", { name: "Stop Watch the build" })).toBeVisible();
-    await page.screenshot({
-      path: path.resolve("../../.artifacts/refinement-monitor-wide.png"),
-      animations: "disabled",
-    });
-  } finally {
-    await cleanupRewindFlow({ handle, cwd });
-  }
-});

packages/app/e2e/browser/schedules-edit-model-hydration.spec.ts

@@ -79,9 +79,7 @@ test.describe("Schedules", () => {
     cleanupTasks.length = 0;
   });
 
-  test("hydrates schedule editing and opens a pristine creation form afterward", async ({
-    page,
-  }) => {
+  test("edit form hydrates the scheduled model selection", async ({ page }) => {
     const workspace = await seedWorkspace({ repoPrefix: "schedule-model-hydration-" });
     cleanupTasks.push(() => workspace.cleanup());
     const scheduleName = `Hydrate model ${Date.now()}`;
@@ -95,45 +93,29 @@ test.describe("Schedules", () => {
 
     await row.click();
     const formSheet = page.getByTestId("schedule-form-sheet");
+    await expect(formSheet).toBeVisible({ timeout: 10_000 });
+    await expectStableHeight(formSheet);
     const hostTrigger = page.getByTestId("schedule-host-trigger");
     const projectTrigger = page.getByTestId("schedule-project-trigger");
     const modelTrigger = page.getByTestId("schedule-model-trigger");
     const thinkingTrigger = page.getByTestId("schedule-thinking-trigger");
     const modeTrigger = page.getByTestId("schedule-mode-trigger");
-    await test.step("edit form hydrates the saved model and controls", async () => {
-      await expect(formSheet).toBeVisible({ timeout: 10_000 });
-      await expectStableHeight(formSheet);
-      await expect(hostTrigger).toBeVisible({ timeout: 30_000 });
-      await expect(hostTrigger).toBeDisabled();
-      await expectSettled(hostTrigger);
-      await expect(projectTrigger).toContainText(workspace.projectDisplayName, { timeout: 30_000 });
-      await expectSettled(projectTrigger);
-      await expect(modelTrigger).toContainText("Ten second stream", { timeout: 30_000 });
-      await expectSettled(modelTrigger);
-      await expect(thinkingTrigger).toContainText("Low");
-      await expectSettled(thinkingTrigger);
-      await expect(modeTrigger).toBeVisible({ timeout: 30_000 });
-      await expectSettled(modeTrigger);
-      await expect(page.getByTestId("cadence-mode")).toHaveCount(0);
-      await expect(page.getByTestId("cadence-interval-value")).toHaveCount(0);
-      await expect(page.getByTestId("schedule-cadence-preset-trigger")).toContainText("Daily 9:00");
-      await expect(page.getByText(/Times are in/)).toHaveCount(0);
-      await expect(formSheet.getByText("Cron", { exact: true })).toHaveCount(0);
-    });
-
-    await test.step("closing edit leaves the new schedule form pristine", async () => {
-      await page.getByRole("button", { name: "Cancel" }).click();
-      await expect(formSheet).toHaveCount(0, { timeout: 30_000 });
-
-      await page.getByTestId("schedules-new").click();
-      await expect(formSheet).toBeVisible({ timeout: 10_000 });
-      await expect(projectTrigger).toContainText(/select project/i);
-      await expectSettled(projectTrigger);
-      await expect(page.getByTestId("schedule-model-trigger")).toHaveCount(0);
-      await expect(page.getByTestId("schedule-thinking-trigger")).toHaveCount(0);
-      await expect(page.getByTestId("schedule-mode-trigger")).toHaveCount(0);
-      await expect(page.getByTestId("cadence-interval-value")).toHaveCount(0);
-    });
+    await expect(hostTrigger).toBeVisible({ timeout: 30_000 });
+    await expect(hostTrigger).toBeDisabled();
+    await expectSettled(hostTrigger);
+    await expect(projectTrigger).toContainText(workspace.projectDisplayName, { timeout: 30_000 });
+    await expectSettled(projectTrigger);
+    await expect(modelTrigger).toContainText("Ten second stream", { timeout: 30_000 });
+    await expectSettled(modelTrigger);
+    await expect(thinkingTrigger).toContainText("Low");
+    await expectSettled(thinkingTrigger);
+    await expect(modeTrigger).toBeVisible({ timeout: 30_000 });
+    await expectSettled(modeTrigger);
+    await expect(page.getByTestId("cadence-mode")).toHaveCount(0);
+    await expect(page.getByTestId("cadence-interval-value")).toHaveCount(0);
+    await expect(page.getByTestId("schedule-cadence-preset-trigger")).toContainText("Daily 9:00");
+    await expect(page.getByText(/Times are in/)).toHaveCount(0);
+    await expect(formSheet.getByText("Cron", { exact: true })).toHaveCount(0);
   });
 
   test("edit form hydrates a non-default host schedule after reload", async ({ page }) => {
@@ -183,4 +165,32 @@ test.describe("Schedules", () => {
     await expect(page.getByTestId("cadence-mode")).toHaveCount(0);
     await expect(page.getByTestId("schedule-cadence-preset-trigger")).toContainText("Daily 9:00");
   });
+
+  test("create opens pristine after closing an edit form", async ({ page }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "schedule-pristine-create-" });
+    cleanupTasks.push(() => workspace.cleanup());
+    const scheduleName = `Pristine create ${Date.now()}`;
+    const scheduleId = await seedMockSchedule(workspace, scheduleName);
+    cleanupTasks.push(() => deleteSeededSchedule(workspace, scheduleId));
+
+    await page.goto(buildSchedulesRoute());
+    const row = page.getByTestId(`schedule-row-${scheduleId}`);
+    await expect(row).toBeVisible({ timeout: 30_000 });
+    await row.click();
+    const formSheet = page.getByTestId("schedule-form-sheet");
+    await expect(formSheet).toBeVisible({ timeout: 10_000 });
+    await expectStableHeight(formSheet);
+    await page.getByRole("button", { name: "Cancel" }).click();
+    await expect(formSheet).toHaveCount(0, { timeout: 30_000 });
+
+    await page.getByTestId("schedules-new").click();
+    await expect(formSheet).toBeVisible({ timeout: 10_000 });
+    const projectTrigger = page.getByTestId("schedule-project-trigger");
+    await expect(projectTrigger).toContainText(/select project/i);
+    await expectSettled(projectTrigger);
+    await expect(page.getByTestId("schedule-model-trigger")).toHaveCount(0);
+    await expect(page.getByTestId("schedule-thinking-trigger")).toHaveCount(0);
+    await expect(page.getByTestId("schedule-mode-trigger")).toHaveCount(0);
+    await expect(page.getByTestId("cadence-interval-value")).toHaveCount(0);
+  });
 });

packages/app/e2e/browser/sessions-search.spec.ts

@@ -60,15 +60,6 @@ async function verifyChronologicalFiltering(page: Page): Promise<void> {
   });
 }
 
-async function verifyHistorySurvivesReload(page: Page): Promise<void> {
-  await test.step("reloads History without visiting a workspace to reconnect", async () => {
-    await expectVisibleTitles(page, [TITLES.unbilled, TITLES.billing, TITLES.terminal]);
-    await page.reload();
-    await expectVisibleTitles(page, [TITLES.unbilled, TITLES.billing, TITLES.terminal]);
-    await expect(page.getByTestId("sessions-host-errors")).toBeHidden();
-  });
-}
-
 async function verifyRecencyBeforeMatchStrength(page: Page): Promise<void> {
   await test.step("keeps newer partial matches before older stronger matches", async () => {
     await search(page, `${NONCE} bill`);
@@ -160,8 +151,6 @@ test.describe("History search", () => {
 
       await verifyChronologicalFiltering(page);
 
-      await verifyHistorySurvivesReload(page);
-
       await verifyRecencyBeforeMatchStrength(page);
 
       await verifyExactAndTypoHighlights(page);

packages/app/e2e/browser/settings-navigation.spec.ts

@@ -95,63 +95,66 @@ test.describe("Settings sidebar scroll position", () => {
     await expectSettingsSidebarScrollOffset(page, offset);
   });
 
-  test("keeps sidebar and detail scrolling independent through section changes", async ({
+  test("scrolls the sidebar and detail pane independently", async ({ page }) => {
+    await gotoAppShell(page);
+    await openSettings(page);
+    const sidebarOffset = await scrollSettingsSidebarToEnd(page);
+    await openSettingsHostSection(page, getServerId(), "providers");
+    await expect(page.getByTestId("host-page-providers-card")).toBeVisible();
+    const detailOffset = await scrollSettingsDetailDown(page);
+    await expectSettingsSidebarScrollOffset(page, sidebarOffset);
+
+    await scrollSettingsSidebarUp(page, 60);
+    await expectSettingsSidebarScrollOffset(page, sidebarOffset - 60);
+    await expectSettingsDetailScrollOffset(page, detailOffset);
+  });
+
+  test("keeps the sidebar position after rapid consecutive selections", async ({ page }) => {
+    await gotoAppShell(page);
+    await openSettings(page);
+
+    const scrollTop = await scrollSettingsSidebarToEnd(page);
+
+    await selectSettingsHostSectionsRapidly(page);
+    await expectSettingsSidebarScrollOffset(page, scrollTop);
+
+    await expectSettingsSidebarScrollSettled(page, scrollTop);
+  });
+
+  test("keeps the sidebar position when switching between app and host sections", async ({
     page,
   }) => {
     await gotoAppShell(page);
     await openSettings(page);
 
-    await test.step("scrolls the sidebar and detail pane independently", async () => {
-      const sidebarOffset = await scrollSettingsSidebarToEnd(page);
-      await openSettingsHostSection(page, getServerId(), "providers");
-      await expect(page.getByTestId("host-page-providers-card")).toBeVisible();
-      const detailOffset = await scrollSettingsDetailDown(page);
-      await expectSettingsSidebarScrollOffset(page, sidebarOffset);
+    const hostScrollTop = await scrollSettingsSidebarToEnd(page);
+    await expect(page.getByTestId("settings-host-section-providers")).toBeInViewport();
 
-      await scrollSettingsSidebarUp(page, 60);
-      await expectSettingsSidebarScrollOffset(page, sidebarOffset - 60);
-      await expectSettingsDetailScrollOffset(page, detailOffset);
-    });
+    for (const section of [
+      "providers",
+      "terminals",
+      "providers",
+      "terminals",
+      "providers",
+    ] as const) {
+      await openSettingsHostSection(page, getServerId(), section);
+      await expect(page.getByTestId("page-title")).toHaveText(
+        section === "providers" ? "Providers" : "Terminals",
+      );
+      await expectSettingsSidebarScrollOffset(page, hostScrollTop);
+    }
 
-    await test.step("keeps the sidebar position after rapid consecutive selections", async () => {
-      const scrollTop = await scrollSettingsSidebarToEnd(page);
+    const sidebar = page.getByTestId("settings-sidebar");
+    const appScrollTop = await revealSettingsSidebarSection(page, "diagnostics");
+    await expect(sidebar.getByRole("button", { name: "About", exact: true })).toBeInViewport();
 
-      await selectSettingsHostSectionsRapidly(page);
-      await expectSettingsSidebarScrollOffset(page, scrollTop);
+    await openSettingsSection(page, "about");
+    await expectAboutContent(page);
+    await expectSettingsSidebarScrollOffset(page, appScrollTop);
 
-      await expectSettingsSidebarScrollSettled(page, scrollTop);
-    });
-
-    await test.step("keeps the sidebar position when switching between app and host sections", async () => {
-      const hostScrollTop = await scrollSettingsSidebarToEnd(page);
-      await expect(page.getByTestId("settings-host-section-providers")).toBeInViewport();
-
-      for (const section of [
-        "providers",
-        "terminals",
-        "providers",
-        "terminals",
-        "providers",
-      ] as const) {
-        await openSettingsHostSection(page, getServerId(), section);
-        await expect(page.getByTestId("page-title")).toHaveText(
-          section === "providers" ? "Providers" : "Terminals",
-        );
-        await expectSettingsSidebarScrollOffset(page, hostScrollTop);
-      }
-
-      const sidebar = page.getByTestId("settings-sidebar");
-      const appScrollTop = await revealSettingsSidebarSection(page, "diagnostics");
-      await expect(sidebar.getByRole("button", { name: "About", exact: true })).toBeInViewport();
-
-      await openSettingsSection(page, "about");
-      await expectAboutContent(page);
-      await expectSettingsSidebarScrollOffset(page, appScrollTop);
-
-      await openSettingsSection(page, "diagnostics");
-      await expectDiagnosticsContent(page);
-      await expectSettingsSidebarScrollOffset(page, appScrollTop);
-    });
+    await openSettingsSection(page, "diagnostics");
+    await expectDiagnosticsContent(page);
+    await expectSettingsSidebarScrollOffset(page, appScrollTop);
   });
 });
 

packages/app/e2e/browser/sidebar-footer-overflow.spec.ts

@@ -1,127 +0,0 @@
-import { expect, test } from "../support/fixtures";
-import { addProjectFlow } from "../support/helpers/add-project-flow";
-import { gotoAppShell } from "../support/helpers/app";
-import {
-  chooseFooterOverflowAction,
-  expectFooterLine,
-  expectFooterMenusInsideViewport,
-  expectFooterNeverClipped,
-  expectFooterOverflowActions,
-  footerOverflowMenu,
-  openFooterOverflow,
-  seedDockedSidebarWidth,
-  watchFooterClipping,
-} from "../support/helpers/sidebar-footer-overflow";
-import { addOfflineHostsAndReload } from "../support/helpers/hosts";
-import { openCompactSidebar } from "../support/helpers/usage-sidebar-item";
-
-const TOUCH_CONTROL = 44;
-const MIN_SIDEBAR_WIDTH = 200;
-const ALL_INLINE = [
-  "sidebar-add-project",
-  "sidebar-usage-icon",
-  "sidebar-hosts-trigger",
-  "sidebar-help",
-  "sidebar-settings",
-];
-// Five 44pt buttons and the row's padding need 236pt; 200pt holds three and the caret.
-const NARROW_TOUCH_LINE = [
-  "sidebar-add-project",
-  "sidebar-hosts-trigger",
-  "sidebar-footer-overflow",
-  "sidebar-settings",
-];
-
-test.describe("Sidebar footer on a touch screen", () => {
-  test.use({ viewport: { width: 1280, height: 800 }, hasTouch: true });
-
-  test("a narrow docked sidebar moves the actions it can't fit behind a caret", async ({
-    page,
-  }) => {
-    await seedDockedSidebarWidth(page, MIN_SIDEBAR_WIDTH);
-    await watchFooterClipping(page);
-    await gotoAppShell(page);
-    await expectFooterLine(page, { testIDs: NARROW_TOUCH_LINE, controlSize: TOUCH_CONTROL });
-    await expectFooterNeverClipped(page);
-
-    await test.step("Help opens as a page of the overflow menu", async () => {
-      await openFooterOverflow(page);
-      await expectFooterOverflowActions(page, ["Usage", "Help and support"]);
-      await chooseFooterOverflowAction(page, "Help and support");
-      await expect(page.getByRole("menuitem", { name: "What's new" })).toBeVisible();
-      await expect(page.getByTestId("sidebar-help-menu")).toHaveCount(0);
-      await page.keyboard.press("Escape");
-      await expect(footerOverflowMenu(page)).toBeHidden();
-    });
-
-    await test.step("Usage opens from the overflow menu", async () => {
-      await openFooterOverflow(page);
-      await chooseFooterOverflowAction(page, "Usage");
-      await expect(footerOverflowMenu(page)).toBeHidden();
-      await expect(page.getByTestId("usage-modal")).toBeVisible();
-      await page.keyboard.press("Escape");
-      await expect(page.getByTestId("usage-modal")).toBeHidden();
-    });
-
-    await test.step("Add project and Settings shortcuts still work", async () => {
-      await page.keyboard.press("Control+o");
-      await expect(addProjectFlow(page)).toBeVisible();
-      await page.keyboard.press("Escape");
-      await expect(addProjectFlow(page)).toBeHidden();
-      await page.keyboard.press("Control+,");
-      await expect(page).toHaveURL(/\/settings\/general$/);
-    });
-  });
-
-  test("the default sidebar width keeps all five actions inline", async ({ page }) => {
-    await gotoAppShell(page);
-    await expectFooterLine(page, { testIDs: ALL_INLINE, controlSize: TOUCH_CONTROL });
-  });
-});
-
-test.describe("Sidebar footer in a compact overlay narrower than the footer", () => {
-  test.use({ viewport: { width: 220, height: 800 }, hasTouch: true });
-
-  test("the overflow menu reaches the hidden actions", async ({ page }) => {
-    await watchFooterClipping(page);
-    await gotoAppShell(page);
-    await openCompactSidebar(page);
-    await expectFooterLine(page, { testIDs: NARROW_TOUCH_LINE, controlSize: TOUCH_CONTROL });
-    await expectFooterNeverClipped(page);
-    await openFooterOverflow(page);
-    await expectFooterOverflowActions(page, ["Usage", "Help and support"]);
-    await expectFooterMenusInsideViewport(page);
-  });
-});
-
-test.describe("Sidebar footer on a short, narrow phone", () => {
-  // 164pt for buttons holds Settings, Add project and the caret, so Hosts moves behind it.
-  test.use({ viewport: { width: 180, height: 360 }, hasTouch: true });
-
-  test("the overflow Hosts page scrolls to its last host and Add host", async ({ page }) => {
-    await gotoAppShell(page);
-    await addOfflineHostsAndReload(
-      page,
-      Array.from({ length: 10 }, (_, index) => ({
-        serverId: `overflow-host-${index}`,
-        label: `Overflow host ${index}`,
-      })),
-    );
-    await openCompactSidebar(page);
-    await expectFooterLine(page, {
-      testIDs: ["sidebar-add-project", "sidebar-footer-overflow", "sidebar-settings"],
-      controlSize: TOUCH_CONTROL,
-    });
-    await openFooterOverflow(page);
-    await expectFooterOverflowActions(page, ["Usage", "Hosts", "Help and support"]);
-    await expectFooterMenusInsideViewport(page);
-    await chooseFooterOverflowAction(page, "Hosts");
-    await expectFooterMenusInsideViewport(page);
-    const addHost = page.getByRole("menuitem", { name: "Add host" });
-    await addHost.scrollIntoViewIfNeeded();
-    await expect(page.getByRole("menuitem", { name: "Overflow host 9" })).toBeVisible();
-    await expect(addHost).toBeInViewport();
-    await addHost.click();
-    await expect(page.getByText("Add connection", { exact: true })).toBeVisible();
-  });
-});

packages/app/e2e/browser/sidebar-nav-settings.spec.ts

@@ -97,7 +97,6 @@ test("fixed footer line keeps its five icons, Help and Settings at the end", asy
   await setFooterItemVisible(page, "usage", true);
   await leaveSettings(page);
   await page.setViewportSize({ width: 390, height: 844 });
-  await openCompactSidebar(page);
   await expectCompactSidebarOpen(page);
   await expectFooterSeparator(page, true);
   await expectFooterIconRow(page);

packages/app/e2e/browser/sidebar-views.spec.ts

@@ -1,18 +0,0 @@
-import { test } from "../support/fixtures";
-import { withSidebarViews } from "../support/helpers/sidebar-views";
-
-test("sidebar views replace the content, preserve chrome, and recover to the default", async ({
-  page,
-}) => {
-  test.setTimeout(150_000);
-  await withSidebarViews(page, async (views) => {
-    await views.expectDefault();
-    await views.chooseWorkspaces();
-    await views.exerciseExamples();
-    await views.exerciseTerminals();
-    await views.restoreDefault();
-    await views.recoverFromFailure();
-    await views.chooseWorkspaces();
-    await views.disableChosenView();
-  });
-});

packages/app/e2e/browser/sidebar-workspace-mark-unread.spec.ts

@@ -1,13 +1,12 @@
 import type { Page } from "@playwright/test";
 import { test as base, expect } from "../support/fixtures";
+import { gotoAppShell } from "../support/helpers/app";
 import {
   openAgentRoute,
   seedMockAgentWorkspace,
   type MockAgentWorkspace,
 } from "../support/helpers/mock-agent";
 import { expectOpenTabCount } from "../support/helpers/sheet";
-import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
-import { expectReconnectingToastGone } from "../support/helpers/workspace-ui";
 import { getServerId } from "../support/helpers/server-id";
 import { closeMobileAgentSidebar, openMobileAgentSidebar } from "../support/helpers/sidebar";
 
@@ -102,13 +101,11 @@ async function leaveMarkedWorkspaceAndReopen(page: Page, { subject, other }: Fin
 }
 
 async function completeTurnAndLeave(page: Page, { subject, other }: FinishedWorkspaces) {
-  await test.step("ordinary completion stays unread on departure and clears on return", async () => {
+  await test.step("ordinary completion still clears on departure", async () => {
     await subject.client.sendAgentMessage(subject.agentId, "Finish another turn.");
     await subject.client.waitForFinish(subject.agentId, 20_000);
     await expectStatus(page, subject.workspaceId, "attention");
     await openWorkspace(page, other.workspaceId);
-    await expectStatus(page, subject.workspaceId, "attention");
-    await openWorkspace(page, subject.workspaceId);
     await expectStatus(page, subject.workspaceId, "done");
   });
 }
@@ -144,15 +141,13 @@ async function leaveMarkedWorkspaceAndReopenOnCompact(
 }
 
 async function completeTurnAndLeaveOnCompact(page: Page, { subject, other }: FinishedWorkspaces) {
-  await test.step("ordinary completion stays unread on departure and clears on return", async () => {
+  await test.step("ordinary completion still clears on departure", async () => {
     await closeMobileAgentSidebar(page);
     await subject.client.sendAgentMessage(subject.agentId, "Finish another turn.");
     await subject.client.waitForFinish(subject.agentId, 20_000);
     await openMobileAgentSidebar(page);
     await expectStatus(page, subject.workspaceId, "attention");
     await openWorkspaceOnCompact(page, other.workspaceId);
-    await expectStatus(page, subject.workspaceId, "attention");
-    await openWorkspaceOnCompact(page, subject.workspaceId);
     await expectStatus(page, subject.workspaceId, "done");
   });
 }
@@ -199,12 +194,11 @@ async function markUnreadThenResumeChat(page: Page, workspaceId: string) {
   });
 }
 
-test("manual unread survives departure and clears on reopening and ordinary completion survives departure", async ({
+test("manual unread survives departure and clears on reopening without changing normal completions", async ({
   page,
   workspaces,
 }) => {
-  await openAgentRoute(page, workspaces.subject);
-  await expect(page.getByText("Finish this turn.", { exact: true })).toBeVisible();
+  await gotoAppShell(page);
   await openWorkspace(page, workspaces.other.workspaceId);
   await markBackgroundWorkspaceAndReopen(page, workspaces.subject.workspaceId);
   await leaveMarkedWorkspaceAndRead(page, workspaces);
@@ -213,19 +207,16 @@ test("manual unread survives departure and clears on reopening and ordinary comp
   await markBackgroundWorkspaceAndRead(page, workspaces.subject.workspaceId);
 });
 
-test("clicking a multi-agent workspace preserves its selected agent and leaves the other unread", async ({
+test("clicking a multi-agent workspace reveals and clears its marked agent", async ({
   page,
   workspaces,
 }) => {
   await openAgentRoute(page, workspaces.subject);
-  await expect(page.getByText("Finish this turn.", { exact: true })).toBeVisible();
   await expectSelectedAgent(page, workspaces.subject.agentId);
   await openWorkspace(page, workspaces.other.workspaceId);
-  await addFinishedAgent(workspaces.subject);
-  await markAsUnread(page, workspaces.subject.workspaceId);
-  await openWorkspace(page, workspaces.subject.workspaceId);
-  await expectSelectedAgent(page, workspaces.subject.agentId);
-  await expectStatus(page, workspaces.subject.workspaceId, "attention");
+  const newest = await addFinishedAgent(workspaces.subject);
+  await markBackgroundWorkspaceAndReopen(page, workspaces.subject.workspaceId);
+  await expectSelectedAgent(page, newest.id);
 });
 
 test("manual unread survives leaving the current workspace on compact layout", async ({
@@ -239,7 +230,7 @@ test("manual unread survives leaving the current workspace on compact layout", a
   await completeTurnAndLeaveOnCompact(page, workspaces);
 });
 
-async function reopenWorkspaceAfterBackgroundTurn(page: Page, workspace: MockAgentWorkspace) {
+async function reopenMarkedWorkspaceAfterBackgroundTurn(page: Page, workspace: MockAgentWorkspace) {
   const route = page.url();
   // End this app session before the turn, so its cached transcript cannot contain the new prompt.
   await page.goto("about:blank");
@@ -274,68 +265,9 @@ test("reopening a marked unread workspace restores only its agent tab and curren
   await test.step("mark the current workspace unread, then close and reopen the app", async () => {
     await openMobileAgentSidebar(page);
     await markAsUnread(page, workspaces.subject.workspaceId);
-    await reopenWorkspaceAfterBackgroundTurn(page, workspaces.subject);
+    await reopenMarkedWorkspaceAfterBackgroundTurn(page, workspaces.subject);
   });
   await test.step("restore the main tab without Explorer entries and load its latest history", async () => {
     await expectRestoredCompactChat(page);
   });
 });
-
-test("clicking the already focused timeline acknowledges a new completion", async ({
-  page,
-  workspaces,
-}) => {
-  await openAgentRoute(page, workspaces.subject);
-  await expect(page.getByText("Finish this turn.", { exact: true })).toBeVisible();
-  await workspaces.subject.client.sendAgentMessage(
-    workspaces.subject.agentId,
-    "Finish another turn.",
-  );
-  await workspaces.subject.client.waitForFinish(workspaces.subject.agentId, 20_000);
-  await expectStatus(page, workspaces.subject.workspaceId, "attention");
-  await page.getByText("Finish another turn.", { exact: true }).click();
-  await expectStatus(page, workspaces.subject.workspaceId, "done");
-});
-
-async function reconnectWithoutInteracting(
-  page: Page,
-  gate: Awaited<ReturnType<typeof installDaemonWebSocketGate>>,
-) {
-  await gate.drop();
-  await gate.waitForBlockedConnection();
-  gate.restore();
-  await expectReconnectingToastGone(page);
-  await expect(page.getByRole("alert").filter({ hasText: "Updating messages" })).toHaveCount(0);
-}
-
-test("reconnecting a focused chat preserves its unread completion until another click", async ({
-  page,
-  workspaces,
-}) => {
-  const gate = await installDaemonWebSocketGate(page);
-  await openAgentRoute(page, workspaces.subject);
-  await expect(page.getByText("Finish this turn.", { exact: true })).toBeVisible();
-  await workspaces.subject.client.sendAgentMessage(
-    workspaces.subject.agentId,
-    "Unread across reconnect.",
-  );
-  await workspaces.subject.client.waitForFinish(workspaces.subject.agentId, 20_000);
-  await expectStatus(page, workspaces.subject.workspaceId, "attention");
-  await reconnectWithoutInteracting(page, gate);
-  await expectStatus(page, workspaces.subject.workspaceId, "attention");
-  await page.getByText("Unread across reconnect.", { exact: true }).click();
-  await expectStatus(page, workspaces.subject.workspaceId, "done");
-});
-
-test("a cached read chat acknowledges a completion that arrived while the app was closed", async ({
-  page,
-  workspaces,
-}) => {
-  await openCompactWorkspace(page, workspaces.subject);
-  await expectStatus(page, workspaces.subject.workspaceId, "done");
-  await closeMobileAgentSidebar(page);
-  await reopenWorkspaceAfterBackgroundTurn(page, workspaces.subject);
-  await expectRestoredCompactChat(page);
-  await openMobileAgentSidebar(page);
-  await expectStatus(page, workspaces.subject.workspaceId, "done");
-});

packages/app/e2e/browser/sidebar-workspace.spec.ts

@@ -6,7 +6,6 @@ import {
   closeMobileAgentSidebar,
   expectMobileAgentSidebarHidden,
   expectMobileAgentSidebarVisible,
-  expectOnlyWorkspaceHoverCardFor,
   expectWorkspaceHoverCardClosed,
   expectWorkspaceHoverCardOpen,
   expectWorkspaceHoverCardStaysOpen,
@@ -15,7 +14,6 @@ import {
   openMobileAgentSidebar,
   pinWorkspaceFromSidebar,
   scrollWorkspaceList,
-  sweepPointerAcrossWorkspaceRows,
 } from "../support/helpers/sidebar";
 import { seedWorkspace } from "../support/helpers/seed-client";
 import { expectWorkspaceHeader } from "../support/helpers/workspace-ui";
@@ -82,22 +80,6 @@ async function openWorkspaceHoverCard(page: import("@playwright/test").Page, wor
   return hoverCard;
 }
 
-async function sortWorkspacesBySidebarOrder<T extends { workspaceId: string }>(
-  page: Page,
-  workspaces: T[],
-): Promise<T[]> {
-  const positioned = await Promise.all(
-    workspaces.map(async (workspace) => {
-      const bounds = await page
-        .getByTestId(getWorkspaceRowTestId(workspace.workspaceId))
-        .boundingBox();
-      if (!bounds) throw new Error(`Could not measure the row of ${workspace.workspaceId}`);
-      return { workspace, y: bounds.y };
-    }),
-  );
-  return positioned.sort((left, right) => left.y - right.y).map(({ workspace }) => workspace);
-}
-
 interface PaseoOwnedWorktree {
   projectName: string;
   workspaceId: string;
@@ -448,38 +430,6 @@ test.describe("Sidebar workspace list", () => {
     }
   });
 
-  test("scanning up the workspace rows leaves only the resting row's hover card open", async ({
-    page,
-  }) => {
-    const workspaces = await Promise.all(
-      [1, 2, 3, 4, 5].map((index) =>
-        seedWorkspace({
-          repoPrefix: `sidebar-hover-scan-${index}-`,
-          title: `Hover scan ${index}`,
-        }),
-      ),
-    );
-
-    try {
-      await gotoAppShell(page);
-      for (const workspace of workspaces) {
-        await waitForSidebarWorkspace(page, workspace.workspaceId);
-      }
-      const rowsTopToBottom = await sortWorkspacesBySidebarOrder(page, workspaces);
-      const top = rowsTopToBottom[0]!;
-
-      for (let scan = 0; scan < 3; scan += 1) {
-        await sweepPointerAcrossWorkspaceRows(
-          page,
-          rowsTopToBottom.map((workspace) => workspace.workspaceId).toReversed(),
-        );
-        await expectOnlyWorkspaceHoverCardFor(page, top.workspaceName);
-      }
-    } finally {
-      await Promise.all(workspaces.map((workspace) => workspace.cleanup()));
-    }
-  });
-
   test("workspace hover card follows keyboard focus on a row", async ({ page }) => {
     const workspace = await seedWorkspace({ repoPrefix: "sidebar-hover-keyboard-" });
 
@@ -702,9 +652,6 @@ test.describe("Half-screen desktop layout", () => {
           .locator('[data-testid^="workspace-pane-"]')
           .getByTestId("workspace-tabs-row")
           .filter({ visible: true }),
-      ).toHaveCount(0);
-      await expect(
-        page.getByTestId("workspace-tab-switcher-trigger").filter({ visible: true }),
       ).toHaveCount(1);
 
       await explorerToggle.click();

packages/app/e2e/browser/subagent-origin-pane.spec.ts

@@ -38,12 +38,8 @@ async function openParentInRightPane(page: Page, parentId: string, workspaceId:
   await expect(left).toBeVisible();
   await expect(right).toBeVisible();
   await expect(right).not.toHaveAttribute("data-testid", "workspace-pane-main");
-  // A later split can replace the parent pane's rail with compact chrome.
-  // Keep the pane identity instead of finding it again through that rail.
-  const rightPaneId = await right.getAttribute("data-testid");
-  expect(rightPaneId).not.toBeNull();
   await left.locator('[data-testid^="workspace-tab-draft_"]').click();
-  return { left, right: page.getByTestId(rightPaneId!) };
+  return { left, right };
 }
 
 test.beforeEach(async ({ page }) => {

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

@@ -1,4 +1,3 @@
-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";
@@ -414,8 +413,6 @@ test("searches retained output without sending Find input to the shell", async (
 test("keeps terminal Find owned by retained tabs and the focused split pane", async ({
   page,
 }, testInfo) => {
-  // This journey selects tabs from the full rails in both split panes.
-  await page.setViewportSize({ width: 1600, height: 900 });
   const first = await harness.createTerminal({
     name: "First search",
     command: "bash",
@@ -490,142 +487,3 @@ 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();
-    }
-  });
-}

packages/app/e2e/browser/terminal-protocol-query.spec.ts

@@ -45,11 +45,6 @@ process.stdin.on("data", (chunk) => {
   for (;;) {
     const paste = /\x1b\[200~([^]*?)\x1b\[201~/.exec(buffer);
     if (!paste) break;
-    const pasted = JSON.stringify(paste[1]).replace(
-      /\s/g,
-      (space) => "\\u" + space.charCodeAt(0).toString(16).padStart(4, "0"),
-    );
-    process.stdout.write("PASTED:" + pasted + "\r\n");
     for (const [, path] of paste[1].matchAll(/'([^']*)'/g)) {
       const digest = crypto.createHash("sha256").update(fs.readFileSync(path)).digest("hex");
       const location = /[\\/]uploads[\\/]upload_/.test(path) ? "upload" : "local";
@@ -207,21 +202,6 @@ test.describe("Terminal protocol queries", () => {
     await expect.poll(() => terminalOutput(terminalId), { timeout: 10_000 }).toContain(text);
   }
 
-  // Every bracketed paste body the receiver consumed, in order and joined: what a
-  // shell would read as one command line.
-  async function pastedText(terminalId: string): Promise<string> {
-    const output = await terminalOutput(terminalId);
-    return [...output.matchAll(/PASTED:("(?:[^"\\]|\\.)*")/g)]
-      .map(([, json]) => JSON.parse(json) as string)
-      .join("");
-  }
-
-  // Exactly one ASCII space after each quoted path and nothing else between them,
-  // so the paths stay separate shell words.
-  async function expectSeparatePastedPaths(terminalId: string): Promise<void> {
-    await expect.poll(() => pastedText(terminalId)).toMatch(/^'[^']+' '[^']+' $/);
-  }
-
   test("pastes images from two panes into their own terminals as uploaded host files", async ({
     page,
   }) => {
@@ -258,23 +238,6 @@ test.describe("Terminal protocol queries", () => {
 
       await expectTerminalOutput(terminal.id, fileRead(pngBytes(3), "upload"));
       await expectTerminalOutput(terminal.id, fileRead(Buffer.from("remote notes"), "upload"));
-      await expectSeparatePastedPaths(terminal.id);
-    } finally {
-      await harness.killTerminal(terminal.id);
-    }
-  });
-
-  test("keeps the paths of two consecutive drops to another machine apart", async ({ page }) => {
-    const terminal = await openFileReceiver(page, "file-drop-remote-twice");
-    const first = { name: "first.png", type: "image/png", bytes: pngBytes(10) };
-    const second = { name: "second.txt", type: "text/plain", bytes: Buffer.from("second drop") };
-    try {
-      await dropFiles(page, [first]);
-      await expectTerminalOutput(terminal.id, fileRead(first.bytes, "upload"));
-      await dropFiles(page, [second]);
-      await expectTerminalOutput(terminal.id, fileRead(second.bytes, "upload"));
-
-      await expectSeparatePastedPaths(terminal.id);
     } finally {
       await harness.killTerminal(terminal.id);
     }

packages/app/e2e/browser/turn-collapse.spec.ts

@@ -2,14 +2,12 @@ import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import path from "node:path";
 import {
   holdOlderHistoryPages,
-  scrollTimelineRowIntoView,
   userScrollsTimelineToHistoryStart,
 } from "../support/helpers/timeline-pagination";
 import { getActiveTabTestId } from "../support/helpers/launcher";
 import type { Page, Locator } from "@playwright/test";
 import { test, expect } from "../support/fixtures";
 import { expectComposerVisible } from "../support/helpers/composer";
-import { withDirectoryPlugin } from "../support/helpers/plugin-timeline";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
 
 test.use({
@@ -51,36 +49,15 @@ async function seedAnsweredAgent(title: string) {
 }
 
 /** Chat rows between the latest turn's summary line and its reply, in document order. */
-async function rowsBetweenLatestSummaryAndReply(
-  page: Page,
-  replyTestId = "assistant-message",
-): Promise<number> {
-  return page.evaluate((testId) => {
+async function rowsBetweenLatestSummaryAndReply(page: Page): Promise<number> {
+  return page.evaluate(() => {
     const rows = [...document.querySelectorAll("[data-message-id]")];
     const summaryRow = rows.findLastIndex((row) => row.querySelector("[data-testid=turn-summary]"));
-    const replyRow = rows.findLastIndex((row) => row.querySelector(`[data-testid="${testId}"]`));
+    const replyRow = rows.findLastIndex((row) =>
+      row.querySelector("[data-testid=assistant-message]"),
+    );
     return replyRow - summaryRow - 1;
-  }, replyTestId);
-}
-
-/** The latest turn's summary line is a chat row of its own, sitting apart from its prompt. */
-async function expectSummaryLineSitsApartFromPrompt(page: Page) {
-  const summaryRow = () =>
-    page.evaluate(() => {
-      const latest = (testId: string) =>
-        [...document.querySelectorAll(`[data-testid="${testId}"]`)].at(-1)!;
-      const summary = latest("turn-summary");
-      const row = summary.closest("[data-message-id]")!;
-      return {
-        sharesRowWithPrompt: row.querySelector("[data-testid=user-message]") !== null,
-        gapBelowPrompt: Math.round(
-          summary.getBoundingClientRect().top -
-            latest("user-message").getBoundingClientRect().bottom,
-        ),
-      };
-    });
-  await expect.poll(summaryRow).toMatchObject({ sharesRowWithPrompt: false });
-  expect((await summaryRow()).gapBelowPrompt).toBeGreaterThan(0);
+  });
 }
 
 async function groupedToolsInsideLatestTurn(page: Page): Promise<string[]> {
@@ -148,67 +125,6 @@ async function expandAndCollapseLongPrompt(page: Page) {
 }
 
 test.describe("Turn collapse", () => {
-  test("folds work before a plugin-rendered reply and reopens it", async ({ page }, info) => {
-    test.setTimeout(120_000);
-    await useChatDisplay(page, "collapseTurns");
-    const agent = await seedMockAgentWorkspace({
-      repoPrefix: "plugin-reply-fold-",
-      title: "Plugin reply folding",
-      model: "ten-second-stream",
-      initialPrompt: "Make the fix and run the burst script.",
-    });
-    try {
-      await agent.client.waitForFinish(agent.agentId, 30_000);
-      await withDirectoryPlugin({
-        pluginId: "reply-fold-e2e",
-        source: `import React from "react";
-import { Text } from "react-native";
-import { z } from "zod";
-
-export default function contribute(client) {
-  client.addTimelineTransformer({
-    id: "reply", query: { itemType: "assistant_message" },
-    transform({ item, phase }) {
-      if (phase === "streaming") return undefined;
-      return { items: [{ type: "plugin", kind: "reply", version: 1, data: { text: item.text } }] };
-    },
-  });
-  client.addTimelineRenderer({
-    kind: "reply", version: 1, schema: z.object({ text: z.string() }),
-    Component: ({ item }) => <Text testID="plugin-reply">{item.data.text}</Text>,
-  });
-  return () => {};
-}`,
-        run: async () => {
-          await page.setViewportSize({ width: 1280, height: 1000 });
-          await openAgentRoute(page, agent);
-          await expectComposerVisible(page);
-          for (const width of [1280, 390]) {
-            await page.setViewportSize({ width, height: 1000 });
-            const summary = page.getByTestId("turn-summary").last().getByRole("button");
-            const reply = page.getByTestId("plugin-reply").last();
-            await expect(summary).toBeVisible();
-            await expect(reply).toContainText("(end of synthetic stream)");
-            await expect.poll(() => rowsBetweenLatestSummaryAndReply(page, "plugin-reply")).toBe(0);
-            await page.screenshot({ path: info.outputPath(`plugin-reply-folded-${width}.png`) });
-            await summary.click();
-            await expect
-              .poll(() => rowsBetweenLatestSummaryAndReply(page, "plugin-reply"))
-              .toBeGreaterThan(0);
-            await expect(reply).toContainText("(end of synthetic stream)");
-            await summary.click();
-            await expect.poll(() => rowsBetweenLatestSummaryAndReply(page, "plugin-reply")).toBe(0);
-          }
-          await page.reload();
-          await expect(page.getByTestId("turn-summary").last()).toBeVisible();
-          await expect.poll(() => rowsBetweenLatestSummaryAndReply(page, "plugin-reply")).toBe(0);
-        },
-      });
-    } finally {
-      await agent.cleanup();
-    }
-  });
-
   test("folds each answered turn behind a summary line that opens it", async ({ page }) => {
     test.setTimeout(120_000);
     await page.setViewportSize({ width: 1280, height: 1000 });
@@ -228,7 +144,6 @@ export default function contribute(client) {
         /\(end of synthetic stream\)$/,
       );
       await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(0);
-      await expectSummaryLineSitsApartFromPrompt(page);
 
       await summary.click();
       await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBeGreaterThan(0);
@@ -428,6 +343,7 @@ test("opening a turn keeps the received message above it clipped on every frame"
       .getByTestId("user-message")
       .filter({ has: page.getByRole("button", { name: "Sent by Reviewer", exact: true }) });
     await expect(bubble.getByRole("button", { name: "Show more", exact: true })).toBeVisible();
+    await bubble.scrollIntoViewIfNeeded();
 
     await watchReceivedMessagePreview(page, "Sent by Reviewer");
     await page
@@ -491,87 +407,34 @@ async function seedWholeTurnHistory() {
   return agent;
 }
 
-async function expectInitialFillIsConcealed(page: Page) {
-  await expect(page.getByTestId("agent-initial-fill")).toBeVisible();
-  await expect(page.getByTestId("agent-chat-scroll")).toHaveCSS("opacity", "0");
-}
-
-async function expectFilledChatAtBottom(page: Page) {
-  await expect(page.getByTestId("agent-initial-fill")).toBeHidden();
-  const chat = page.getByTestId("agent-chat-scroll");
-  await expect(chat).toHaveCSS("opacity", "1");
-  await expect
-    .poll(() =>
-      chat.evaluate((element) => ({
-        hasOverflow: element.scrollHeight > element.clientHeight,
-        atBottom: Math.abs(element.scrollHeight - element.clientHeight - element.scrollTop) <= 2,
-      })),
-    )
-    .toEqual({ hasOverflow: true, atBottom: true });
-}
-
-test("fills collapsed history before revealing a fresh chat", async ({ page }) => {
-  test.setTimeout(120_000);
-  await page.setViewportSize({ width: 1280, height: 1000 });
-  await useChatDisplay(page, "collapseTurns");
-  const agent = await seedWholeTurnHistory();
-  try {
-    const history = await holdOlderHistoryPages(page, agent);
-    await openAgentRoute(page, agent);
-    await history.expectRequestedPages(1);
-    await expectInitialFillIsConcealed(page);
-    history.releasePage(1);
-    await history.expectRequestedPages(2);
-    await expectInitialFillIsConcealed(page);
-    history.releasePage(2);
-    await expectFilledChatAtBottom(page);
-    await page.setViewportSize({ width: 1280, height: 8000 });
-    await history.expectRequestedPages(3);
-    await expect(page.getByTestId("agent-chat-scroll")).toHaveCSS("opacity", "1");
-    await expect(page.getByTestId("agent-initial-fill")).toBeHidden();
-    history.releasePage(3);
-    await history.expectSettledWithRequestedPages(3);
-    history.expectNoRepeatedEntries();
-  } finally {
-    await agent.cleanup();
-  }
-});
-
 test("loads complete long turns and preserves expansion while revealing older history", async ({
   page,
 }) => {
   test.setTimeout(120_000);
-  await page.setViewportSize({ width: 1280, height: 1000 });
   await useChatDisplay(page, "collapseTurns");
   const agent = await seedWholeTurnHistory();
   try {
     const history = await holdOlderHistoryPages(page, agent);
     await openAgentRoute(page, agent);
-    await history.expectRequestedPages(1);
-    history.releasePage(1);
-    await history.expectRequestedPages(2);
-    history.releasePage(2);
-    await expectFilledChatAtBottom(page);
     await expectComposerVisible(page);
     const latest = page
       .getByTestId("turn-summary")
       .getByRole("button", { name: "Ran 120 commands", exact: true });
     await expect(latest).toBeVisible();
+    await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(0);
+    await latest.click();
+    await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(120);
+    await userScrollsTimelineToHistoryStart(page);
+    await history.expectRequestedPages(1);
+    history.releasePage(1);
     await expect(
       page
         .getByTestId("turn-summary")
         .getByRole("button", { name: "Ran 60 commands", exact: true }),
     ).toBeVisible();
-    await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(0);
-    await latest.click();
-    await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(120);
-    await userScrollsTimelineToHistoryStart(page);
-    await history.expectRequestedPages(3);
-    history.releasePage(3);
-    await page.getByTestId("scroll-to-bottom-button").click();
     await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(120);
     history.expectNoRepeatedEntries();
-    await scrollTimelineRowIntoView(page, latest);
+    await latest.scrollIntoViewIfNeeded();
     await latest.click();
     await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(0);
   } finally {
@@ -666,7 +529,6 @@ async function expectThinkingPresentation(page: Page, autoExpandReasoning: boole
       .last();
     await expect(group).toContainText(/read 1 file/i);
     await expect(group.getByRole("button").first()).not.toContainText(/thought/i);
-    await scrollTimelineRowIntoView(page, group);
     await group.getByRole("button").first().click();
     // Expand thinking is off: the group opens its rows, but the thought row stays closed
     // until the reader opens it.

packages/app/e2e/browser/usage-sidebar-item.spec.ts

@@ -8,7 +8,7 @@ import {
   openProjectViaDaemon,
 } from "../support/helpers/new-workspace";
 import { getServerId } from "../support/helpers/server-id";
-import { openCompactSettings, openSettingsHostSection } from "../support/helpers/settings";
+import { openSettingsHostSection } from "../support/helpers/settings";
 import {
   expectFooterItemSetting,
   expectFooterSeparator,
@@ -42,7 +42,6 @@ import {
 import { seedSidebarFooterPreferences } from "../support/helpers/sidebar-nav-settings";
 import { waitForSettledPosition } from "../support/helpers/sheet-layout";
 import { createTempGitRepo } from "../support/helpers/workspace";
-import { buildOpenProjectRoute } from "@/utils/host-routes";
 
 const WIDE = { width: 1440, height: 900 };
 const COMPACT = { width: 390, height: 844 };
@@ -71,112 +70,7 @@ async function footerClip(page: Page) {
   return (await page.locator('[data-testid="sidebar-footer"]:visible').boundingBox())!;
 }
 
-async function setPageVisibility(page: Page, visibility: DocumentVisibilityState): Promise<void> {
-  await page.evaluate((state) => {
-    Object.defineProperty(document, "visibilityState", { configurable: true, get: () => state });
-    Object.defineProperty(document, "hidden", {
-      configurable: true,
-      get: () => state === "hidden",
-    });
-    document.dispatchEvent(new Event("visibilitychange"));
-  }, visibility);
-}
-
 test.describe("Usage item", () => {
-  test("visible summary refreshes every five minutes without opening Usage", async ({ page }) => {
-    let usedPct = 31;
-    const usage = await installUsageReportsFixture(page, {
-      lists: [
-        () => [
-          {
-            ...claudeAndCodexReports()[0]!,
-            report: {
-              status: "available",
-              windows: [
-                { id: "five_hour", label: "Session", shortLabel: "5h", summary: true, usedPct },
-              ],
-            },
-          },
-        ],
-      ],
-    });
-    await page.clock.install();
-    await page.setViewportSize(WIDE);
-    await seedSidebarFooterPreferences(page, [{ key: "usage", visible: true }]);
-    await gotoAppShell(page);
-    await expectPinnedUsage(page, ["31% 5h"]);
-    const startingUrl = page.url();
-    await qaScreenshot(page, "usage-auto-refresh-initial", { kind: "footer" });
-    const requestsBeforeRefresh = usage.listRequests();
-
-    usedPct = 42;
-    await page.clock.fastForward(5 * 60_000);
-    await qaScreenshot(page, "usage-auto-refresh-after-interval", { kind: "footer" });
-    await expectPinnedUsage(page, ["42% 5h"]);
-    await expect(usageModal(page)).toHaveCount(0);
-    await expect(page).toHaveURL(startingUrl);
-    expect(usage.listRequests()).toEqual([
-      ...requestsBeforeRefresh,
-      { forceRefresh: false, reportIds: undefined, agentId: undefined },
-    ]);
-
-    await setPageVisibility(page, "hidden");
-    const requestsBeforeBackgrounding = usage.listRequests();
-    usedPct = 47;
-    await page.clock.fastForward(5 * 60_000);
-    expect(usage.listRequests()).toEqual(requestsBeforeBackgrounding);
-    await expectPinnedUsage(page, ["42% 5h"]);
-    await setPageVisibility(page, "visible");
-    await page.clock.fastForward(5 * 60_000);
-    await expectPinnedUsage(page, ["47% 5h"]);
-    expect(usage.listRequests()).toEqual([
-      ...requestsBeforeBackgrounding,
-      { forceRefresh: false, reportIds: undefined, agentId: undefined },
-    ]);
-
-    await page.setViewportSize(COMPACT);
-    await expect(usageItem(page)).toHaveCount(0);
-    const requestsBeforeHiding = usage.listRequests();
-    await page.clock.fastForward(5 * 60_000);
-    expect(usage.listRequests()).toEqual(requestsBeforeHiding);
-
-    await openCompactSidebar(page);
-    await expectPinnedUsage(page, ["47% 5h"]);
-    await expect(page.getByTestId("agent-list-backdrop")).toBeVisible();
-    usedPct = 53;
-    await page.clock.fastForward(5 * 60_000);
-    await expectPinnedUsage(page, ["53% 5h"]);
-    await expect(usageModal(page)).toHaveCount(0);
-
-    await page.setViewportSize(WIDE);
-    await openSidebarNavSettings(page);
-    await setFooterItemVisible(page, "usage", false);
-    await leaveSettings(page);
-    await expectNoUsageItem(page);
-    const requestsBeforeDisabling = usage.listRequests();
-    await page.clock.fastForward(5 * 60_000);
-    expect(usage.listRequests()).toEqual(requestsBeforeDisabling);
-  });
-
-  test("Usage settings do not poll reports while the sidebar is inactive", async ({ page }) => {
-    const usage = await installUsageReportsFixture(page, {
-      lists: [() => claudeAndCodexReports()],
-    });
-    await page.clock.install();
-    await page.setViewportSize(COMPACT);
-    await seedSidebarFooterPreferences(page, [{ key: "usage", visible: true }]);
-    await gotoAppShell(page);
-    await openCompactSettings(page, buildOpenProjectRoute());
-    await openSettingsHostSection(page, getServerId(), "usage");
-    await expect(page.getByTestId("usage-card").getByText("31% used")).toBeVisible();
-    await expect(usageItem(page)).toHaveCount(0);
-    const requestsBeforeWaiting = usage.listRequests();
-
-    await page.clock.fastForward(5 * 60_000);
-    expect(usage.listRequests()).toEqual(requestsBeforeWaiting);
-    await expect(page.getByTestId("usage-card").getByText("31% used")).toBeVisible();
-  });
-
   test("both compact footer entry points open Usage as a sheet", async ({ page }) => {
     await page.setViewportSize(COMPACT);
     await installUsageReportsFixture(page, { lists: [() => claudeAndCodexReports()] });

packages/app/e2e/browser/viewed-agent-timelines.spec.ts

@@ -357,8 +357,6 @@ test.describe("Viewed agent timelines", () => {
   });
 
   test("two visible split chats both stay current", async ({ page }) => {
-    // Keep both split panes wide enough for the tab-rail interactions below.
-    await page.setViewportSize({ width: 1600, height: 900 });
     const scenario = await seedViewedTimelineScenario();
     try {
       await enableMoveTabShortcut(page);

packages/app/e2e/browser/workspace-archive-undo.spec.ts

@@ -1,273 +0,0 @@
-import type { Page } from "@playwright/test";
-import { expect, test } from "../support/fixtures";
-import { gotoAppShell } from "../support/helpers/app";
-import {
-  archiveWorkspaceFromDaemon,
-  connectNewWorkspaceDaemonClient,
-  createWorktreeViaDaemon,
-  openProjectViaDaemon,
-} from "../support/helpers/new-workspace";
-import { getServerId } from "../support/helpers/server-id";
-import { expectWorkspaceAbsentFromSidebar } from "../support/helpers/sidebar";
-import { createMockIdleAgent, openWorkspaceWithAgents } from "../support/helpers/archive-tab";
-import { connectSeedClient } from "../support/helpers/seed-client";
-import { createTempGitRepo } from "../support/helpers/workspace";
-import { getWorkspaceTabTestIds } from "../support/helpers/workspace-tabs";
-import {
-  archiveFromRowButton,
-  createGatedTeardown,
-  expectDirectoryPresence,
-  expectHostWorkspaceSettledActive,
-  holdNextArchiveRequest,
-  outlastUndoWindow,
-  pressArchiveShortcut,
-  pressUndoShortcut,
-  resizeSidebarToMinimum,
-  rowArchiveButton,
-  rowKebab,
-  undoButton,
-  workspaceRow,
-  workspaceTitleWidth,
-} from "../support/helpers/workspace-archive-undo";
-import {
-  waitForSidebarHydration,
-  waitForWorkspaceInSidebar,
-} from "../support/helpers/workspace-ui";
-
-test.describe("Workspace archive undo", () => {
-  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
-  let tempRepo: { path: string; cleanup: () => Promise<void> };
-  const worktreeDirectories = new Set<string>();
-
-  test.describe.configure({ timeout: 120_000 });
-
-  test.beforeEach(async () => {
-    client = await connectNewWorkspaceDaemonClient();
-    tempRepo = await createTempGitRepo("archive-undo-");
-  });
-
-  test.afterEach(async () => {
-    for (const directory of worktreeDirectories) {
-      await archiveWorkspaceFromDaemon(client, directory).catch(() => undefined);
-    }
-    worktreeDirectories.clear();
-    await client?.close().catch(() => undefined);
-    await tempRepo?.cleanup().catch(() => undefined);
-  });
-
-  async function seedWorktree(page: Page, slug: string) {
-    await openProjectViaDaemon(client, tempRepo.path);
-    const worktree = await createWorktreeViaDaemon(client, {
-      cwd: tempRepo.path,
-      slug: `${slug}-${Date.now()}`,
-    });
-    worktreeDirectories.add(worktree.workspaceDirectory);
-    await gotoAppShell(page);
-    await waitForSidebarHydration(page);
-    await waitForWorkspaceInSidebar(page, {
-      serverId: getServerId(),
-      workspaceId: worktree.workspaceId,
-    });
-    return worktree;
-  }
-
-  test("the hover archive button overlays the title instead of narrowing it", async ({ page }) => {
-    const worktree = await seedWorktree(page, "archive-button-overlay");
-
-    await page.mouse.move(0, 0);
-    await expect(rowArchiveButton(page, worktree.workspaceId)).toHaveCount(0);
-    const restingWidth = await workspaceTitleWidth(page, worktree.workspaceId);
-
-    await workspaceRow(page, worktree.workspaceId).hover();
-    await expect(rowArchiveButton(page, worktree.workspaceId)).toBeVisible();
-    await expect(page.getByTestId("sidebar-workspace-trailing-scrim")).toBeVisible();
-    expect(await workspaceTitleWidth(page, worktree.workspaceId)).toBe(restingWidth);
-
-    const [buttonBox, kebabBox] = await Promise.all([
-      rowArchiveButton(page, worktree.workspaceId).boundingBox(),
-      rowKebab(page, worktree.workspaceId).boundingBox(),
-    ]);
-    if (!buttonBox || !kebabBox) throw new Error("Row actions are not laid out");
-    expect(kebabBox.x - (buttonBox.x + buttonBox.width)).toBeGreaterThanOrEqual(8);
-  });
-
-  test("the archived toast sits over the sidebar above its footer, and only Undo presses", async ({
-    page,
-  }) => {
-    const worktree = await seedWorktree(page, "archive-toast-sidebar");
-
-    await archiveFromRowButton(page, worktree.workspaceId);
-
-    const [toastBox, footerBox] = await Promise.all([
-      page.getByTestId("workspace-archived-toast").boundingBox(),
-      page.getByTestId("sidebar-footer").boundingBox(),
-    ]);
-    if (!toastBox || !footerBox) throw new Error("Toast or footer is not laid out");
-    expect(toastBox.x).toBeGreaterThanOrEqual(footerBox.x);
-    expect(toastBox.x + toastBox.width).toBeLessThanOrEqual(footerBox.x + footerBox.width);
-    expect(toastBox.y + toastBox.height).toBeLessThanOrEqual(footerBox.y);
-    expect(footerBox.y - (toastBox.y + toastBox.height)).toBeLessThanOrEqual(16);
-
-    await expect(page.getByTestId("app-toast-message")).toHaveCSS("cursor", "auto");
-    await expect(undoButton(page)).toHaveCSS("cursor", "pointer");
-
-    const [labelBox, shortcutBox] = await Promise.all([
-      undoButton(page).getByText("Undo", { exact: true }).boundingBox(),
-      undoButton(page).getByText(/Z$/).boundingBox(),
-    ]);
-    if (!labelBox || !shortcutBox) throw new Error("Undo button is not laid out");
-    expect(shortcutBox.x - (labelBox.x + labelBox.width)).toBeLessThanOrEqual(8.5);
-  });
-
-  test("an archive that fails after the sidebar was replaced still shows its error", async ({
-    page,
-  }) => {
-    const archive = await holdNextArchiveRequest(page);
-    const worktree = await seedWorktree(page, "archive-late-failure");
-
-    await archiveFromRowButton(page, worktree.workspaceId);
-    await archive.waitForHeld();
-    // Crossing the compact breakpoint swaps the sidebar, unmounting the toast's host.
-    await page.setViewportSize({ width: 400, height: 720 });
-    await expect(undoButton(page)).toHaveCount(0);
-
-    archive.releaseForUnknownWorkspace("workspace-the-daemon-never-had");
-
-    await expect(page.getByTestId("app-toast-message")).toHaveText(
-      "Workspace not found: workspace-the-daemon-never-had",
-    );
-  });
-
-  test("the archived toast keeps Undo inside the card at the narrowest sidebar", async ({
-    page,
-  }) => {
-    const worktree = await seedWorktree(page, "archive-toast-narrow");
-    await resizeSidebarToMinimum(page);
-
-    await archiveFromRowButton(page, worktree.workspaceId);
-
-    const [toastBox, undoBox] = await Promise.all([
-      page.getByTestId("workspace-archived-toast").boundingBox(),
-      undoButton(page).boundingBox(),
-    ]);
-    if (!toastBox || !undoBox) throw new Error("Toast is not laid out");
-    expect(undoBox.x + undoBox.width).toBeLessThanOrEqual(toastBox.x + toastBox.width);
-    expect(undoBox.y + undoBox.height).toBeLessThanOrEqual(toastBox.y + toastBox.height);
-  });
-
-  test("archiving by shortcut with the sidebar collapsed shows the toast over the app", async ({
-    page,
-  }) => {
-    const worktree = await seedWorktree(page, "archive-toast-collapsed");
-    await workspaceRow(page, worktree.workspaceId).click();
-    await page.keyboard.press("ControlOrMeta+b");
-    await expect(workspaceRow(page, worktree.workspaceId)).not.toBeInViewport();
-
-    page.once("dialog", (dialog) => void dialog.accept());
-    await pressArchiveShortcut(page);
-
-    const toast = page.getByTestId("workspace-archived-toast");
-    await expect(toast).toBeInViewport();
-    const toastBox = await toast.boundingBox();
-    if (!toastBox) throw new Error("Toast is not laid out");
-    expect(toastBox.y).toBeLessThan(page.viewportSize()!.height / 2);
-  });
-
-  test("Cmd/Ctrl+Z right after archiving keeps the worktree", async ({ page }) => {
-    const worktree = await seedWorktree(page, "archive-undo-shortcut");
-
-    await archiveFromRowButton(page, worktree.workspaceId);
-    await pressUndoShortcut(page);
-
-    await expect(workspaceRow(page, worktree.workspaceId)).toBeVisible();
-    await expect(undoButton(page)).toHaveCount(0);
-    await expectHostWorkspaceSettledActive(client, worktree.workspaceId);
-    // Once the host settled, any remove the canceled archive sent has already arrived.
-    await expect(workspaceRow(page, worktree.workspaceId)).toBeVisible();
-    await expectDirectoryPresence(worktree.workspaceDirectory, true);
-  });
-
-  test("Undo after the worktree was removed recreates it", async ({ page }) => {
-    const worktree = await seedWorktree(page, "archive-undo-recreate");
-
-    await archiveFromRowButton(page, worktree.workspaceId);
-    // Hovering the toast holds it, and with it the undo, open while the archive finishes.
-    await undoButton(page).hover();
-    await expectDirectoryPresence(worktree.workspaceDirectory, false);
-    await undoButton(page).click();
-
-    await expect(workspaceRow(page, worktree.workspaceId)).toBeVisible({ timeout: 30_000 });
-    await expectDirectoryPresence(worktree.workspaceDirectory, true);
-    await expectHostWorkspaceSettledActive(client, worktree.workspaceId);
-  });
-
-  test("hovering Undo keeps the toast open past its deadline, and its close ends the undo", async ({
-    page,
-  }) => {
-    await page.clock.install({ time: Date.now() });
-    const worktree = await seedWorktree(page, "archive-undo-hold");
-
-    await archiveFromRowButton(page, worktree.workspaceId);
-    await page.getByTestId("workspace-archived-toast").hover({ position: { x: 8, y: 8 } });
-    await undoButton(page).hover();
-    await outlastUndoWindow(page);
-    await expect(undoButton(page)).toBeVisible();
-
-    await page.mouse.move(0, 0);
-    await outlastUndoWindow(page);
-    await expect(undoButton(page)).toHaveCount(0);
-
-    // The toast took the undo with it.
-    await pressUndoShortcut(page);
-    await expectWorkspaceAbsentFromSidebar(page, worktree.workspaceId);
-  });
-
-  test("opening the workspace while its undo is still running keeps its tabs", async ({ page }) => {
-    const teardown = createGatedTeardown();
-    const repo = await createTempGitRepo("archive-undo-tabs-", {
-      paseoConfig: teardown.paseoConfig,
-    });
-    const seedClient = await connectSeedClient();
-    try {
-      await openProjectViaDaemon(client, repo.path);
-      const worktree = await createWorktreeViaDaemon(client, {
-        cwd: repo.path,
-        slug: `archive-undo-tabs-${Date.now()}`,
-      });
-      worktreeDirectories.add(worktree.workspaceDirectory);
-      const target = { cwd: worktree.workspaceDirectory, workspaceId: worktree.workspaceId };
-      const agents = [
-        await createMockIdleAgent(seedClient, { ...target, title: "first" }),
-        await createMockIdleAgent(seedClient, { ...target, title: "second" }),
-      ] as const;
-      await openWorkspaceWithAgents(page, [agents[0], agents[1]]);
-      const tabsBefore = await getWorkspaceTabTestIds(page);
-
-      await archiveFromRowButton(page, worktree.workspaceId);
-      // The archive has taken its agents down and now parks in teardown.
-      await teardown.expectStarted();
-      await undoButton(page).click();
-      await workspaceRow(page, worktree.workspaceId).click();
-
-      for (const agent of agents) {
-        await expect(page.getByTestId(`workspace-tab-agent_${agent.id}`).first()).toBeVisible();
-      }
-      teardown.release();
-      await expectHostWorkspaceSettledActive(client, worktree.workspaceId);
-      await expect.poll(() => getWorkspaceTabTestIds(page)).toEqual(tabsBefore);
-    } finally {
-      teardown.release();
-      await seedClient.close().catch(() => undefined);
-      await repo.cleanup().catch(() => undefined);
-    }
-  });
-
-  test("Cmd/Ctrl+Z without an archive to undo leaves the sidebar alone", async ({ page }) => {
-    const worktree = await seedWorktree(page, "archive-undo-none");
-
-    await pressUndoShortcut(page);
-
-    await expect(undoButton(page)).toHaveCount(0);
-    await expect(workspaceRow(page, worktree.workspaceId)).toBeVisible();
-  });
-});

packages/app/e2e/browser/workspace-focus-mode.spec.ts

@@ -101,20 +101,3 @@ test("focus mode only applies to the active workspace screen", async ({ page, wi
   await expect(exitFocusMode).toHaveCount(0);
   await expect(settingsButton).toBeVisible();
 });
-
-async function exitFocusModeFromCompactHeader(page: Page) {
-  await page.setViewportSize({ width: 400, height: 844 });
-  await page.getByTestId("workspace-header-menu-trigger").click();
-  await page.getByRole("menuitem", { name: "Exit focus mode", exact: true }).click();
-  await page.setViewportSize({ width: 1280, height: 900 });
-}
-
-test("compact workspace menu keeps focus mode exit reachable", async ({ page, withWorkspace }) => {
-  const workspace = await withWorkspace({ prefix: "compact-focus-exit-" });
-  await page.setViewportSize({ width: 1280, height: 900 });
-  await workspace.navigateTo();
-  await enterFocusMode(page);
-  await exitFocusModeFromCompactHeader(page);
-  await expect(exitFocusModeButton(page)).toHaveCount(0);
-  await expect(page.getByTestId("sidebar-global-new-workspace")).toBeVisible();
-});

packages/app/e2e/browser/workspace-pane-remount.spec.ts

@@ -52,8 +52,6 @@ async function waitForWorkspaceRoute(page: Page, route: string) {
 test.describe("Workspace pane mounting", () => {
   test("workspace navigation keeps the existing agent composer mounted", async ({ page }) => {
     test.setTimeout(90_000);
-    // Keep both split panes wide enough for the tab-rail interactions below.
-    await page.setViewportSize({ width: 1600, height: 900 });
     const serverId = getServerId();
 
     const workspace = await seedWorkspace({ repoPrefix: "pane-remount-" });

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

@@ -1,131 +0,0 @@
-import { expect, type Locator, type Page } from "@playwright/test";
-import { test } from "../support/fixtures";
-import { runWorkspaceActionFromCommandCenter } from "../support/helpers/command-center-workspace-actions";
-import { clickNewChat, gotoWorkspace } from "../support/helpers/launcher";
-import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
-import { waitForWorkspaceTabsVisible } from "../support/helpers/workspace-tabs";
-
-function visible(page: Page, testId: string): Locator {
-  return page.getByTestId(testId).filter({ visible: true });
-}
-
-function panes(page: Page): Locator {
-  return page.locator('[data-testid^="workspace-pane-"]').filter({ visible: true });
-}
-
-function splitDividers(page: Page): Locator {
-  return visible(page, "workspace-split-resize-handle");
-}
-
-async function openSplitWorkspace(
-  page: Page,
-  repoPrefix: string,
-  split: "Split pane right" | "Split pane down",
-): Promise<SeededWorkspace> {
-  await page.setViewportSize({ width: 1600, height: 900 });
-  const workspace = await seedWorkspace({ repoPrefix });
-  await gotoWorkspace(page, workspace.workspaceId);
-  await waitForWorkspaceTabsVisible(page);
-  await clickNewChat(page);
-  await expect(visible(page, "workspace-header-title")).toHaveCount(1);
-  await runWorkspaceActionFromCommandCenter(page, split);
-  await expect(splitDividers(page)).toHaveCount(1);
-  await expect(panes(page)).toHaveCount(2);
-  return workspace;
-}
-
-async function expectOneSharedWorkspaceHeader(page: Page): Promise<void> {
-  await expect(visible(page, "workspace-header-title")).toHaveCount(1);
-  await expect(visible(page, "workspace-header-menu-trigger")).toHaveCount(1);
-  await expect(panes(page).getByTestId("workspace-header-title")).toHaveCount(0);
-  await expect(panes(page).getByTestId("workspace-header-menu-trigger")).toHaveCount(0);
-}
-
-/** The tab counter belongs to the single-pane layout: split panes always show their rails. */
-async function expectPanesKeepTabRails(page: Page): Promise<void> {
-  for (const pane of await panes(page).all()) {
-    await expect(pane.getByTestId("workspace-tabs-row")).toBeVisible();
-  }
-  await expect(visible(page, "workspace-tab-switcher-trigger")).toHaveCount(0);
-}
-
-async function dragDivider(divider: Locator, deltaX: number): Promise<void> {
-  const page = divider.page();
-  const box = await divider.boundingBox();
-  if (!box) throw new Error("Divider has no bounding box");
-  const x = box.x + box.width / 2;
-  const y = box.y + box.height / 2;
-  await page.mouse.move(x, y);
-  await page.mouse.down();
-  await page.mouse.move(x + deltaX, y, { steps: 8 });
-  await page.mouse.up();
-}
-
-test.describe("Workspace header with split panes", () => {
-  test("wide side-by-side panes share one header and keep their tab rails", async ({ page }) => {
-    const workspace = await openSplitWorkspace(page, "split-header-wide-", "Split pane right");
-    try {
-      await expectOneSharedWorkspaceHeader(page);
-      await expectPanesKeepTabRails(page);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("stacked panes share one header", async ({ page }) => {
-    const workspace = await openSplitWorkspace(page, "split-header-stacked-", "Split pane down");
-    try {
-      await expectOneSharedWorkspaceHeader(page);
-      await expectPanesKeepTabRails(page);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("a narrow workspace shows one compact header and every pane keeps its tab rail", async ({
-    page,
-  }) => {
-    const workspace = await openSplitWorkspace(page, "split-header-narrow-", "Split pane right");
-    try {
-      await page.setViewportSize({ width: 760, height: 900 });
-      await expectPanesKeepTabRails(page);
-      await expectOneSharedWorkspaceHeader(page);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("a narrow pane beside a wide one keeps its tab rail", async ({ page }) => {
-    const workspace = await openSplitWorkspace(page, "split-header-mixed-", "Split pane right");
-    try {
-      await dragDivider(splitDividers(page), -300);
-      const [left, right] = await panes(page).all();
-      const leftBox = await left.boundingBox();
-      const rightBox = await right.boundingBox();
-      expect(leftBox!.width).toBeLessThan(500);
-      expect(rightBox!.width).toBeGreaterThan(500);
-      await expectPanesKeepTabRails(page);
-      await expectOneSharedWorkspaceHeader(page);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("closing back to one pane returns the merged compact header", async ({ page }) => {
-    const workspace = await openSplitWorkspace(page, "split-header-close-", "Split pane right");
-    try {
-      const [, emptyPane] = await panes(page).all();
-      const emptyPaneRail = emptyPane.getByTestId("workspace-tabs-row");
-      await emptyPaneRail.locator('[data-testid^="workspace-tab-"]').first().hover();
-      await emptyPaneRail.locator('[data-testid*="-close-"]').first().click();
-      await expect(splitDividers(page)).toHaveCount(0);
-      await expect(visible(page, "workspace-header-title")).toHaveCount(1);
-      await page.setViewportSize({ width: 760, height: 900 });
-      await expect(visible(page, "workspace-tabs-row")).toHaveCount(0);
-      await expect(visible(page, "workspace-tab-switcher-trigger")).toHaveCount(1);
-      await expect(visible(page, "workspace-header-title")).toHaveCount(1);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-});

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

@@ -6,11 +6,6 @@ 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/mobile/composer-keyboard/android.sh

@@ -509,8 +509,6 @@ check_autocomplete() {
     fi
   fi
   ad wait 'id="composer-autocomplete-popover"' 10000
-  # Rows replace the popover's loading row once the host lists them; a cold Claude list is slow.
-  ad wait "text=\"${expected}\"" 30000
   # The popover remeasures once keyboard motion settles.
   sleep 1
   capture_screen "${prefix}.png"

packages/app/e2e/mobile/composer-keyboard/ios.mjs

@@ -69,23 +69,17 @@ async function waitFor(name, predicate, timeoutMs = 10_000) {
   }
 }
 
-// Keyboard motion has settled once two snapshots agree on the composer position. The
-// popover shows a loading row until the host lists its commands; a cold Claude list is slow.
+// Keyboard motion has settled once two snapshots agree on the composer position.
 async function settledPlacement(name, keyboard) {
   let previousTop;
-  return waitFor(
-    name,
-    (snap) => {
-      const composer = nodeById(snap, "message-input-root");
-      if (!nodeById(snap, "composer-autocomplete-popover") || !composer) return false;
-      if (nodeById(snap, "composer-autocomplete-loading")) return false;
-      if (keyboardShown(snap) !== keyboard) return false;
-      const stable = composer.rect.y === previousTop;
-      previousTop = composer.rect.y;
-      return stable;
-    },
-    30_000,
-  );
+  return waitFor(name, (snap) => {
+    const composer = nodeById(snap, "message-input-root");
+    if (!nodeById(snap, "composer-autocomplete-popover") || !composer) return false;
+    if (keyboardShown(snap) !== keyboard) return false;
+    const stable = composer.rect.y === previousTop;
+    previousTop = composer.rect.y;
+    return stable;
+  });
 }
 
 function assertPlacement(name, snap, expected) {

packages/app/e2e/support/helpers/archive-tab.ts

@@ -219,11 +219,6 @@ export async function expectWorkspaceArchiveOutcome(
   await expectWorkspaceTabVisible(page, input.survivingAgentId);
 }
 
-export async function closeActiveAgentWithShortcut(page: Page, agentId: string): Promise<void> {
-  await page.keyboard.press("Alt+Shift+w");
-  await expectWorkspaceTabHidden(page, agentId);
-}
-
 export async function closeWorkspaceAgentTab(page: Page, agentId: string): Promise<void> {
   const closeButton = page.getByTestId(`workspace-agent-close-${agentId}`).filter({
     visible: true,
@@ -242,10 +237,6 @@ export async function expectArchivedAgentFocused(page: Page, agentId: string): P
   });
 }
 
-export async function unarchiveAgentFromConversation(page: Page): Promise<void> {
-  await page.getByRole("button", { name: "Unarchive", exact: true }).click();
-}
-
 export async function reloadWorkspace(page: Page, workspaceId: string): Promise<void> {
   const serverId = getServerId();
   await page.goto(buildHostWorkspaceRoute(serverId, workspaceId));

packages/app/e2e/support/helpers/command-center-file-search.ts

@@ -99,7 +99,6 @@ export async function startCommandCenterLayoutObservation(page: Page): Promise<v
     const observedElements = new WeakSet<Element>();
     const resizeObserver = new ResizeObserver(record);
     const mutationObserver = new MutationObserver(discover);
-    let performanceObserver: PerformanceObserver | undefined;
 
     function record(): void {
       if (!observation.active) return;
@@ -133,7 +132,6 @@ export async function startCommandCenterLayoutObservation(page: Page): Promise<v
       if (!observation.active) {
         mutationObserver.disconnect();
         resizeObserver.disconnect();
-        performanceObserver?.disconnect();
         return;
       }
       record();
@@ -143,16 +141,9 @@ export async function startCommandCenterLayoutObservation(page: Page): Promise<v
 
     if (typeof PerformanceObserver !== "undefined") {
       try {
-        performanceObserver = new PerformanceObserver((list) => {
-          const panel = document.querySelector(selectors.panel);
+        const performanceObserver = new PerformanceObserver((list) => {
           for (const entry of list.getEntries()) {
-            const shift = entry as PerformanceEntry & {
-              value: number;
-              sources: Array<{ node: Node | null }>;
-            };
-            if (shift.sources.some((source) => source.node && panel?.contains(source.node))) {
-              observation.layoutShift += shift.value;
-            }
+            observation.layoutShift += (entry as PerformanceEntry & { value?: number }).value ?? 0;
           }
         });
         performanceObserver.observe({ type: "layout-shift", buffered: false });
@@ -183,54 +174,7 @@ export async function expectStableCommandCenterLayout(page: Page): Promise<void>
       ).toBeLessThanOrEqual(1);
     }
   }
-  expect(
-    observation.layoutShift,
-    `command center layoutShift: ${JSON.stringify(observation)}`,
-  ).toBeLessThanOrEqual(0.001);
-}
-
-/** Exercise an unrelated page shift while the real search panel is being observed. */
-export async function shiftOutsideCommandCenter(page: Page): Promise<void> {
-  await shiftLayoutProbe(page.locator("body"));
-}
-
-export async function expectLayoutObservationToCatchPanelShift(page: Page): Promise<void> {
-  await startCommandCenterLayoutObservation(page);
-  await shiftLayoutProbe(page.getByTestId("command-center-panel"));
-  await expect(expectStableCommandCenterLayout(page)).rejects.toThrow("command center layoutShift");
-}
-
-async function shiftLayoutProbe(parent: Locator): Promise<void> {
-  const recordedShift = await parent.evaluate(async (container) => {
-    const sibling = document.createElement("div");
-    sibling.textContent = "Layout probe";
-    sibling.style.cssText =
-      "position:fixed;left:0;top:0;width:300px;height:100px;background:white;z-index:99999";
-    container.append(sibling);
-    await new Promise<void>((resolve) =>
-      requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
-    );
-    const value = await new Promise<number>((resolve) => {
-      const observer = new PerformanceObserver((list) => {
-        for (const entry of list.getEntries()) {
-          const shift = entry as PerformanceEntry & {
-            value: number;
-            sources: Array<{ node: Node | null }>;
-          };
-          if (shift.sources.some((source) => source.node === sibling)) {
-            observer.disconnect();
-            resolve(shift.value);
-          }
-        }
-      });
-      observer.observe({ type: "layout-shift", buffered: false });
-      sibling.style.left = "400px";
-    });
-    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-    sibling.remove();
-    return value;
-  });
-  expect(recordedShift, "the browser recorded a substantial probe shift").toBeGreaterThan(0.001);
+  expect(observation.layoutShift, JSON.stringify(observation)).toBeLessThanOrEqual(0.001);
 }
 
 export async function expectOneLineTruncatedFileResult(

packages/app/e2e/support/helpers/composer-control-density.ts

@@ -53,302 +53,3 @@ export async function expectNoCollapsedComposerToolbarFrame(page: Page): Promise
   const collapsed = frames.filter((frame) => frame.labels.some((label) => label === ""));
   expect(collapsed, `collapsed toolbar frames: ${JSON.stringify(collapsed)}`).toEqual([]);
 }
-
-/** One painted frame of the composer's trailing controls: the slot and what sits beside it. */
-export interface TrailingActionFrame {
-  atMs: number;
-  /** Every trailing action on screen, as `label` or `label (disabled)`. */
-  actions: string[];
-  slotX: number | null;
-  micX: number | null;
-  ringX: number | null;
-  ringWidth: number | null;
-}
-
-declare global {
-  interface Window {
-    __trailingActionFrames?: TrailingActionFrame[];
-    __trailingActionStop?: () => void;
-  }
-}
-
-const TRAILING_ACTION_LABELS = [
-  "Enable Voice mode",
-  "Send message",
-  "Queue message",
-  "Send and interrupt",
-  "Send and steer",
-  "Interrupt agent",
-  "Stop agent",
-];
-
-/**
- * Records every painted frame of the visible composer's trailing controls. Takes one sample before
- * the first paint, so input that lands right after this resolves still has a frame to compare to.
- */
-export async function recordTrailingActionFrames(page: Page): Promise<void> {
-  await page.evaluate((labels) => {
-    const frames: TrailingActionFrame[] = [];
-    window.__trailingActionFrames = frames;
-    const start = performance.now();
-    const visibleRoot = () =>
-      Array.from(document.querySelectorAll('[data-testid="message-input-root"]')).find(
-        (root) => root.getClientRects().length > 0,
-      );
-    const sample = () => {
-      const root = visibleRoot();
-      const control = (selector: string) =>
-        Array.from(root?.querySelectorAll(selector) ?? []).find(
-          (node) => node.getClientRects().length > 0,
-        );
-      const actions = labels.flatMap((label) => {
-        const node = control(`[aria-label="${label}"]`);
-        if (!node) return [];
-        return [node.getAttribute("aria-disabled") === "true" ? `${label} (disabled)` : label];
-      });
-      const slot = labels.map((label) => control(`[aria-label="${label}"]`)).find(Boolean);
-      const mic = control('[aria-label="Start dictation"]');
-      const ring = control('[aria-label^="Context window"]');
-      frames.push({
-        atMs: Math.round(performance.now() - start),
-        actions,
-        slotX: slot ? slot.getBoundingClientRect().x : null,
-        micX: mic ? mic.getBoundingClientRect().x : null,
-        ringX: ring ? ring.getBoundingClientRect().x : null,
-        ringWidth: ring ? ring.getBoundingClientRect().width : null,
-      });
-    };
-    sample();
-    let running = true;
-    const tick = () => {
-      if (!running) return;
-      sample();
-      requestAnimationFrame(tick);
-    };
-    requestAnimationFrame(tick);
-    window.__trailingActionStop = () => {
-      running = false;
-    };
-  }, TRAILING_ACTION_LABELS);
-}
-
-export async function readTrailingActionFrames(page: Page): Promise<TrailingActionFrame[]> {
-  return page.evaluate(() => {
-    window.__trailingActionStop?.();
-    return window.__trailingActionFrames ?? [];
-  });
-}
-
-/**
- * Every frame of the span shows exactly one trailing action, in the one slot, moving straight from
- * `from` to `to`, with the mic and context ring where they started.
- */
-export function expectTrailingActionSwap(
-  frames: TrailingActionFrame[],
-  expected: { from: string; to: string },
-): void {
-  expect(frames.length).toBeGreaterThan(1);
-  const [first] = frames;
-  const wrongFrames = frames.filter(
-    (frame) =>
-      frame.actions.length !== 1 ||
-      frame.slotX !== first.slotX ||
-      frame.micX !== first.micX ||
-      frame.ringX !== first.ringX ||
-      frame.ringWidth !== first.ringWidth,
-  );
-  expect(wrongFrames, `frames that moved or showed the wrong action`).toEqual([]);
-  const sequence = frames
-    .map((frame) => frame.actions[0])
-    .filter((action, index, all) => action !== all[index - 1]);
-  expect(sequence).toEqual([expected.from, expected.to]);
-}
-
-/** What the folded model control's labels show, read from the DOM. */
-export interface ModelTriggerLabelState {
-  thinkingShown: boolean;
-  modelShown: boolean;
-  modelText: string;
-  modelTruncated: boolean;
-}
-
-declare global {
-  interface Window {
-    __modelTriggerFrames?: ModelTriggerLabelState[];
-  }
-}
-
-function readModelTriggerLabelStateInPage(): ModelTriggerLabelState {
-  const visible = (node: Element) => node.getClientRects().length > 0;
-  const model = Array.from(
-    document.querySelectorAll('[data-testid="combined-model-selector-model-label"]'),
-  ).find(visible);
-  const thinking = Array.from(
-    document.querySelectorAll('[data-testid="combined-model-selector-thinking-label"]'),
-  ).find(visible);
-  const shown = (node: Element | null): boolean => {
-    for (let current = node; current; current = current.parentElement) {
-      if (Number(getComputedStyle(current).opacity) === 0) return false;
-    }
-    return true;
-  };
-  const modelShown = model !== undefined && shown(model);
-  const modelText = model?.textContent ?? "";
-  return {
-    modelShown,
-    modelText,
-    thinkingShown: modelShown && thinking !== undefined,
-    modelTruncated:
-      model !== undefined && (modelText.endsWith("…") || model.scrollWidth > model.clientWidth),
-  };
-}
-
-/** Records the folded model control's labels on every painted frame from page load. */
-export async function recordModelTriggerFramesFromLoad(page: Page): Promise<void> {
-  await page.addInitScript(`(() => {
-    const read = ${readModelTriggerLabelStateInPage.toString()};
-    const frames = [];
-    window.__modelTriggerFrames = frames;
-    const tick = () => {
-      frames.push(read());
-      requestAnimationFrame(tick);
-    };
-    requestAnimationFrame(tick);
-  })()`);
-}
-
-/** The model control's labels once two reads 100ms apart agree. */
-export async function readSettledModelTriggerLabels(page: Page): Promise<ModelTriggerLabelState> {
-  let previous = await page.evaluate(readModelTriggerLabelStateInPage);
-  for (;;) {
-    await page.waitForTimeout(100);
-    const next = await page.evaluate(readModelTriggerLabelStateInPage);
-    if (JSON.stringify(next) === JSON.stringify(previous)) return next;
-    previous = next;
-  }
-}
-
-/** The labels at the widths where the folded model control changes what it shows. */
-export interface ModelTriggerLabelSweep {
-  /** The labels at the widest width. */
-  widest: ModelTriggerLabelState & { width: number };
-  /** The first width at which the thinking label is hidden. */
-  thinkingHidden: ModelTriggerLabelState & { width: number };
-  /** The first width at which the model label is truncated. */
-  modelTruncated: ModelTriggerLabelState & { width: number };
-}
-
-/**
- * Narrows the viewport step by step and records where the thinking label disappears and where the
- * model label first truncates.
- */
-export async function sweepModelTriggerLabels(
-  page: Page,
-  widths: { from: number; to: number; step: number; height: number },
-): Promise<ModelTriggerLabelSweep> {
-  const steps: (ModelTriggerLabelState & { width: number })[] = [];
-  for (let width = widths.from; width >= widths.to; width -= widths.step) {
-    await page.setViewportSize({ width, height: widths.height });
-    const labels = await readSettledModelTriggerLabels(page);
-    steps.push({ ...labels, width });
-    if (labels.modelTruncated || !labels.modelShown) break;
-  }
-  const thinkingHidden = steps.find((step) => !step.thinkingShown);
-  const modelTruncated = steps.find((step) => step.modelTruncated);
-  if (!thinkingHidden || !modelTruncated) {
-    throw new Error(`the sweep never hid the thinking label and truncated the model label`);
-  }
-  return { widest: steps[0], thinkingHidden, modelTruncated };
-}
-
-/** No frame recorded so far painted a truncated model label beside the thinking label. */
-export async function expectNoFrameTruncatesModelBesideThinking(page: Page): Promise<void> {
-  const frames = await page.evaluate(() => window.__modelTriggerFrames ?? []);
-  expect(frames.some((frame) => frame.modelShown)).toBe(true);
-  const wrong = frames
-    .map((frame, index) => ({ ...frame, index }))
-    .filter((frame) => frame.thinkingShown && frame.modelTruncated);
-  expect(wrong, `of ${frames.length} frames`).toEqual([]);
-}
-
-/** Where the composer toolbar's ends sit against the composer, in CSS pixels. */
-export interface ComposerToolbarRails {
-  /** Where the text column starts. */
-  textLeft: number;
-  /** Where the toolbar's leftmost ink starts. */
-  inkLeft: number;
-  /** How far the trailing disc sits from the composer's right edge. */
-  discRightInset: number;
-  /** How far the trailing disc sits from the composer's bottom edge. */
-  discBottomInset: number;
-}
-
-/**
- * Reads where the toolbar's ink starts against the text column and where the trailing disc sits
- * in the composer's corner. A control's ink is its filled disc when it has one, otherwise its
- * glyph's stroked geometry.
- */
-export async function readComposerToolbarRails(page: Page): Promise<ComposerToolbarRails> {
-  const root = page.locator('[data-testid="message-input-root"]:visible').first();
-  return root.evaluate((element) => {
-    const textarea = element.querySelector("textarea");
-    if (!textarea) throw new Error("composer has no text input");
-    const composerRect = element.getBoundingClientRect();
-    const textLeft =
-      textarea.getBoundingClientRect().left +
-      Number.parseFloat(getComputedStyle(textarea).paddingLeft);
-
-    const isFilled = (node: Element) => {
-      const color = getComputedStyle(node).backgroundColor;
-      return color !== "" && color !== "transparent" && !/rgba\(.*,\s*0\)$/.test(color);
-    };
-    const glyphInkLeft = (svg: SVGSVGElement) => {
-      let left = Number.POSITIVE_INFINITY;
-      for (const shape of Array.from(
-        svg.querySelectorAll<SVGGraphicsElement>("path, circle, rect, line, polyline"),
-      )) {
-        const matrix = shape.getScreenCTM();
-        if (!matrix) continue;
-        const box = shape.getBBox();
-        const stroke = Number.parseFloat(getComputedStyle(shape).strokeWidth || "0");
-        left = Math.min(left, matrix.a * (box.x - stroke / 2) + matrix.e);
-      }
-      return left;
-    };
-
-    const band = composerRect.bottom - 64;
-    let inkLeft = Number.POSITIVE_INFINITY;
-    let trailingDisc: DOMRect | null = null;
-    for (const control of Array.from(element.querySelectorAll('[role="button"]'))) {
-      const rect = control.getBoundingClientRect();
-      if (rect.width === 0 || rect.top < band) continue;
-      const disc = [control, ...Array.from(control.querySelectorAll("div"))].find(isFilled);
-      const svg = control.querySelector("svg");
-      if (disc) {
-        const discRect = disc.getBoundingClientRect();
-        inkLeft = Math.min(inkLeft, discRect.left);
-        if (!trailingDisc || discRect.right > trailingDisc.right) trailingDisc = discRect;
-      } else if (svg) {
-        inkLeft = Math.min(inkLeft, glyphInkLeft(svg));
-      }
-    }
-    if (!trailingDisc) throw new Error("composer toolbar has no trailing disc");
-    return {
-      textLeft,
-      inkLeft,
-      discRightInset: composerRect.right - trailingDisc.right,
-      discBottomInset: composerRect.bottom - trailingDisc.bottom,
-    };
-  });
-}
-
-/**
- * The toolbar's left ink sits on the text column's edge, and its trailing disc nests into the
- * corner, as far from the right edge as from the bottom edge. Within half a pixel.
- */
-export async function expectComposerToolbarOnTextRails(page: Page): Promise<void> {
-  const rails = await readComposerToolbarRails(page);
-  // A precision of 0 digits passes within half a pixel.
-  expect(rails.inkLeft).toBeCloseTo(rails.textLeft, 0);
-  expect(rails.discRightInset).toBeCloseTo(rails.discBottomInset, 0);
-}

packages/app/e2e/support/helpers/composer.ts

@@ -31,9 +31,7 @@ export async function expectComposerVisible(
   page: Page,
   options?: { timeout?: number },
 ): Promise<void> {
-  await expect(composerInput(page)).toBeVisible({
-    timeout: options?.timeout ?? 15_000,
-  });
+  await expect(composerInput(page)).toBeVisible({ timeout: options?.timeout ?? 15_000 });
 }
 
 export async function expectComposerDisabled(page: Page): Promise<void> {
@@ -158,9 +156,7 @@ export async function attachImageFromMenu(
 }
 
 export async function expectAttachmentPill(page: Page, testID: string): Promise<void> {
-  await expect(page.getByTestId(testID).first()).toBeVisible({
-    timeout: 10_000,
-  });
+  await expect(page.getByTestId(testID).first()).toBeVisible({ timeout: 10_000 });
 }
 
 export async function attachFileFromMenu(
@@ -222,24 +218,18 @@ export async function expectGithubAttachmentPill(
 
 export async function openImageLightbox(page: Page): Promise<void> {
   await page.getByRole("button", { name: "Open image attachment" }).first().click();
-  await expect(page.getByTestId("attachment-lightbox-close")).toBeVisible({
-    timeout: 5_000,
-  });
+  await expect(page.getByTestId("attachment-lightbox-close")).toBeVisible({ timeout: 5_000 });
 }
 
 export async function closeImageLightbox(page: Page): Promise<void> {
   await page.keyboard.press("Escape");
-  await expect(page.getByTestId("attachment-lightbox-close")).not.toBeVisible({
-    timeout: 5_000,
-  });
+  await expect(page.getByTestId("attachment-lightbox-close")).not.toBeVisible({ timeout: 5_000 });
 }
 
 export async function openGithubPickerFromMenu(page: Page): Promise<void> {
   await openAttachmentMenu(page);
   await page.getByTestId("message-input-attachment-menu-item-github").click();
-  await expect(page.getByTestId("combobox-desktop-container")).toBeVisible({
-    timeout: 5_000,
-  });
+  await expect(page.getByTestId("combobox-desktop-container")).toBeVisible({ timeout: 5_000 });
 }
 
 /** Open picker, type a query, wait for the matching option by id (e.g. "issue:3", "change_request:1"), and click it. */
@@ -293,10 +283,7 @@ export async function startRunningMockAgent(
     model: opts.model,
     featureValues: opts.featureValues,
   });
-  const agentUrl = `${buildHostWorkspaceRoute(
-    serverId,
-    workspace.id,
-  )}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
+  const agentUrl = `${buildHostWorkspaceRoute(serverId, workspace.id)}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
   await page.goto(agentUrl);
   await expectComposerVisible(page);
   await client.sendAgentMessage(agent.id, opts.prompt);
@@ -360,11 +347,7 @@ export async function pasteComposerTestImage(page: Page): Promise<boolean> {
     const bytes = Uint8Array.from(atob(base64), (character) => character.charCodeAt(0));
     const clipboardData = new DataTransfer();
     clipboardData.items.add(new File([bytes], "pasted.png", { type: "image/png" }));
-    const event = new ClipboardEvent("paste", {
-      clipboardData,
-      bubbles: true,
-      cancelable: true,
-    });
+    const event = new ClipboardEvent("paste", { clipboardData, bubbles: true, cancelable: true });
     input.dispatchEvent(event);
     return event.defaultPrevented;
   }, COMPOSER_TEST_IMAGE_BASE64);
@@ -522,10 +505,7 @@ export async function recordVisibleComposerGeometry(page: Page): Promise<void> {
 export async function expectNoCollapsedVisibleComposer(page: Page): Promise<void> {
   const frames = await page.evaluate(() => {
     Reflect.get(window, "__stopComposerGeometry")?.();
-    return Reflect.get(window, "__composerGeometryFrames") as {
-      input: number;
-      root: number;
-    }[];
+    return Reflect.get(window, "__composerGeometryFrames") as { input: number; root: number }[];
   });
   expect(frames.length).toBeGreaterThan(0);
   expect(frames.filter((frame) => frame.root < 42 || frame.input < 42)).toEqual([]);
@@ -536,10 +516,7 @@ export async function roundTripComposerTabBeforePaint(
   page: Page,
   activeChatTitle: string,
 ): Promise<void> {
-  const activeTab = page.getByRole("button", {
-    name: activeChatTitle,
-    exact: true,
-  });
+  const activeTab = page.getByRole("button", { name: activeChatTitle, exact: true });
   await expect(activeTab).toHaveAttribute("aria-selected", "true");
   const result = await activeTab.evaluate((tab) => {
     const editor = document.activeElement;
@@ -579,10 +556,7 @@ export async function roundTripComposerTabBeforePaint(
           });
         }
       });
-      observer.observe(tab, {
-        attributes: true,
-        attributeFilter: ["aria-selected"],
-      });
+      observer.observe(tab, { attributes: true, attributeFilter: ["aria-selected"] });
       shortcut("BracketLeft");
     });
   });
@@ -592,44 +566,3 @@ export async function roundTripComposerTabBeforePaint(
   ).toBe(true);
   expect(result.focused, "returning on touch must leave the composer unfocused").toBe(false);
 }
-
-/** Paste both clipboard representations through the browser's normal paste command. */
-export async function pasteRichTextIntoComposer({
-  page,
-  html,
-  text,
-}: {
-  page: Page;
-  html: string;
-  text: string;
-}): Promise<void> {
-  await page.context().grantPermissions(["clipboard-read", "clipboard-write"]);
-  await page.evaluate(
-    async ({ html: richHtml, text: plainText }) => {
-      await navigator.clipboard.write([
-        new ClipboardItem({
-          "text/html": new Blob([richHtml], { type: "text/html" }),
-          "text/plain": new Blob([plainText], { type: "text/plain" }),
-        }),
-      ]);
-    },
-    { html, text },
-  );
-  await composerInput(page).press("ControlOrMeta+v");
-}
-
-export async function undoComposerEdit(page: Page): Promise<void> {
-  await composerInput(page).press("ControlOrMeta+z");
-}
-export async function redoComposerEdit(page: Page): Promise<void> {
-  await composerInput(page).press("ControlOrMeta+Shift+z");
-}
-
-/** Reuse the actual response Copy action and the browser's native paste. */
-export async function copyLatestTurnIntoComposer(page: Page): Promise<void> {
-  await page.context().grantPermissions(["clipboard-read", "clipboard-write"]);
-  await page.getByRole("button", { name: "Copy turn", exact: true }).last().click();
-  await expect(page.getByRole("button", { name: "Copied", exact: true })).toBeVisible();
-  await composerInput(page).fill("");
-  await composerInput(page).press("ControlOrMeta+v");
-}

packages/app/e2e/support/helpers/context-window.ts

@@ -49,83 +49,6 @@ export async function moveOntoContextWindowDetails(page: Page, card: Locator): P
   await page.mouse.move(meter.x + meter.width / 2, box.y + box.height / 2, { steps: 20 });
 }
 
-/** The hover card as one painted frame showed it, or unmounted. */
-export interface ContextWindowFrame {
-  mounted: boolean;
-  bottom: number | null;
-  loading: boolean;
-  usageCards: number;
-}
-
-/**
- * Reads the hover card as it was painted, every frame, until stopped, so a state that lasted one
- * frame is seen. Stop it only after everything has settled.
- */
-export async function recordContextWindowFrames(
-  page: Page,
-): Promise<{ stop: () => Promise<ContextWindowFrame[]> }> {
-  await page.evaluate(() => {
-    const recorder = window as unknown as {
-      __contextWindowFrames: ContextWindowFrame[];
-      __contextWindowRecording: boolean;
-    };
-    recorder.__contextWindowFrames = [];
-    recorder.__contextWindowRecording = true;
-    const findCard = () =>
-      document.querySelector<HTMLElement>('[data-testid="context-window-details"]');
-    const read = (card: HTMLElement | null): ContextWindowFrame => ({
-      mounted: card !== null,
-      bottom: card?.getBoundingClientRect().bottom ?? null,
-      loading: card?.innerText.includes("Loading usage...") ?? false,
-      usageCards: card?.querySelectorAll('[data-testid^="usage-report-"]').length ?? 0,
-    });
-    // A card that just resized has not been painted yet: its frame is read from an observer,
-    // which runs before that paint.
-    let watched: HTMLElement | null = null;
-    let paintedHeight: number | null = null;
-    let observer: ResizeObserver | null = null;
-    const watch = (card: HTMLElement) => {
-      observer = new ResizeObserver(() => {
-        paintedHeight = card.offsetHeight;
-        recorder.__contextWindowFrames.push(read(card));
-      });
-      observer.observe(card);
-    };
-    const channel = new MessageChannel();
-    // A message posted from an animation frame runs after that frame's paint.
-    channel.port1.addEventListener("message", () => {
-      const card = findCard();
-      if (card !== watched) {
-        observer?.disconnect();
-        watched = card;
-        paintedHeight = null;
-        if (card) watch(card);
-      }
-      if (!card || card.offsetHeight === paintedHeight) {
-        recorder.__contextWindowFrames.push(read(card));
-      }
-    });
-    channel.port1.start();
-    const sample = () => {
-      if (!recorder.__contextWindowRecording) return;
-      channel.port2.postMessage(null);
-      requestAnimationFrame(sample);
-    };
-    requestAnimationFrame(sample);
-  });
-  return {
-    stop: () =>
-      page.evaluate(() => {
-        const recorder = window as unknown as {
-          __contextWindowFrames: ContextWindowFrame[];
-          __contextWindowRecording: boolean;
-        };
-        recorder.__contextWindowRecording = false;
-        return recorder.__contextWindowFrames;
-      }),
-  };
-}
-
 export async function leaveContextWindowMeter(page: Page): Promise<void> {
   await page.mouse.move(0, 0);
   await expect(contextWindowDetails(page)).toHaveCount(0);
@@ -216,8 +139,6 @@ export interface AgentUsageScript {
   agentRequests(): string[];
   /** Each scoped agent Refresh, by agent ID. */
   refreshedAgents(): string[];
-  /** Reloads the agent's session, which starts it under a new usage scope, as a resume does. */
-  resumeAgent(agent: MockAgentSession): Promise<void>;
 }
 
 /**
@@ -248,8 +169,6 @@ export async function scriptAgentUsage(page: Page): Promise<AgentUsageScript> {
       usage
         .listRequests()
         .flatMap((request) => (request.forceRefresh && request.agentId ? [request.agentId] : [])),
-    resumeAgent: (agent) =>
-      usage.untilUsageScopeChanges(agent.agentId, () => agent.client.refreshAgent(agent.agentId)),
   };
 }
 

packages/app/e2e/support/helpers/diagram.ts

@@ -148,59 +148,3 @@ export async function expectFullscreenDiagram(
 export async function expectFullscreenDiagramClosed(page: Page): Promise<void> {
   await expect(page.getByTestId(FULLSCREEN_VIEWPORT)).toHaveCount(0);
 }
-
-/** Tall diagrams stay within the screen so their controls remain reachable. */
-export async function expectInlineDiagramFitsViewport(page: Page): Promise<void> {
-  const viewport = page.getByTestId("mermaid-viewport").last();
-  const box = await viewport.boundingBox();
-  expect(box, "the inline diagram has measurable layout").not.toBeNull();
-  const screenHeight = page.viewportSize()!.height;
-  expect(box!.height, "the inline diagram fits within the screen").toBeLessThan(screenHeight);
-  const contentHeight = await diagramSvg(page, "mermaid-viewport").evaluate(
-    (svg) => (svg as SVGSVGElement).viewBox.baseVal.height,
-  );
-  expect(box!.height, "a tall diagram is bounded rather than expanding the chat").toBeLessThan(
-    contentHeight,
-  );
-}
-
-/** Exercise pointer toggles and the controls encountered along that same journey. */
-export async function toggleDiagramSourceAndVerifyControls(page: Page): Promise<void> {
-  const viewport = page.getByTestId("mermaid-viewport").last();
-  const iframe = await viewport.locator("iframe").elementHandle();
-  for (let iteration = 0; iteration < 3; iteration++) {
-    await viewport.hover();
-    await page.getByRole("button", { name: "View source" }).last().click();
-    const viewDiagram = page.getByRole("button", { name: "View diagram" }).last();
-    await viewDiagram.click({ timeout: 10_000 });
-    await expect(viewDiagram).toHaveCount(0);
-    await expectFullscreenDiagramClosed(page);
-    expect(
-      await viewport.locator("iframe").evaluate((node, original) => node === original, iframe),
-      "switching views preserves the rendered diagram",
-    ).toBe(true);
-  }
-  await viewport.hover();
-  await page.getByRole("button", { name: "View source" }).last().click();
-  const hiddenFullscreen = viewport.getByRole("button", {
-    name: "Fullscreen",
-    includeHidden: true,
-  });
-  await hiddenFullscreen.focus();
-  await expect(hiddenFullscreen).not.toBeFocused();
-  await page.getByRole("button", { name: "View diagram" }).last().click();
-  await viewport.hover();
-  const fullscreen = viewport.getByRole("button", { name: "Fullscreen", exact: true });
-  const box = await viewport.boundingBox();
-  const control = await fullscreen.boundingBox();
-  expect(box).not.toBeNull();
-  expect(control).not.toBeNull();
-  expect(control!.y, "the toolbar starts inside the preview").toBeGreaterThanOrEqual(box!.y);
-  expect(control!.y + control!.height, "the toolbar fits inside the preview").toBeLessThanOrEqual(
-    box!.y + box!.height,
-  );
-  await viewport.getByRole("button", { name: "Zoom in" }).click();
-  await expect(viewport.getByRole("button", { name: "Reset view" })).toBeEnabled();
-  await viewport.getByRole("button", { name: "Reset view" }).click();
-  await expect(viewport.getByRole("button", { name: "Reset view" })).toBeDisabled();
-}