chore(release): cut 0.1.110

ACP setup and out-of-prompt notifications do not define a turn lifecycle. Treating them as autonomous turns could complete the active run while its prompt was still streaming.

.github/workflows/android-apk-release.yml

@@ -71,7 +71,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install JS dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/ci.yml

@@ -33,7 +33,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
 
       - name: Check formatting
         run: npx oxfmt --check .
@@ -51,7 +51,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
 
       - name: Lint lockfile
         run: npx --yes lockfile-lint --path package-lock.json --type npm --allowed-hosts npm --validate-https --validate-integrity
@@ -75,7 +75,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
       - name: Build server stack
         run: npm run build:server
 
@@ -111,9 +111,9 @@ jobs:
         run: git fetch --no-tags origin main:refs/remotes/origin/main
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
       - name: Install agent CLIs for provider tests
-        run: npm install -g @anthropic-ai/claude-code opencode-ai
+        run: node scripts/npm-retry.mjs install -g @anthropic-ai/claude-code opencode-ai
 
       - name: Build server dependencies
         run: npm run build:server-deps
@@ -139,35 +139,8 @@ jobs:
           node-version: "22"
           cache: "npm"
 
-      - name: Install dependencies with Electron retry
-        if: runner.os != 'Windows'
-        run: |
-          for attempt in 1 2 3; do
-            if npm ci; then
-              exit 0
-            else
-              exit_code=$?
-            fi
-            if [ "$attempt" -eq 3 ]; then
-              exit $exit_code
-            fi
-            sleep $((attempt * 20))
-          done
-
-      - name: Install dependencies with Electron retry
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          for ($attempt = 1; $attempt -le 3; $attempt++) {
-            npm ci
-            if ($LASTEXITCODE -eq 0) {
-              exit 0
-            }
-            if ($attempt -eq 3) {
-              exit $LASTEXITCODE
-            }
-            Start-Sleep -Seconds (20 * $attempt)
-          }
+      - name: Install dependencies with retry
+        run: node scripts/npm-retry.mjs ci
       - name: Build server stack
         run: npm run build:server
 
@@ -187,18 +160,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies with retry
-        run: |
-          for attempt in 1 2 3; do
-            if npm ci; then
-              exit 0
-            else
-              exit_code=$?
-            fi
-            if [ "$attempt" -eq 3 ]; then
-              exit $exit_code
-            fi
-            sleep $((attempt * 20))
-          done
+        run: node scripts/npm-retry.mjs ci
       - name: Install Playwright browsers
         timeout-minutes: 10
         run: npx playwright install chromium
@@ -222,7 +184,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
       - name: Build client dependencies
         run: npm run build:client
 
@@ -258,18 +220,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies with retry
-        run: |
-          for attempt in 1 2 3; do
-            if npm ci; then
-              exit 0
-            else
-              exit_code=$?
-            fi
-            if [ "$attempt" -eq 3 ]; then
-              exit $exit_code
-            fi
-            sleep $((attempt * 20))
-          done
+        run: node scripts/npm-retry.mjs ci
       - name: Install Playwright browsers
         timeout-minutes: 10
         run: npx playwright install chromium
@@ -282,7 +233,7 @@ jobs:
 
       - name: Install agent CLIs for provider tests
         if: ${{ !matrix.desktop }}
-        run: npm install -g @anthropic-ai/claude-code @openai/codex@0.105.0 opencode-ai
+        run: node scripts/npm-retry.mjs install -g @anthropic-ai/claude-code @openai/codex@0.105.0 opencode-ai
 
       - name: Run Playwright E2E tests
         if: ${{ !matrix.desktop }}
@@ -317,7 +268,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
 
       - name: Build relay
         run: npm run build:relay
@@ -343,10 +294,10 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
 
       - name: Install agent CLIs for provider tests
-        run: npm install -g @anthropic-ai/claude-code @openai/codex@0.105.0 opencode-ai
+        run: node scripts/npm-retry.mjs install -g @anthropic-ai/claude-code @openai/codex@0.105.0 opencode-ai
 
       - name: Run CLI tests
         run: npm run test --workspace=@getpaseo/cli

.github/workflows/deploy-app.yml

@@ -24,7 +24,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Build app dependencies

.github/workflows/deploy-relay.yml

@@ -1,11 +1,8 @@
 name: Deploy Relay
 
 on:
-  push:
-    branches: [main]
-    paths:
-      - "packages/relay/**"
-      - ".github/workflows/deploy-relay.yml"
+  # Manual-only while relay.paseo.sh bridges traffic to the Fly deployment.
+  # A release or main push must not redeploy the temporary Cloudflare bridge.
   workflow_dispatch:
 
 jobs:
@@ -21,7 +18,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci --workspace=@getpaseo/relay --include-workspace-root
+        run: node scripts/npm-retry.mjs ci --workspace=@getpaseo/relay --include-workspace-root
 
       - name: Typecheck
         run: npm run typecheck --workspace=@getpaseo/relay

.github/workflows/deploy-website.yml

@@ -29,7 +29,7 @@ jobs:
           cache: "npm"
 
       - name: Install dependencies
-        run: npm ci --workspace=@getpaseo/website --include-workspace-root
+        run: node scripts/npm-retry.mjs ci --workspace=@getpaseo/website --include-workspace-root
 
       - name: Typecheck
         run: npm run typecheck --workspace=@getpaseo/website

.github/workflows/desktop-release.yml

@@ -127,7 +127,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install JS dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -227,7 +227,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install JS dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -325,7 +325,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install JS dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -425,7 +425,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install JS dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/desktop-rollout.yml

@@ -47,7 +47,7 @@ jobs:
           scope: "@boudra"
 
       - name: Install JS dependencies
-        run: npm ci
+        run: node scripts/npm-retry.mjs ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/nix.yml

@@ -9,12 +9,15 @@ on:
       - "flake.lock"
       - "package.json"
       - "package-lock.json"
+      - "packages/app/**"
+      - "packages/expo-two-way-audio/**"
       - "packages/highlight/**"
       - "packages/protocol/**"
       - "packages/client/**"
       - "packages/server/**"
       - "packages/relay/**"
       - "packages/cli/**"
+      - "scripts/build-daemon-web-ui.mjs"
       - "scripts/update-nix.sh"
       - "scripts/fix-lockfile.mjs"
       - ".github/workflows/nix.yml"
@@ -64,7 +67,7 @@ jobs:
           }
           trap cleanup EXIT
 
-          ./result/bin/paseo-server --no-relay >"$WRAPPER_LOG" 2>&1 &
+          PASEO_WEB_UI_ENABLED=true ./result/bin/paseo-server --no-relay >"$WRAPPER_LOG" 2>&1 &
           DAEMON_PID=$!
 
           deadline=$((SECONDS + 30))
@@ -72,6 +75,8 @@ jobs:
             if STATUS_JSON="$(./result/bin/paseo daemon status --json)" \
               && jq -e '.connectedDaemon == "reachable"' <<<"$STATUS_JSON" >/dev/null; then
               echo "$STATUS_JSON"
+              curl --fail --silent --show-error http://127.0.0.1:6767/ >"$PASEO_HOME/web-ui.html"
+              [[ -s "$PASEO_HOME/web-ui.html" ]]
               exit 0
             fi
 

.mise.toml

@@ -1,9 +1,10 @@
 [env]
-ANDROID_HOME = "{{env.HOME}}/.local/share/mise/installs/android-sdk/1.0"
+ANDROID_HOME = "{{env.HOME}}/.local/share/mise/installs/android-sdk/21.0"
 _.path = [
-  "{{env.HOME}}/.local/share/mise/installs/android-sdk/1.0/platform-tools",
-  "{{env.HOME}}/.local/share/mise/installs/android-sdk/1.0/emulator",
+  "{{env.HOME}}/.local/share/mise/installs/android-sdk/21.0/cmdline-tools/21.0/bin",
+  "{{env.HOME}}/.local/share/mise/installs/android-sdk/21.0/platform-tools",
+  "{{env.HOME}}/.local/share/mise/installs/android-sdk/21.0/emulator",
 ]
 
 [tools]
-java = "17"
+java = "21"

.tool-versions

@@ -1,4 +1,4 @@
 rust        1.85.1
 nodejs      22.20.0
 java        21
-android-sdk latest
+android-sdk 21.0

CHANGELOG.md

@@ -1,5 +1,93 @@
 # Changelog
 
+## 0.1.110 - 2026-07-16
+
+### Fixed
+
+- Kimi and other ACP agents now stay marked as running while a response is actively streaming ([#2148](https://github.com/getpaseo/paseo/pull/2148))
+
+## 0.1.109 - 2026-07-16
+
+### Fixed
+
+- Paseo Desktop no longer gets stuck connecting or loses native window controls after updating ([#2111](https://github.com/getpaseo/paseo/pull/2111) by [@cleiter](https://github.com/cleiter))
+
+## 0.1.108 - 2026-07-16
+
+### Added
+
+- Create a new project folder or clone a GitHub repository from Add Project ([#1331](https://github.com/getpaseo/paseo/pull/1331), [#2045](https://github.com/getpaseo/paseo/pull/2045), [#2097](https://github.com/getpaseo/paseo/pull/2097) by [@mcowger](https://github.com/mcowger))
+- Search for and open workspaces from the search menu ([#2096](https://github.com/getpaseo/paseo/pull/2096))
+- Pin workspaces to the top of the sidebar ([#1981](https://github.com/getpaseo/paseo/pull/1981) by [@half144](https://github.com/half144))
+- Summarize tool calls in a single collapsed item with a new appearance setting ([#2031](https://github.com/getpaseo/paseo/pull/2031), [#2069](https://github.com/getpaseo/paseo/pull/2069), [#2090](https://github.com/getpaseo/paseo/pull/2090) by [@mcowger](https://github.com/mcowger))
+- Save browser cookies and site data across tabs and restarts ([#2089](https://github.com/getpaseo/paseo/pull/2089))
+- Claude and Codex subagents now show their actual names, with a new option to archive finished Claude Code, Codex, and OpenCode subagents ([#2073](https://github.com/getpaseo/paseo/pull/2073))
+- Fork chats from failed turns ([#2063](https://github.com/getpaseo/paseo/pull/2063))
+
+### Improved
+
+- Permission modes have clearer icons ([#1980](https://github.com/getpaseo/paseo/pull/1980) by [@cleiter](https://github.com/cleiter))
+- Desktop stays usable in narrower windows ([#1983](https://github.com/getpaseo/paseo/pull/1983))
+- Sidebar controls stay in place when desktop panels open and close ([#2078](https://github.com/getpaseo/paseo/pull/2078))
+- Typing in long drafts is smoother ([#2086](https://github.com/getpaseo/paseo/pull/2086))
+- Codex terminal commands always appear in chat, even when they have no output ([#2037](https://github.com/getpaseo/paseo/pull/2037))
+
+### Fixed
+
+- New Workspace keeps your prompt and attachments when you switch projects or hosts ([#2030](https://github.com/getpaseo/paseo/pull/2030), [#2036](https://github.com/getpaseo/paseo/pull/2036))
+- OpenCode sessions close without crashing Paseo ([#2027](https://github.com/getpaseo/paseo/pull/2027) by [@mcowger](https://github.com/mcowger))
+- Pi slash commands no longer leave chats stuck as running ([#2066](https://github.com/getpaseo/paseo/pull/2066) by [@ebg1223](https://github.com/ebg1223))
+- Background-agent updates now appear after the main reply ([#2058](https://github.com/getpaseo/paseo/pull/2058) by [@1254087415](https://github.com/1254087415))
+- Codex subagents no longer disappear from the Subagents track ([#2068](https://github.com/getpaseo/paseo/pull/2068))
+- Forked chats open ready to edit in their new tab ([#2038](https://github.com/getpaseo/paseo/pull/2038))
+- Paseo Desktop opens normally after an interrupted shutdown ([#1962](https://github.com/getpaseo/paseo/pull/1962))
+- Keyboard shortcuts now work with `-`, `=`, `;`, and `'` ([#2047](https://github.com/getpaseo/paseo/pull/2047) by [@OnCloud125252](https://github.com/OnCloud125252))
+- Codebuddy Code models now appear in the model picker ([#1979](https://github.com/getpaseo/paseo/pull/1979) by [@park0er](https://github.com/park0er))
+- Workspace search now includes OpenCode commands and workflows ([#2049](https://github.com/getpaseo/paseo/pull/2049))
+- Nix installations now include the Paseo web app ([#1978](https://github.com/getpaseo/paseo/pull/1978) by [@liamdiprose](https://github.com/liamdiprose))
+
+## 0.1.107 - 2026-07-13
+
+### Added
+
+- Inspect provider-created subagents and their live conversations from the Subagents track ([#2013](https://github.com/getpaseo/paseo/pull/2013) by [@omercnet](https://github.com/omercnet))
+- Fork chats with every supported agent provider ([#2022](https://github.com/getpaseo/paseo/pull/2022))
+
+### Improved
+
+- Add projects directly from New Workspace when none are configured ([#2026](https://github.com/getpaseo/paseo/pull/2026))
+- New terminals open at the correct size immediately ([#2023](https://github.com/getpaseo/paseo/pull/2023) by [@cleiter](https://github.com/cleiter))
+- Sidebar footer actions now explain themselves with tooltips ([#2025](https://github.com/getpaseo/paseo/pull/2025))
+- Codex shell tool calls show only the command being run ([#2029](https://github.com/getpaseo/paseo/pull/2029))
+- Custom ACP providers keep file and terminal work in the agent environment by default ([#2024](https://github.com/getpaseo/paseo/pull/2024))
+- ACP provider catalog updated to the latest registry versions
+
+### Fixed
+
+- Large tables no longer make iOS chats unresponsive
+- Chat controls remain clickable near the scroll-to-bottom button ([#2007](https://github.com/getpaseo/paseo/pull/2007))
+- Oversized tool output no longer slows or floods chat timelines ([#2020](https://github.com/getpaseo/paseo/pull/2020))
+- Cross-provider subagents can use providers without mode settings ([#2000](https://github.com/getpaseo/paseo/pull/2000) by [@githubbzxs](https://github.com/githubbzxs))
+- Pi's internal metadata tasks no longer clutter normal session history ([#1999](https://github.com/getpaseo/paseo/pull/1999) by [@githubbzxs](https://github.com/githubbzxs))
+- Pi chats remain usable after canceling extension commands ([#2019](https://github.com/getpaseo/paseo/pull/2019))
+
+## 0.1.106 - 2026-07-12
+
+### Added
+
+- Approve Codex MCP permission requests in Paseo ([#2001](https://github.com/getpaseo/paseo/pull/2001))
+
+### Improved
+
+- ACP provider catalog updated to the latest registry versions
+
+### Fixed
+
+- Reduced mobile chat freezes and blank screens when switching workspaces while agents are streaming ([#1989](https://github.com/getpaseo/paseo/pull/1989))
+- OpenCode sessions start reliably instead of occasionally losing the first turn ([#2015](https://github.com/getpaseo/paseo/pull/2015) by [@mcowger](https://github.com/mcowger))
+- Switching between workspaces no longer flashes a white screen
+- Pi keeps your existing MCP tools and settings when Paseo adds its own ([#1990](https://github.com/getpaseo/paseo/pull/1990) by [@mcowger](https://github.com/mcowger))
+
 ## 0.1.105 - 2026-07-10
 
 ### Added

README.md

@@ -70,7 +70,7 @@ You need at least one agent CLI installed and configured with your credentials:
 
 Download it from [paseo.sh/download](https://paseo.sh/download) or the [GitHub releases page](https://github.com/getpaseo/paseo/releases). Open the app and the daemon starts automatically. Nothing else to install.
 
-To connect from your phone, scan the QR code shown in Settings.
+To connect from your phone, open **Settings → your host → Connections → Pair a device**.
 
 ### CLI / headless
 

docs/agent-lifecycle.md

@@ -12,6 +12,10 @@ initializing → idle → running → idle (or error → closed)
 
 Each agent in `AgentManager` carries a `lastStatus` of `initializing`, `idle`, `running`, `error`, or `closed`. State transitions persist to disk and stream to subscribed clients via WebSocket.
 
+### Cancellation
+
+Cancellation changes lifecycle state only after the provider acknowledges the interrupt or emits a terminal turn event. If the interrupt is rejected or times out, the agent remains `running` with its active foreground turn intact. Follow-up actions such as replacement, reload, rewind, and Stop must report that failure instead of accepting work they cannot perform. Synthesizing a local cancellation without provider acknowledgment creates a split-brain session: Paseo accepts a new prompt while the provider still owns the previous foreground turn.
+
 ## Relationships
 
 Agents can launch other agents via the agent-scoped `create_agent` MCP tool. Agent-scoped creation is always asynchronous. `relationship` and `workspace` are separate decisions:
@@ -61,23 +65,33 @@ Closing a tab on a **root agent** still archives — the tab is the agent's home
 
 Closing a tab on a **subagent** (any agent with `parentAgentId`) is **layout-only**. The agent stays unarchived and stays in its parent's track. The user can re-open the tab from the track at any time. This is implemented in `handleCloseAgentTab` (`packages/app/src/screens/workspace/workspace-screen.tsx`).
 
-The asymmetry is intentional: a subagent's home is the parent's track, not the tab. Tabs are ephemeral viewing slots; the track is the persistent record of the parent's children.
+The asymmetry is intentional: a subagent's persistent relationship lives in the parent's track. Same-workspace subagents are not auto-opened as tabs; the user opens one from that track when needed. A cross-workspace subagent is also auto-opened as a tab in its own workspace so opening that workspace does not appear empty. It remains in the parent's track until it is actually detached.
 
 ## Workspace activity
 
 Agent lifecycle status stays literal: a parent agent is `idle` when its own turn is idle, even if a child is running.
 
-Workspace status is an aggregate activity signal computed **per `workspaceId`**: a workspace's status reflects only records whose `workspaceId === workspace.id`. Ownership is never derived from `cwd` — many workspaces may share one directory, and same-`cwd` siblings do not clump under one status. A root agent contributes its normal state bucket to its owning workspace only. Running subagents contribute `running` to their root parent's owning workspace (by the parent agent's `workspaceId`), not to the subagent's current `cwd` or worktree. Non-running subagent attention, permission, and error states stay in the parent's subagents track and do not escalate the workspace bucket.
+Workspace status is an aggregate activity signal computed **per `workspaceId`**. Ownership is never derived from `cwd` — many workspaces may share one directory, and same-`cwd` siblings do not clump under one status. Root agents and cross-workspace subagents contribute their normal state bucket to their own workspace. Same-workspace descendants contribute `running` to the nearest ancestor in that workspace; their non-running attention, permission, and error states stay in the parent's subagents track. This makes a cross-workspace subagent behave like a detached agent for workspace visibility and status without removing its parent relationship.
 
 ## The subagents track
 
-The collapsible track above the composer in an agent's pane (`packages/app/src/subagents/track.tsx`). Membership rule (`packages/app/src/subagents/select.ts`):
+The collapsible track above the composer in an agent's pane (`packages/app/src/subagents/track.tsx`) combines two kinds of children:
+
+- **Paseo subagents** are full managed agents. Their membership rule (`packages/app/src/subagents/select.ts`) is:
 
 ```
 parentAgentId === thisAgent.id  AND  !archivedAt
 ```
 
-Archived subagents disappear from the track, by design. To remove a subagent from the track without closing its tab, use the **archive button (X)** on the row — it opens a confirm dialog and archives the subagent on confirm. That same archive shows the subagent leave the track on every connected client.
+- **Provider subagents** are child executions owned by Claude, Codex, or OpenCode. They are not inserted into `AgentManager` as managed agents. Providers emit a separate descriptor and timeline stream through `agent.provider_subagents.*`; the client keeps that state outside the normal agent store and merges only the presentation rows into the track.
+
+Clicking either kind opens a workspace tab. A Paseo subagent tab is a normal interactive agent pane. A provider subagent tab is a read-only timeline pane with no composer, archive, detach, rewind, or fork actions. Both panes use `AgentStreamView`, so message, reasoning, tool-call, and layout rendering stay identical.
+
+Provider timelines use the same structural timeline item format but deliberately have a separate lifecycle and transport. A provider thread/session identifier is not a Paseo agent identifier, and closing its tab is always layout-only.
+
+Archived Paseo subagents disappear from the track, by design. To remove one from the track without closing its tab, use the **archive button** on the row — it opens a confirm dialog and archives the subagent on confirm. Provider-owned rows have no individual Paseo lifecycle controls.
+
+The track header's **Archive finished** action hides finished provider-owned rows in the current app session. Their native sessions and timelines are untouched, and managed Paseo subagents are not archived by this bulk action. If a hidden provider child starts running again, the app brings it back to the track.
 
 To keep the agent alive but remove it from the parent's track, use **detach**. The daemon clears the parent label, emits the normal agent update, and every client reclassifies the agent from subagent to root/sibling from that updated snapshot.
 
@@ -97,7 +111,7 @@ We considered universal decoupling (no tab close ever archives, archive is alway
 
 ### Subagent accumulation under long-lived parents
 
-A parent that spawns many subagents will see the track grow. There's no automatic cleanup for completed subagents — the user prunes via the archive button on each row. A bulk gesture (e.g. "archive all idle children") could land later if this becomes a real problem.
+A parent that spawns many subagents will see the track grow. Managed Paseo subagents can be archived individually. Finished provider-owned rows can be hidden together with **Archive finished**; this is app-local presentation state and resets when the app restarts.
 
 ### Cross-client tab dismissal
 

docs/android.md

@@ -13,6 +13,50 @@ EAS profiles: `development`, `production`, and `production-apk` in `packages/app
 
 `development` uses Android `debug`.
 
+## Version codes
+
+`packages/app/app.config.js` derives Android `versionCode` from the package version with:
+
+```text
+major * 1_000_000 + minor * 1_000 + patch
+```
+
+Prerelease metadata is ignored, so `0.1.102-beta.1` and `0.1.102` both produce `1102`. The same value is used as the iOS `buildNumber` because `packages/app/eas.json` uses EAS's local app version source. Do not re-enable EAS remote version counters or Android `autoIncrement`; F-Droid and other source-based builders need the native build number to be visible in the repo.
+
+The formula reserves three digits each for minor and patch. If either reaches `1000`, change the formula before cutting that release.
+
+## Prerequisites (local dev)
+
+Local Android builds run on macOS (or Linux) and need the Android toolchain, pinned in `.tool-versions` (`java 21`, `android-sdk 21.0`) and wired up by `.mise.toml` (which sets `ANDROID_HOME` and puts `cmdline-tools/21.0/bin`, `platform-tools`, and `emulator` on `PATH`). With [mise](https://mise.jdx.dev):
+
+```bash
+mise install        # java 21 + android-sdk 21.0 command-line tools
+```
+
+> **Pin a real `android-sdk` version, not `latest`.** The mise `android-sdk` plugin's `latest` resolved to the ancient `1.0` bundle, whose `sdkmanager` (3.6.0) predates the `emulator` package and fails with `Failed to find package emulator`. `21.0` ships a current `sdkmanager`. If you bump it, update the version in `.tool-versions` and in all four paths in `.mise.toml`.
+
+`mise install` only lays down the command-line tools. Install the rest and create an emulator. On Apple Silicon:
+
+```bash
+sdkmanager --licenses
+sdkmanager "platform-tools" "emulator" "platforms;android-35" "build-tools;35.0.0" \
+           "system-images;android-35;google_apis;arm64-v8a"
+avdmanager create avd -n paseo -k "system-images;android-35;google_apis;arm64-v8a" -d pixel_7
+emulator @paseo     # start it; leave running
+```
+
+On an Intel Mac, use the `x86_64` system image:
+
+```bash
+sdkmanager --licenses
+sdkmanager "platform-tools" "emulator" "platforms;android-35" "build-tools;35.0.0" \
+           "system-images;android-35;google_apis;x86_64"
+avdmanager create avd -n paseo -k "system-images;android-35;google_apis;x86_64" -d pixel_7
+emulator @paseo     # start it; leave running
+```
+
+Gradle auto-fetches the platform/build-tools it needs once licenses are accepted, so adjust `android-35` only if it asks for a different level.
+
 ## Local build + install
 
 From repo root:
@@ -38,6 +82,46 @@ npx cross-env APP_VARIANT=production expo run:android --variant=release
 rm -rf android
 ```
 
+## Running on an emulator against a worktree daemon
+
+`npm run android` builds and installs the dev client, but two connections have to reach your Mac from inside the emulator — Metro (the JS bundle) and the Paseo daemon — and **the emulator does not share the host's loopback**: `localhost` inside the emulator is the emulator itself. Reach the host at `10.0.2.2` (the standard AVD's host alias) for both:
+
+```bash
+REACT_NATIVE_PACKAGER_HOSTNAME=10.0.2.2 \
+  EXPO_PUBLIC_LOCAL_DAEMON=10.0.2.2:$PASEO_SERVICE_DAEMON_PORT \
+  npm run android
+```
+
+- **`REACT_NATIVE_PACKAGER_HOSTNAME=10.0.2.2`** — without it, Expo bakes your Mac's LAN IP into the dev client's Metro URL, which the emulator can't route to, and the app dies with `Failed to connect to /<lan-ip>:8081` before any JS loads.
+- **`EXPO_PUBLIC_LOCAL_DAEMON=10.0.2.2:<port>`** — the client's daemon endpoint (`packages/app/src/runtime/host-runtime.ts`); when unset it defaults to `localhost:6767`, the production daemon. Use `$PASEO_SERVICE_DAEMON_PORT` for a worktree daemon running as a Paseo service, or `6768` for a standalone `npm run dev:server`. It is inlined into the JS bundle at Metro bundle time, so set it on the build command and clear the Metro cache (`npx expo start -c`) if a change doesn't take.
+
+**Alternative — `adb reverse` + `localhost`** (if `10.0.2.2` misbehaves):
+
+```bash
+adb reverse tcp:8081 tcp:8081
+adb reverse tcp:$PASEO_SERVICE_DAEMON_PORT tcp:$PASEO_SERVICE_DAEMON_PORT
+REACT_NATIVE_PACKAGER_HOSTNAME=localhost \
+  EXPO_PUBLIC_LOCAL_DAEMON=localhost:$PASEO_SERVICE_DAEMON_PORT \
+  npm run android
+```
+
+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`.
+
+## F-Droid / source-only Android builds
+
+F-Droid builds should set `PASEO_FDROID_BUILD=1` when running Expo prebuild:
+
+```bash
+cd packages/app
+PASEO_FDROID_BUILD=1 APP_VARIANT=production npx expo prebuild --platform android --clean --non-interactive
+cd android
+PASEO_FDROID_BUILD=1 ./gradlew assembleRelease --no-daemon --max-workers=1 -Dorg.gradle.parallel=false
+```
+
+The flag must be present for both prebuild and Gradle because Gradle starts Metro for the release bundle. Keep the source build serial and daemon-free as shown above: compiling every Expo module can exhaust memory when Gradle workers run in parallel. The profile enables source-built Expo modules, excludes the proprietary camera, Firebase notification, and Expo development-client native modules, disables EAS updates and Gradle dependency metadata, and substitutes JavaScript stubs for camera and notifications. The resulting app supports direct and pasted-link pairing but not QR scanning or push notifications.
+
+Keep the excluded npm packages installed. Normal builds use them, while the F-Droid profile removes only their Android native modules and config plugins. Paseo always applies `expo-gradle-jvmargs` with `-Xmx4096m` and `-XX:MaxMetaspaceSize=1024m` so local Expo prebuilds have enough Gradle heap whether they use precompiled AARs or source-built Expo modules.
+
 ### React version lockstep
 
 Keep `react` and `react-dom` pinned to the React version embedded by the current `react-native` release. React Native `0.81.x` embeds `react-native-renderer` `19.1.0`, so `packages/app` must use React `19.1.0`. Bumping React to a newer patch can build successfully but crash at JS startup on Android with `Incompatible React versions`, leaving the app on the native splash screen.

docs/architecture.md

@@ -138,7 +138,9 @@ Electron wrapper for macOS, Linux, and Windows.
 
 > **Window-state v1 limitation:** only the _first_ window of a session restores and persists saved geometry (size/position/maximized). Windows opened via ⌘⇧N / second-instance / "Open in new window" open at the default size, OS-cascaded, and do not persist — this avoids every window stacking on the same restored bounds and fighting over the single window-state store. Lifting this needs per-window state keys.
 >
-> **In-app browser panes are not yet per-window.** Browser webviews are tracked by one process-global registry that keeps a single current `WebContents` per browser id. Human focus still records the workspace-active browser for UI state and `list_tabs` reporting, but agent automation targets only explicit browser ids returned by `browser_new_tab` or `browser_list_tabs`. The webview registration queue (`pendingBrowserWebviewIds` in `main.ts`) is still process-global. With browser panes open in two windows, a menu Reload can target the other window's webview, and near-simultaneous webview attach across windows can register under the wrong browser id. Multi-window v1 ships windows; making the browser-webview subsystem window-scoped is a follow-up.
+> **In-app browser profile.** Every browser guest uses one stable persistent Electron session, so cookies, authentication, cache, and site storage are shared across tabs, workspaces, and desktop windows and survive tab or app closure. Browser identity is independent of that storage partition: after `did-attach`, the renderer explicitly registers its browser id, workspace id, and guest `WebContents` id, and main accepts the registration only when that guest belongs to the calling renderer and the shared profile. Settings > General > Clear browser data is the sole profile-deletion path; it clears the shared session and reloads live guests without deleting saved tabs or URLs.
+
+> **In-app browser targets are not yet per-window.** Browser webviews are still tracked by one process-global registry that keeps a single current `WebContents` per browser id. Human focus records the workspace-active browser for UI state and `list_tabs` reporting, while agent automation targets explicit browser ids returned by `browser_new_tab` or `browser_list_tabs`. Explicit attached-guest registration prevents concurrent windows from swapping different browser ids, but rendering the same saved browser tab in multiple windows can still make menu actions target the most recently registered guest. Making the registry window-scoped remains a follow-up.
 
 ### `packages/website` — Marketing site
 

docs/browser-capture-harness.md

@@ -27,6 +27,17 @@ Run the browser automation fixture with:
 PASEO_CAPTURE_HARNESS_GROUP=automation npm run capture-harness --workspace=@getpaseo/desktop
 ```
 
+Run the shared browser profile fixture with:
+
+```bash
+PASEO_CAPTURE_HARNESS_GROUP=browser-profile npm run capture-harness --workspace=@getpaseo/desktop
+```
+
+The browser profile group runs two Electron processes in sequence. It verifies that each
+renderer-side `did-attach` identity maps to the correct main-process guest, that two live
+tabs share cookies and local storage through one persistent session, and that the data is
+still present after the first Electron process exits and the second starts.
+
 The automation group uses a real guest webview to verify the page-side ref contract:
 ARIA-like snapshot text includes headings, static text, and controls; refs survive
 `pushState` when the element still matches; same-URL rerenders stale old refs; and a

docs/coding-standards.md

@@ -84,6 +84,10 @@ For testing rules, see [testing.md](testing.md).
 - Components render and dispatch — they don't compute transitions. Two-plus interacting `useState`s → extract a reducer.
 - Never define components inside other components. Module-scope only.
 - Subscribe narrowly: select primitives from stores, pass `status` not `agent`, use `useShallow` / deep-equal when returning derived arrays/objects.
+- Collection rows do not independently subscribe to a high-frequency global store. The collection owner selects structurally shared indexes once, derives a keyed row model with `useMemo`, and passes entries to rows. This keeps retained hidden collections current without running one selector per row on every store update.
+- Equality functions prevent React renders; they do not prevent selector callbacks from running. A selector attached to a hot store must be O(1) when its relevant source references have not changed.
+- Retained native panels use `RetainedPanel`. If an existing gesture/layout wrapper must own visibility, wrap its contents in `RetainedPanelActivity` instead. Keep keyed panel roots in a stable sibling order, include the newly active panel in the same render, centralize subscriptions, and gate genuine effects through `useRetainedPanelActive`. Do not use `Suspense` or render freezing for this on native: those techniques change native tree ownership instead of merely stopping work.
+- Infinite animations are subscriptions. Start them only while their retained panel is active, and cancel a shared clock when its final active consumer leaves. Synchronized animations use one clock per animation family and feed active instances through local shared values; retained hidden instances stay mounted but unsubscribed. Match state updates to the actual visual cadence; do not run every style worklet at 60 fps when the rendered value changes only a few times per second.
 - Stable references for props that cross `memo` boundaries or feed dependency arrays. Static literals at module scope `as const`; derived with `useMemo`; handlers with `useCallback` only when there's a memoized beneficiary.
 - Use stable ids for `key`, never array index for reorderable/filterable lists.
 - Context for stable values (theme, auth). Store with selectors for state that changes.

docs/custom-providers.md

@@ -457,6 +457,37 @@ Paseo tools such as subagent creation come from the shared internal tool catalog
 }
 ```
 
+ACP agents execute filesystem and terminal operations in their own environment
+by default. To let a compliant agent delegate those operations to Paseo instead,
+enable the corresponding client capabilities:
+
+```json
+{
+  "agents": {
+    "providers": {
+      "local-agent": {
+        "extends": "acp",
+        "label": "Local Agent",
+        "command": ["local-agent", "acp"],
+        "params": {
+          "clientCapabilities": {
+            "fs": {
+              "readTextFile": true,
+              "writeTextFile": true
+            },
+            "terminal": true
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Only enable capabilities Paseo should execute. When the agent and Paseo run in
+different environments, configure equivalent absolute workspace paths before
+delegating filesystem or terminal operations to Paseo.
+
 ### Generic ACP diagnostics
 
 Paseo diagnostics for `extends: "acp"` providers report the configured command, resolved launcher binary, version output, ACP `initialize`, ACP `session/new`, model count, modes, and final status.

docs/data-model.md

@@ -420,15 +420,16 @@ Single file containing an array of all loop records. Writes are direct (not atom
 
 Array of project records.
 
-| Field         | Type                        | Description                              |
-| ------------- | --------------------------- | ---------------------------------------- |
-| `projectId`   | `string`                    | Primary key                              |
-| `rootPath`    | `string`                    | Filesystem root of the project           |
-| `kind`        | `"git" \| "non_git"`        |                                          |
-| `displayName` | `string`                    |                                          |
-| `createdAt`   | `string` (ISO 8601)         |                                          |
-| `updatedAt`   | `string` (ISO 8601)         |                                          |
-| `archivedAt`  | `string \| null` (ISO 8601) | Soft-delete timestamp; required nullable |
+| Field         | Type                        | Description                                                                      |
+| ------------- | --------------------------- | -------------------------------------------------------------------------------- |
+| `projectId`   | `string`                    | Primary key                                                                      |
+| `rootPath`    | `string`                    | Filesystem root of the project                                                   |
+| `kind`        | `"git" \| "non_git"`        |                                                                                  |
+| `displayName` | `string`                    |                                                                                  |
+| `customName`  | `string \| null`            | User-set override layered over `displayName`. Null means "use the derived name". |
+| `createdAt`   | `string` (ISO 8601)         |                                                                                  |
+| `updatedAt`   | `string` (ISO 8601)         |                                                                                  |
+| `archivedAt`  | `string \| null` (ISO 8601) | Soft-delete timestamp; required nullable                                         |
 
 Active git projects are unique by normalized `rootPath`. Startup reconciliation repairs older bad
 states by moving workspaces from duplicate path-keyed projects onto the canonical project,
@@ -455,6 +456,7 @@ Array of workspace records. A workspace is a specific working directory within a
 | `createdAt`   | `string` (ISO 8601)                             |                                                                                                                                                                                       |
 | `updatedAt`   | `string` (ISO 8601)                             |                                                                                                                                                                                       |
 | `archivedAt`  | `string \| null` (ISO 8601)                     | Soft-delete; required nullable                                                                                                                                                        |
+| `pinnedAt`    | `string \| null` (ISO 8601)                     | Pinned-to-top-of-sidebar timestamp; null means "not pinned"                                                                                                                           |
 
 > **Opaque-ID invariant:** `workspaceId` is opaque identity, never a filesystem path. Filesystem and git operations take `cwd`/`workspaceDirectory` only — never the id. Path-derived grouping keys (e.g. `deriveWorkspaceDirectoryKey`, used at bootstrap to group agents into a workspace) are directory keys, not workspace identity, and must not be persisted or compared as ids.
 

docs/design.md

@@ -131,6 +131,10 @@ The branching is one `useIsCompactFormFactor()` check at the top of the screen c
 
 The workspace screen (`packages/app/src/screens/workspace/workspace-screen.tsx`) follows a different but parallel rule: tabs collapse on compact, panes split on desktop. The sidebar (`packages/app/src/components/left-sidebar.tsx`) is overlaid on compact and pinned on desktop.
 
+On a narrow desktop route, app navigation yields to the rendered content topology when the remaining width cannot preserve its center target: Settings keeps its 320px list + 400px detail split, and a workspace Explorer keeps its current visible width plus a 400px center pane. That is a topology decision at the app container, not a second compact breakpoint. Temporary width clamps are render-only; widening restores the user's saved sidebar widths.
+
+Electron window controls are top-corner obstructions, not a compact-layout condition. Rendered surfaces declare which top corners they physically occupy; only those corners receive clearance. Full-window overlays redeclare both corners. A focused split pane owns both corners; if focus restoration temporarily exposes the full split tree, the split boundary reserves one top strip instead of assigning a control rectangle to an arbitrarily narrow leaf. The 720px desktop breakpoint preserves the default 320px sidebar and target 400px center width when the Explorer is closed; it is product policy, not an obstruction gate.
+
 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.
 
 ---
@@ -218,7 +222,7 @@ The bespoke pills in `packages/app/src/screens/settings/host-page.tsx:97-116`, `
 - Raw DOM APIs without an `isWeb` guard.
 - Spacing values outside the scale. `padding: 20` and `gap: 10` are wrong.
 - Color changes for disabled state. Opacity only.
-- Destructive actions without `confirmDialog`. Restart, remove, and future destructive actions are confirmed. Worktree archive is confirmed only when git runtime reports uncommitted changes or unpushed commits; clean pushed worktrees archive immediately.
+- Destructive actions without `confirmDialog`. Restart, remove, and future destructive actions are confirmed. Archive workspace is confirmed only when its worktree backing reports uncommitted changes or unpushed commits; otherwise it archives immediately.
 - Bespoke status pills. `<StatusBadge>` is the pill primitive.
 - Raw `Modal` for a focused task. `<AdaptiveModalSheet>` is the modal primitive.
 - Importing `ActivityIndicator` directly. `<LoadingSpinner>` is the loading primitive.

docs/development.md

@@ -59,11 +59,42 @@ startup routing, remembered workspace restore, or active workspace selection.
 
 Paseo worktrees expose the native iOS dev app through the `ios-simulator` service in `paseo.json`. The service URL serves the simulator preview at `/.sim`, so the preview link is `${PASEO_URL}/.sim`.
 
+**Prerequisites (macOS only).** The service shells out to the Apple toolchain, so beyond the `npm ci` that worktree setup runs you must install:
+
+- **Xcode** (the full app, not just the Command Line Tools) — install it from the Mac App Store, or from `developer.apple.com/download` for a specific version. It provides `xcodebuild` and `xcrun simctl`; accept its license and let first-run component installation finish before starting the service.
+- **An iOS Simulator runtime with at least one iPhone device type**. Recent Xcode versions may not bundle a runtime — add one via Xcode → Settings → Components (older Xcode: "Platforms"). The service targets `iPhone 16 Pro` by default (override with `PASEO_IOS_DEVICE_TYPE`) and falls back to any iPhone; it fails with `No iPhone simulator device type is installed` when none exist.
+- **Homebrew** — CocoaPods itself installs automatically: `expo prebuild` runs `pod install` on a cold worktree, and when the CocoaPods CLI is missing the runner installs it for you. It tries `gem install cocoapods` first and falls back to Homebrew (`brew install cocoapods`), so having Homebrew available lets that fallback succeed without a manual step.
+
+`serve-sim`, Expo, and Metro come from `npm ci`, and CocoaPods installs itself on the first prebuild as described above.
+
 The service is designed for concurrent worktrees: it derives a deterministic simulator identity from the worktree path, uses the worktree's assigned `PASEO_PORT`, pins `serve-sim` to that simulator UDID, and only tears down that worktree's helper/simulator state. It must not rely on the globally booted simulator or any fixed Metro port.
 
 Worktree setup best-effort seeds the generated iOS project and newest native build cache from the source checkout before the service runs. The service still validates the native project by running Expo prebuild and Xcode; the seed only avoids paying all setup/build cost from a cold worktree every time.
 
-Starting the service must not create, focus, reveal, or leave behind macOS Simulator.app windows. The browser preview is the user-visible simulator surface.
+Starting the service must not create, focus, reveal, or leave behind macOS Simulator.app windows — a guard hides Simulator.app every 250ms, so the native window vanishes if you focus it. The user-visible surface is the interactive `/.sim` preview: a `serve-sim` stream (60 FPS MJPEG + a WebSocket control channel) that Metro mounts at `basePath: "/.sim"` (`packages/app/metro.config.cjs`) and that forwards taps and gestures, so first-launch prompts like "Open in PaseoDebug?" are answered there, not in the native window. Open the `${PASEO_URL}/.sim` link the service prints — not `serve-sim`'s raw stream port (`:3100`), which is view-only. Because the stream sits behind the daemon proxy it is convenient for remote viewing but laggy up close; for fast local dev at the Mac, use the native simulator path below.
+
+**Troubleshooting.** If `xcrun simctl` fails with `unable to find utility "simctl"`, the active developer directory is still the Command Line Tools even though Xcode is installed. Point it at Xcode: `sudo xcode-select -s /Applications/Xcode.app/Contents/Developer`, then confirm with `xcrun --find simctl`.
+
+### Running the iOS app on a local simulator
+
+For fast, native, interactive iOS dev at the Mac — as opposed to the remote `/.sim` preview above — skip the service and build the dev client directly:
+
+```bash
+npm run ios        # → expo run:ios (packages/app): builds and launches the app in the real Simulator.app
+```
+
+`expo run:ios` starts its own Metro and gives you the normal Simulator.app window (full speed, native touch, no stream).
+
+**Pointing the app at a daemon.** The client resolves its local daemon from `EXPO_PUBLIC_LOCAL_DAEMON` (`packages/app/src/runtime/host-runtime.ts`); when unset it falls back to `localhost:6767`, the production `~/.paseo` daemon. To target a worktree's dev daemon instead, set it on the build command:
+
+```bash
+EXPO_PUBLIC_LOCAL_DAEMON=localhost:${PASEO_SERVICE_DAEMON_PORT} npm run ios   # worktree daemon running as a Paseo service
+EXPO_PUBLIC_LOCAL_DAEMON=localhost:6768 npm run ios                          # standalone `npm run dev:server`
+```
+
+The iOS simulator shares the Mac's loopback, so `localhost:<port>` reaches the host daemon directly.
+
+**Gotcha — `EXPO_PUBLIC_*` is inlined into the JS bundle at Metro bundle time, not read at runtime.** Set it in the same shell that starts Metro. If the app still connects to the old daemon, Metro served a cached bundle; re-bundle clean with `cd packages/app && EXPO_PUBLIC_LOCAL_DAEMON=… npx expo start -c` and reload the app.
 
 ### Desktop renderer profiling
 
@@ -72,6 +103,17 @@ Starting the service must not create, focus, reveal, or leave behind macOS Simul
 It launches its own Electron-flavored Expo server and passes that URL to Electron.
 Override the CDP port with `PASEO_ELECTRON_REMOTE_DEBUGGING_PORT` when `9223` is busy.
 
+With desktop dev running, verify the real BrowserWindow, titlebar clearance, fullscreen
+transition, and 751-pixel settings split with:
+
+```bash
+npm run verify:electron-cdp --workspace=@getpaseo/desktop
+```
+
+The verifier reads the same `EXPO_PORT` and
+`PASEO_ELECTRON_REMOTE_DEBUGGING_PORT` environment names as desktop dev. Set both when
+testing an isolated instance on non-default ports.
+
 When running a dedicated Electron QA instance against a non-default Expo port, set
 `EXPO_DEV_URL` explicitly. Desktop main defaults to `http://localhost:8081`, so
 `PASEO_PORT=57928` alone starts Metro on 57928 but Electron still loads 8081.
@@ -338,6 +380,7 @@ npm run cli -- ls -a -g --json       # Same, as JSON
 npm run cli -- inspect <id>          # Show detailed agent info
 npm run cli -- logs <id>             # View agent timeline
 npm run cli -- daemon status         # Check daemon status
+npm run cli -- clone owner/repo --dir ~/workspace # Clone GitHub repo and register project
 ```
 
 Use `--host <host:port>` to point the CLI at a different daemon:

docs/expo-router.md

@@ -48,8 +48,13 @@ dynamic params exist before any nested workspace leaf is selected.
 ## App-Wide Route Hops
 
 When app-wide routes such as `/new`, `/settings`, or `/sessions` navigate back
-into a host workspace, express only the destination with `navigateToWorkspace()`.
-Do not make the caller branch on its current route.
+into a host workspace, use `navigateToWorkspace()`. Do not make the caller
+branch on its current route.
+
+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.
 
 The root stack owns `h/[serverId]`; the host stack owns
 `workspace/[workspaceId]/index`. Repeated global-route hops must `POP_TO` the
@@ -96,6 +101,18 @@ Keep workspace identity and retention outside native-stack `getId` and
 Navigation `getId`, and `getId` has broken Android native-stack/Fabric by
 reordering an already-mounted workspace screen.
 
+Use `ThemedStack` from `packages/app/src/navigation/themed-stack.tsx` for every
+Expo Router stack. React Navigation otherwise paints each native stack screen
+with its light default background. A screen-level wrapper can hide that surface
+while settled, but Android may expose it for one frame when navigation crosses
+from a nested stack to its parent stack. This is especially visible when an
+app-wide route such as `/new` opens from a dark workspace.
+
+Do not read the active theme with `useUnistyles()` in a layout to build
+`screenOptions`. `ThemedStack` keeps that third-party prop theme-reactive through
+a small `withUnistyles` boundary without subscribing the route tree itself to
+every Unistyles runtime update.
+
 ## Regression Shape
 
 Pure helper tests are useful but not enough. The failure mode here is native
@@ -121,7 +138,8 @@ Before landing route changes:
 
 - [ ] Did you change `packages/app/src/app`? Re-read this file.
 - [ ] Did you touch remembered workspace restore? Keep root on `/h/[serverId]`.
-- [ ] Did any route return to a workspace? Use `navigateToWorkspace()`.
+- [ ] Did a route return to a workspace? Use `navigateToWorkspace()` and pass a
+      `target` when the action names a specific tab.
 - [ ] Did you add a route? Register it in the layout that directly owns it.
 - [ ] Did `useLocalSearchParams()` lose a required param? Fix the route tree.
 - [ ] Did native show a blank screen without a crash? Suspect route ownership

docs/glossary.md

@@ -4,6 +4,7 @@ Authoritative terminology. UI label wins. Don't invent synonyms; use what's here
 
 - **Project** — Logical grouping of workspaces sharing a git remote (or main repo root). UI: "Project" / "Add project". Code: `ProjectSummary` (`packages/app/src/utils/projects.ts:22`), `projectKey` (`packages/server/src/server/workspace-registry-model.ts:16`). Forbidden: "Repo", "Repository" as UI label.
 - **Workspace** — One concrete `cwd` on one daemon, with git state; belongs to exactly one project. Its `id` is opaque workspace identity; its `cwd` is the filesystem directory. UI: "Workspace". Code: `WorkspaceDescriptorPayload` (`packages/protocol/src/messages.ts:2178`). Don't confuse with: Branch (one branch can back many workspaces via worktrees). Forbidden: "Folder", "Directory" as UI label.
+- **Archive workspace** — Removes one workspace from active use and archives everything it owns. UI and app shortcuts always say "Archive workspace", regardless of backing. The daemon leaves ordinary directories intact and removes a Paseo-owned worktree only when no active workspace still references it. CLI/MCP **archive worktree** is a separate lower-level operation that archives every workspace on that worktree.
 - **Workspace kind** — `"directory" | "local_checkout" | "worktree"`. The git-derived, persisted property of a workspace, used across its lifetime (archive safety, sidebar, grouping). Derived from the cwd's git reality (`deriveWorkspaceKind`, `packages/server/src/server/workspace-registry-model.ts:158`), not stored from a user choice. Code: `PersistedWorkspaceKind` (`packages/server/src/server/workspace-registry-model.ts:8`). Don't confuse with **Isolation** (the create-time intent).
 - **Isolation** — Create-time choice for a new workspace: reuse the existing checkout (**Local**) or cut a dedicated git worktree (**New worktree**). A transient setup input, also remembered as a create-form preference; it is not a workspace property. UI: "Isolation" control on the New Workspace screen. Code: `isolation` (`"local" | "worktree"`), `useWorkspaceIsolation` (`packages/app/src/screens/new-workspace-screen.tsx`); persisted as `FormPreferences.isolation` (`packages/app/src/create-agent-preferences/preferences.ts`). Distinct from **Workspace kind**, which is the git-derived property the intent produces (Local → `local_checkout` or `directory` by git-ness; New worktree → `worktree`). On the wire it is the create request's `source.kind` (`directory | worktree`, `packages/protocol/src/messages.ts:1693`).
 - **Agent** — See **Agent session**. UI still says "Agent" / "New Agent" in places, but moving toward **Agent session** as the canonical term. Code: `AgentSnapshotPayload` (`packages/protocol/src/messages.ts:608`). Forbidden: "Task", "Job", "Run".

docs/mobile-panels.md

@@ -75,11 +75,30 @@ definition, no longer eligible to begin.
   so its injected `collapsable={false}` reaches Android/Fabric.
 - 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.
 - The plain React wrapper owns `display: none` after settlement. This prevents a stale Fabric animated
   prop commit from resurrecting a closed overlay.
+- Hidden tabs and workspaces use `RetainedPanel`. It owns a non-collapsible native root, visibility,
+  pointer events, and the active signal consumed by `useRetainedPanelActive`.
+- Panels whose gesture wrapper already owns visibility use `RetainedPanelActivity` to provide the
+  same active signal without adding another layout root. Persistent animations, timers, polling, and
+  shared clocks must subscribe to that signal and stop when their final visible consumer leaves.
+- Synchronized step animations use one wall-clock-aligned source. Register a local shared value only
+  while its retained panel is active so hidden animated styles remain mounted without receiving clock
+  updates. Do not give every instance its own loop or leave hidden styles subscribed to the source.
+- Retention order and render order are separate concerns. LRU metadata may change on every switch;
+  keyed retained roots must keep a stable sibling order. Moving large retained roots triggered Fabric
+  Differ failures (`addViewAt` / `removeViewAt` view reuse) on Android.
+- The newly active panel must be included in the same render that changes selection. Adding it from an
+  effect creates a committed frame where every retained panel is hidden, which is a real blank screen.
+- Do not suspend retained native subtrees with `Suspense`/`react-freeze`. Suspension changes native
+  ownership and can detach descendants. Keep the tree mounted, stabilize its subscriptions/selectors,
+  and use the retained-panel active signal to stop timers, polling, and other genuine background work.
 
 ## Tests
 

docs/providers.md

@@ -28,7 +28,7 @@ Paseo's per-agent and daemon-wide system prompts are passed to Pi with `--append
 
 Pi model records expose input capabilities through `model.input`. Only send raw RPC `images` when the current model explicitly includes `"image"` in that list. Text-only Pi/OMP models reject image content and persist the rejected image in JSONL history, so image prompts for those models must be materialized to a local file and passed as a text path hint instead.
 
-Pi MCP support depends on the open-source `pi-mcp-adapter` extension being loaded for the agent cwd. Probe with Pi RPC `get_commands`; the adapter registers an extension command named `mcp` (often with `sourceInfo.source` containing `pi-mcp-adapter`). When Paseo injects MCP servers into Pi, write a per-agent MCP config and pass it with `--mcp-config` instead of modifying user or project MCP files. For local HTTP servers such as Paseo's own `/mcp/agents` endpoint, explicitly disable adapter OAuth (`auth: false`, `oauth: false`) in the generated config.
+Pi MCP support depends on the open-source `pi-mcp-adapter` extension being loaded for the agent cwd. Probe with Pi RPC `get_commands`; the adapter registers an extension command named `mcp` (often with `sourceInfo.source` containing `pi-mcp-adapter`). When Paseo injects MCP servers into Pi, write a per-agent MCP config and pass it with `--mcp-config` instead of modifying user or project MCP files. Because that flag replaces the Pi global config layer, preserve the existing `<Pi agent dir>/mcp.json` in the generated file before overlaying injected servers. For local HTTP servers such as Paseo's own `/mcp/agents` endpoint, explicitly disable adapter OAuth (`auth: false`, `oauth: false`) in the generated config.
 
 Pi import discovery reads Pi's persisted JSONL session files because Pi RPC does not expose a recent-session listing command. Resume and full history hydration still go through `pi --mode rpc` using the session file as `nativeHandle`.
 

docs/release.md

@@ -52,6 +52,8 @@ This bumps the version across all workspaces, runs checks, publishes to npm, and
 
 The Docker workflow builds images from the checked-out source tree on pull requests and on `main` as non-publishing checks. Stable `vX.Y.Z` tag pushes publish `ghcr.io/getpaseo/paseo:X.Y.Z` and `ghcr.io/getpaseo/paseo:latest`; beta `vX.Y.Z-beta.N` tag pushes publish only `ghcr.io/getpaseo/paseo:X.Y.Z-beta.N` and never move `latest`.
 
+Relay deployment is manual-only while `relay.paseo.sh` bridges traffic to the Fly deployment. Releases and pushes to `main` do not deploy the Cloudflare relay worker. Deploy it explicitly with `gh workflow run deploy-relay.yml` only when the production bridge should change.
+
 **Releases are always patch.** "Release paseo", "release stable", "ship stable", and similar always mean a patch bump from the previous stable. Never bump minor or major to trigger a build, ever — minor and major bumps are reserved for genuinely larger product cuts and require an explicit user instruction with the word "minor" or "major". If you find yourself reaching for `release:minor` to retrigger a failed build, you are doing the wrong thing — push a retry tag instead (see "Fixing a failed release build" below).
 
 **Stable means stable.** If the user says "stable" or "ship stable", do not ask whether they want a beta first. They picked stable; treat it as a direct stable release. Only run the beta flow when the user explicitly says "beta".
@@ -186,6 +188,8 @@ iOS and Android store builds are not in `.github/workflows`. They are triggered
 - **iOS (TestFlight + App Store)** — EAS builds with profile `production`, uploads to TestFlight, and a Fastlane lane submits the build for App Store review.
 - **Android APK (GitHub Release asset)** — separate, via `.github/workflows/android-apk-release.yml`. This is the only Android-related workflow that lives in this repo.
 
+EAS uses the local app version source. `packages/app/app.config.js` derives Android `versionCode` and iOS `buildNumber` from the package version as `major * 1_000_000 + minor * 1_000 + patch`, ignoring prerelease metadata. Rebuilding the same tag produces the same native build number; if a store has already accepted a binary and you need a different binary, cut a new patch instead of relying on EAS remote auto-increment.
+
 There is no `release-mobile.yml` in this repo. Earlier versions of these docs referenced one — that workflow was removed and the EAS GitHub app handles tag triggering directly.
 
 ### Watching mobile builds from the terminal

docs/timeline-sync.md

@@ -9,6 +9,11 @@ The invariant is:
 
 > If the daemon has committed timeline rows for an agent, any connected client that opens or resumes that agent eventually displays every row through the daemon's current tail.
 
+Tool output is bounded before it enters either delivery path. Canonical shell tool output is sliced
+to 64 KiB, and the same bounded item is used for durable timeline rows and live stream events.
+Provider history hydration applies the same rule so reopening an agent cannot restore an oversized
+tool payload.
+
 ## Presence is not delivery
 
 Client heartbeat reports presence:
@@ -32,6 +37,14 @@ Initialization timeouts guard lack of catch-up progress, not the full multi-page
 
 The first load of an agent without a local cursor is different: it fetches a bounded latest tail page. Older history remains user-driven by scrolling upward.
 
+## Durable item anchors
+
+Provider message IDs are not guaranteed for every displayed item. Paseo-generated system errors are one example. Rendered item indices are not durable either because pagination and projection can merge source rows.
+
+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 that the epoch is current and the exact source sequence still exists before slicing rows. It slices before projection so later lifecycle updates cannot leak into the selected context.
+
 ## Resume behavior
 
 When a client resumes with a known cursor, it catches up after that cursor to completion. It does not replace the view with a latest tail page, because tail pagination can skip the middle of a long background run.

docs/unistyles.md

@@ -90,6 +90,19 @@ When a reusable component has a prop whose whole job is dynamic geometry, make t
 
 Do not flatten a caller-provided style array and pass the flattened object back to a React Native component. Unistyles style entries carry `unistyles_*` metadata; flattening two entries produces one object with multiple metadata keys and triggers the runtime warning: "use array syntax instead of object syntax." Preserve caller styles as arrays, and only flatten the dynamic geometry value you explicitly own. If that owned value was flattened from a mixed style prop, strip `unistyles_*` metadata before sending it through `inlineUnistylesStyle`.
 
+Do not register an existing Unistyles style inside another `StyleSheet.create` either. That also combines two metadata identities into one object. Reuse the original style directly at the component:
+
+```tsx
+// Wrong: sharedStyles.row already carries Unistyles metadata.
+const styles = StyleSheet.create({ row: sharedStyles.row });
+<View style={styles.row} />;
+
+// Right: one registered style identity reaches the native view.
+<View style={sharedStyles.row} />;
+```
+
+This mistake once produced tens of thousands of warnings from retained sidebar rows. Because React Native captures component stacks for warnings, the warning loop itself can consume enough CPU and memory to make the app appear blank.
+
 ## Main Gotcha: `contentContainerStyle`
 
 `ScrollView.contentContainerStyle` is the canonical trap. It looks like a style prop, but it is not the same prop that Unistyles' remapped native component registers by default. The upstream tutorial calls this out directly in its [ScrollView Background Issue](https://www.unistyl.es/v3/tutorial/settings-screen#scrollview-background-issue) section.

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-cU6qRXY9fnr80pllmqJts5w8+OiE6F99SRo2d9G0HDA=
+sha256-TiKnZMEypZYb6GGj189XUeb77j6voamTs6IPJye0UyE=

nix/package.nix

@@ -30,9 +30,7 @@ buildNpmPackage rec {
         relPath = lib.removePrefix (toString ./..) path;
       in
       # Exclude non-daemon workspace contents (keep package.json for workspace resolution)
-      !(lib.hasPrefix "/packages/app/src" relPath)
-      && !(lib.hasPrefix "/packages/app/assets" relPath)
-      && !(lib.hasPrefix "/packages/app/android" relPath)
+      !(lib.hasPrefix "/packages/app/android" relPath)
       && !(lib.hasPrefix "/packages/app/ios" relPath)
       && !(lib.hasPrefix "/packages/website/src" relPath)
       && !(lib.hasPrefix "/packages/website/public" relPath)
@@ -81,6 +79,7 @@ buildNpmPackage rec {
 
     # Build all server packages in dependency order (defined in package.json)
     npm run build:server
+    npm run build:daemon-web-ui
 
     runHook postBuild
   '';
@@ -107,6 +106,9 @@ buildNpmPackage rec {
     # CLI/server bin starts from $out.
     cp package.json $out/lib/paseo/
 
+    # Web UI Assets
+    cp -r packages/server/dist/server/web-ui $out/lib/paseo/packages/server/dist/server/
+
     # Create wrapper for the server entry point (for systemd / direct use)
     mkdir -p $out/bin
     makeWrapper ${nodejs}/bin/node $out/bin/paseo-server \

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "paseo",
-  "version": "0.1.105",
+  "version": "0.1.110",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "paseo",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "hasInstallScript": true,
       "license": "AGPL-3.0-or-later",
       "workspaces": [
@@ -19591,6 +19591,16 @@
         "react-native": "*"
       }
     },
+    "node_modules/expo-gradle-jvmargs": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/expo-gradle-jvmargs/-/expo-gradle-jvmargs-1.1.2.tgz",
+      "integrity": "sha512-VJRecrYlklVXEwafLyuZKUCnYEY9vJYvUy639LN3c5krlmunkYQphh/YzXDng8C9oihz6mr+cPbwEn6sv6fXyw==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@expo/config-plugins": "*"
+      }
+    },
     "node_modules/expo-haptics": {
       "version": "15.0.8",
       "resolved": "https://registry.npmjs.org/expo-haptics/-/expo-haptics-15.0.8.tgz",
@@ -35152,7 +35162,7 @@
     },
     "packages/app": {
       "name": "@getpaseo/app",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",
         "@dnd-kit/sortable": "^10.0.0",
@@ -35250,6 +35260,7 @@
         "eas-cli": "^16.24.1",
         "eslint": "^9.25.0",
         "eslint-config-expo": "~10.0.0",
+        "expo-gradle-jvmargs": "^1.1.2",
         "jsdom": "^20.0.3",
         "material-icon-theme": "^5.32.0",
         "playwright": "^1.56.1",
@@ -36170,12 +36181,12 @@
     },
     "packages/cli": {
       "name": "@getpaseo/cli",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "@clack/prompts": "^1.0.0",
-        "@getpaseo/client": "0.1.105",
-        "@getpaseo/protocol": "0.1.105",
-        "@getpaseo/server": "0.1.105",
+        "@getpaseo/client": "0.1.110",
+        "@getpaseo/protocol": "0.1.110",
+        "@getpaseo/server": "0.1.110",
         "chalk": "^5.3.0",
         "commander": "^12.0.0",
         "mime-types": "^2.1.35",
@@ -36421,10 +36432,10 @@
     },
     "packages/client": {
       "name": "@getpaseo/client",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
-        "@getpaseo/protocol": "0.1.105",
-        "@getpaseo/relay": "0.1.105",
+        "@getpaseo/protocol": "0.1.110",
+        "@getpaseo/relay": "0.1.110",
         "zod": "^4.4.3"
       },
       "devDependencies": {
@@ -36435,7 +36446,7 @@
     },
     "packages/desktop": {
       "name": "@getpaseo/desktop",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "@getpaseo/cli": "*",
@@ -36678,7 +36689,7 @@
     },
     "packages/expo-two-way-audio": {
       "name": "@getpaseo/expo-two-way-audio",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "license": "MIT",
       "devDependencies": {
         "@types/jest": "^29.5.14",
@@ -37574,7 +37585,7 @@
     },
     "packages/highlight": {
       "name": "@getpaseo/highlight",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "@codemirror/language": "^6.12.3",
         "@codemirror/legacy-modes": "^6.5.3",
@@ -37806,7 +37817,7 @@
     },
     "packages/protocol": {
       "name": "@getpaseo/protocol",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "zod": "^4.4.3"
       },
@@ -37819,7 +37830,7 @@
     },
     "packages/relay": {
       "name": "@getpaseo/relay",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "base64-js": "^1.5.1",
         "tweetnacl": "^1.0.3",
@@ -38037,15 +38048,15 @@
     },
     "packages/server": {
       "name": "@getpaseo/server",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "@agentclientprotocol/sdk": "^0.17.1",
         "@anthropic-ai/claude-agent-sdk": "^0.3.195",
         "@anthropic-ai/sdk": "^0.104.2",
-        "@getpaseo/client": "0.1.105",
-        "@getpaseo/highlight": "0.1.105",
-        "@getpaseo/protocol": "0.1.105",
-        "@getpaseo/relay": "0.1.105",
+        "@getpaseo/client": "0.1.110",
+        "@getpaseo/highlight": "0.1.110",
+        "@getpaseo/protocol": "0.1.110",
+        "@getpaseo/relay": "0.1.110",
         "@isaacs/ttlcache": "^2.1.4",
         "@modelcontextprotocol/sdk": "^1.20.1",
         "@opencode-ai/sdk": "1.14.46",
@@ -38582,7 +38593,7 @@
     },
     "packages/website": {
       "name": "@getpaseo/website",
-      "version": "0.1.105",
+      "version": "0.1.110",
       "dependencies": {
         "@cloudflare/vite-plugin": "^1.29.1",
         "@cloudflare/workers-types": "^4.20260317.1",
@@ -38609,7 +38620,8 @@
         "@vitejs/plugin-react": "^4.5.1",
         "typescript": "^5.9.3",
         "vite": "^7.3.3",
-        "vite-tsconfig-paths": "^5.1.4"
+        "vite-tsconfig-paths": "^5.1.4",
+        "vitest": "^4.1.6"
       }
     },
     "packages/website/node_modules/@babel/code-frame": {
@@ -39544,6 +39556,201 @@
         "undici-types": "~6.21.0"
       }
     },
+    "packages/website/node_modules/@vitest/browser": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/browser/-/browser-4.1.10.tgz",
+      "integrity": "sha512-UDwuWGwXj646CBx/bQHOaJSX7np0I8JL/UKQYa1e4QrVHH8VdWtx8eaOuf8sy0ShwDgR6NjJAsp5eF6vjF6qng==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "dependencies": {
+        "@blazediff/core": "1.9.1",
+        "@vitest/mocker": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "magic-string": "^0.30.21",
+        "pngjs": "^7.0.0",
+        "sirv": "^3.0.2",
+        "tinyrainbow": "^3.1.0",
+        "ws": "^8.19.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "vitest": "4.1.10"
+      }
+    },
+    "packages/website/node_modules/@vitest/browser-playwright": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/browser-playwright/-/browser-playwright-4.1.10.tgz",
+      "integrity": "sha512-nMoXGEiRpT7m3W7NsbvrM2aKNwiNHZf+zEpUCvMteGjZFvfT96Q9fh7QyB98dvDWXiKvrLxA7bJ1mCOOv+JQPw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "dependencies": {
+        "@vitest/browser": "4.1.10",
+        "@vitest/mocker": "4.1.10",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "playwright": "*",
+        "vitest": "4.1.10"
+      },
+      "peerDependenciesMeta": {
+        "playwright": {
+          "optional": false
+        }
+      }
+    },
+    "packages/website/node_modules/@vitest/browser-playwright/node_modules/@vitest/mocker": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+      "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "dependencies": {
+        "@vitest/spy": "4.1.10",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "packages/website/node_modules/@vitest/browser/node_modules/@vitest/mocker": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+      "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "dependencies": {
+        "@vitest/spy": "4.1.10",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "packages/website/node_modules/@vitest/expect": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz",
+      "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "packages/website/node_modules/@vitest/pretty-format": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",
+      "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "packages/website/node_modules/@vitest/runner": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz",
+      "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.1.10",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "packages/website/node_modules/@vitest/snapshot": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz",
+      "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "packages/website/node_modules/@vitest/spy": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz",
+      "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "packages/website/node_modules/@vitest/utils": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",
+      "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.10",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
     "packages/website/node_modules/chokidar": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-5.0.0.tgz",
@@ -39904,6 +40111,123 @@
         "node": ">=20.18.1"
       }
     },
+    "packages/website/node_modules/vitest": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz",
+      "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.10",
+        "@vitest/mocker": "4.1.10",
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/runner": "4.1.10",
+        "@vitest/snapshot": "4.1.10",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.10",
+        "@vitest/browser-preview": "4.1.10",
+        "@vitest/browser-webdriverio": "4.1.10",
+        "@vitest/coverage-istanbul": "4.1.10",
+        "@vitest/coverage-v8": "4.1.10",
+        "@vitest/ui": "4.1.10",
+        "happy-dom": "*",
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
+        }
+      }
+    },
+    "packages/website/node_modules/vitest/node_modules/@vitest/mocker": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+      "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.1.10",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
     "packages/website/node_modules/workerd": {
       "version": "1.20260625.1",
       "resolved": "https://registry.npmjs.org/workerd/-/workerd-1.20260625.1.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo",
-  "version": "0.1.105",
+  "version": "0.1.110",
   "private": true,
   "description": "Paseo: voice-controlled development environment for local AI coding agents",
   "keywords": [

packages/app/app.config.js

@@ -1,7 +1,75 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const pkg = require("./package.json");
+const withFdroidAutolinking = require("./plugins/with-fdroid-autolinking");
 const appVariant = process.env.APP_VARIANT ?? "production";
+const isFdroidBuild = process.env.PASEO_FDROID_BUILD === "1";
+
+const buildProfile = isFdroidBuild
+  ? {
+      androidPermissions: [
+        "RECORD_AUDIO",
+        "android.permission.RECORD_AUDIO",
+        "android.permission.MODIFY_AUDIO_SETTINGS",
+      ],
+      cameraPlugins: [],
+      fdroidPlugins: [withFdroidAutolinking],
+      notificationPlugins: [],
+      updates: { enabled: false },
+    }
+  : {
+      androidPermissions: [
+        "RECORD_AUDIO",
+        "android.permission.RECORD_AUDIO",
+        "android.permission.MODIFY_AUDIO_SETTINGS",
+        "CAMERA",
+        "android.permission.CAMERA",
+      ],
+      cameraPlugins: [
+        [
+          "expo-camera",
+          {
+            cameraPermission:
+              "Allow $(PRODUCT_NAME) to access your camera to scan pairing QR codes.",
+          },
+        ],
+      ],
+      fdroidPlugins: [],
+      notificationPlugins: [
+        [
+          "expo-notifications",
+          {
+            icon: "./assets/images/notification-icon.png",
+            color: "#20744A",
+          },
+        ],
+      ],
+      updates: {},
+    };
+
+function getNativeBuildVersionCode(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version);
+  if (!match) {
+    throw new Error(`Cannot derive Android versionCode from non-semver version: ${version}`);
+  }
+
+  const [, majorText, minorText, patchText] = match;
+  const major = Number(majorText);
+  const minor = Number(minorText);
+  const patch = Number(patchText);
+
+  if (minor > 999 || patch > 999) {
+    throw new Error(`Cannot derive collision-free Android versionCode from version: ${version}`);
+  }
+
+  const versionCode = major * 1_000_000 + minor * 1_000 + patch;
+
+  if (!Number.isSafeInteger(versionCode) || versionCode <= 0 || versionCode > 2_100_000_000) {
+    throw new Error(`Derived Android versionCode is out of range: ${versionCode}`);
+  }
+
+  return versionCode;
+}
 
 function resolveSecretFile(params) {
   const fromEnv = process.env[params.envKey];
@@ -45,6 +113,7 @@ const variants = {
 };
 
 const variant = variants[appVariant] ?? variants.production;
+const nativeBuildVersionCode = getNativeBuildVersionCode(pkg.version);
 
 export default {
   expo: {
@@ -61,6 +130,7 @@ export default {
     },
     updates: {
       url: "https://u.expo.dev/0e7f65ce-0367-46c8-a238-2b65963d235a",
+      ...buildProfile.updates,
     },
     ios: {
       supportsTablet: true,
@@ -72,6 +142,7 @@ export default {
       ...(variant.googleServiceInfoPlist
         ? { googleServicesFile: variant.googleServiceInfoPlist }
         : {}),
+      buildNumber: String(nativeBuildVersionCode),
     },
     android: {
       adaptiveIcon: {
@@ -83,14 +154,9 @@ export default {
       softwareKeyboardLayoutMode: "resize",
       // Allow HTTP connections for local network hosts (required for release builds)
       usesCleartextTraffic: true,
-      permissions: [
-        "RECORD_AUDIO",
-        "android.permission.RECORD_AUDIO",
-        "android.permission.MODIFY_AUDIO_SETTINGS",
-        "CAMERA",
-        "android.permission.CAMERA",
-      ],
+      permissions: buildProfile.androidPermissions,
       package: variant.packageId,
+      versionCode: nativeBuildVersionCode,
       ...(variant.googleServicesFile ? { googleServicesFile: variant.googleServicesFile } : {}),
     },
     web: {
@@ -102,12 +168,7 @@ export default {
     },
     plugins: [
       "expo-router",
-      [
-        "expo-camera",
-        {
-          cameraPermission: "Allow $(PRODUCT_NAME) to access your camera to scan pairing QR codes.",
-        },
-      ],
+      ...buildProfile.cameraPlugins,
       [
         "expo-splash-screen",
         {
@@ -120,14 +181,15 @@ export default {
           },
         },
       ],
+      ...buildProfile.notificationPlugins,
+      "expo-audio",
       [
-        "expo-notifications",
+        "expo-gradle-jvmargs",
         {
-          icon: "./assets/images/notification-icon.png",
-          color: "#20744A",
+          xmx: "4096m",
+          maxMetaspace: "1024m",
         },
       ],
-      "expo-audio",
       [
         "expo-build-properties",
         {
@@ -139,6 +201,7 @@ export default {
           },
         },
       ],
+      ...buildProfile.fdroidPlugins,
     ],
     experiments: {
       typedRoutes: true,
@@ -146,6 +209,7 @@ export default {
       autolinkingModuleResolution: true,
     },
     extra: {
+      fdroidBuild: isFdroidBuild,
       router: {},
       eas: {
         projectId: "0e7f65ce-0367-46c8-a238-2b65963d235a",

packages/app/e2e/add-project-flow.spec.ts

@@ -0,0 +1,350 @@
+import { randomUUID } from "node:crypto";
+import { mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test, expect, type Page } from "./fixtures";
+import {
+  addProjectFlow,
+  addProjectFlowBack,
+  addProjectFlowHost,
+  addProjectFlowInput,
+  addProjectFlowMethod,
+  chooseAddProjectMethod,
+  expectAddProjectPage,
+  expectNewWorkspaceForAddedProject,
+  openAddProjectFlow,
+  waitForConnectedHost,
+} from "./helpers/add-project-flow";
+import { gotoAppShell } from "./helpers/app";
+import { buildSeededHost } from "./helpers/daemon-registry";
+import { addOfflineHostAndReload } from "./helpers/hosts";
+import { type IsolatedHostDaemon, startIsolatedHostDaemon } from "./helpers/isolated-host-daemon";
+import { expectOpenedProject } from "./helpers/project-picker-ui";
+import { connectSeedClient } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+
+const EXTRA_HOSTS_KEY = "@paseo:e2e-extra-hosts";
+const SECONDARY_HOST_ID = "add-project-flow-secondary";
+const SECONDARY_HOST_LABEL = "Secondary Host";
+
+async function addConnectedHostAndReload(page: Page, host: IsolatedHostDaemon): Promise<void> {
+  const registryEntry = buildSeededHost({
+    serverId: host.serverId,
+    label: SECONDARY_HOST_LABEL,
+    endpoint: `127.0.0.1:${host.port}`,
+    nowIso: new Date().toISOString(),
+  });
+  await page.evaluate(
+    ({ key, entry }) => {
+      localStorage.setItem(key, JSON.stringify([entry]));
+    },
+    { key: EXTRA_HOSTS_KEY, entry: registryEntry },
+  );
+  await page.reload();
+}
+
+async function expectProjectDirectory(pathname: string): Promise<void> {
+  await expect.poll(async () => (await stat(pathname)).isDirectory()).toBe(true);
+}
+
+async function removeCreatedProject(
+  pathname: string,
+  knownProjectId: string | null,
+): Promise<void> {
+  const client = await connectSeedClient();
+  try {
+    let projectId = knownProjectId;
+    if (!projectId) {
+      const result = await client.addProject(pathname);
+      projectId = result.project?.projectId ?? null;
+    }
+    if (projectId) await client.removeProject(projectId).catch(() => undefined);
+  } finally {
+    await client.close();
+  }
+}
+
+async function expectProjectHasNoWorkspaces(projectId: string): Promise<void> {
+  const client = await connectSeedClient();
+  try {
+    const result = await client.fetchWorkspaces({ filter: { projectId } });
+    expect(result.entries).toEqual([]);
+  } finally {
+    await client.close();
+  }
+}
+
+test.describe("Add Project command-center flow", () => {
+  test.describe.configure({ timeout: 180_000 });
+
+  test("a single connected host opens directly on method selection", async ({ page }) => {
+    await gotoAppShell(page);
+
+    await openAddProjectFlow(page);
+
+    await expect(addProjectFlowMethod(page, "directory-search")).toBeVisible();
+    await expect(page.getByTestId("add-project-flow-page-host")).toHaveCount(0);
+  });
+
+  test("the back arrow, search input, and result glyph share one left edge", async ({ page }) => {
+    await gotoAppShell(page);
+    await openAddProjectFlow(page);
+
+    await page.keyboard.press("Enter");
+    await expectAddProjectPage(page, "directory-search");
+    await addProjectFlowInput(page).fill("/tmp");
+
+    const backGlyph = addProjectFlowBack(page).locator("svg");
+    const resultGlyph = addProjectFlow(page)
+      .locator('[data-testid^="add-project-flow-path-"]')
+      .first()
+      .locator("svg");
+    await expect(resultGlyph).toBeVisible();
+
+    const [backBox, inputBox, resultBox, titleBox, resultsBox, footerBox] = await Promise.all([
+      backGlyph.boundingBox(),
+      addProjectFlowInput(page).boundingBox(),
+      resultGlyph.boundingBox(),
+      page.getByTestId("add-project-flow-title").boundingBox(),
+      page.getByTestId("add-project-flow-results").boundingBox(),
+      page.getByTestId("add-project-flow-footer").boundingBox(),
+    ]);
+    expect(backBox).not.toBeNull();
+    expect(inputBox).not.toBeNull();
+    expect(resultBox).not.toBeNull();
+    expect(titleBox).not.toBeNull();
+    expect(resultsBox).not.toBeNull();
+    expect(footerBox).not.toBeNull();
+    if (!backBox || !inputBox || !resultBox || !titleBox || !resultsBox || !footerBox) return;
+
+    expect(Math.abs(backBox.x - inputBox.x)).toBeLessThanOrEqual(2);
+    expect(Math.abs(resultBox.x - inputBox.x)).toBeLessThanOrEqual(2);
+    expect(titleBox.height).toBeLessThanOrEqual(24);
+    expect(resultsBox.y + resultsBox.height).toBeLessThanOrEqual(footerBox.y + 1);
+  });
+
+  test("an offline extra host neither appears nor forces host selection", async ({ page }) => {
+    await gotoAppShell(page);
+    await addOfflineHostAndReload(page, {
+      serverId: "add-project-flow-offline",
+      label: "Offline Host",
+    });
+
+    await openAddProjectFlow(page);
+
+    await expect(addProjectFlowHost(page, "add-project-flow-offline")).toHaveCount(0);
+    await expect(addProjectFlowMethod(page, "directory-search")).toBeVisible();
+  });
+
+  test.describe("with two connected hosts", () => {
+    let secondaryHost: IsolatedHostDaemon;
+
+    test.beforeAll(async () => {
+      secondaryHost = await startIsolatedHostDaemon(SECONDARY_HOST_ID);
+    });
+
+    test.afterAll(async () => {
+      await secondaryHost?.close();
+    });
+
+    test("keyboard selection chooses the second host", async ({ page }) => {
+      await gotoAppShell(page);
+      await addConnectedHostAndReload(page, secondaryHost);
+      await waitForConnectedHost(page, {
+        serverId: SECONDARY_HOST_ID,
+        endpoint: `localhost:${secondaryHost.port}`,
+      });
+      await openAddProjectFlow(page, "host");
+
+      await page.keyboard.press("ArrowDown");
+      await page.keyboard.press("Enter");
+
+      await expectAddProjectPage(page, "method");
+      await expect(addProjectFlow(page)).toContainText(SECONDARY_HOST_LABEL);
+    });
+
+    test("Escape and Back restore page input and active selection before closing at the root", async ({
+      page,
+    }) => {
+      await gotoAppShell(page);
+      await addConnectedHostAndReload(page, secondaryHost);
+      await waitForConnectedHost(page, {
+        serverId: SECONDARY_HOST_ID,
+        endpoint: `localhost:${secondaryHost.port}`,
+      });
+      await openAddProjectFlow(page, "host");
+
+      await addProjectFlowInput(page).fill("o");
+      await page.keyboard.press("ArrowDown");
+      await page.keyboard.press("Enter");
+      await expectAddProjectPage(page, "method");
+
+      await addProjectFlowInput(page).fill("new");
+      await page.keyboard.press("Enter");
+      await expectAddProjectPage(page, "new-directory-parent");
+      await page.keyboard.press("Escape");
+
+      await expectAddProjectPage(page, "method");
+      await expect(addProjectFlowInput(page)).toHaveValue("new");
+      await page.keyboard.press("Enter");
+      await expectAddProjectPage(page, "new-directory-parent");
+      await addProjectFlowBack(page).click();
+
+      await expectAddProjectPage(page, "method");
+      await addProjectFlowBack(page).click();
+      await expectAddProjectPage(page, "host");
+      await expect(addProjectFlowInput(page)).toHaveValue("o");
+      await page.keyboard.press("Enter");
+      await expectAddProjectPage(page, "method");
+      await expect(addProjectFlow(page)).toContainText(SECONDARY_HOST_LABEL);
+
+      await page.keyboard.press("Escape");
+      await expectAddProjectPage(page, "host");
+      await page.keyboard.press("Escape");
+      await expect(addProjectFlow(page)).not.toBeVisible();
+    });
+
+    test("New directory creates a Project on the selected remote host", async ({ page }) => {
+      const parentDirectory = await mkdtemp(path.join(tmpdir(), "paseo-e2e-remote-project-"));
+      const directoryName = `remote-${randomUUID().slice(0, 8)}`;
+      const directoryPath = path.join(parentDirectory, directoryName);
+
+      try {
+        await gotoAppShell(page);
+        await addConnectedHostAndReload(page, secondaryHost);
+        await waitForConnectedHost(page, {
+          serverId: SECONDARY_HOST_ID,
+          endpoint: `localhost:${secondaryHost.port}`,
+        });
+        await openAddProjectFlow(page, "host");
+        await addProjectFlowHost(page, SECONDARY_HOST_ID).click();
+        await expectAddProjectPage(page, "method");
+
+        await expect(addProjectFlowMethod(page, "new-directory")).toContainText(
+          `Create an empty directory on ${SECONDARY_HOST_LABEL}`,
+        );
+        await chooseAddProjectMethod(page, "new-directory");
+        await addProjectFlowInput(page).fill(parentDirectory);
+        await page.keyboard.press("Enter");
+        await expectAddProjectPage(page, "new-directory-name");
+        await page.keyboard.type(directoryName);
+        await page.keyboard.press("Enter");
+
+        const projectId = await expectOpenedProject(page, directoryName);
+        await expectNewWorkspaceForAddedProject(page, {
+          serverId: SECONDARY_HOST_ID,
+          projectId,
+          projectName: directoryName,
+          projectPath: directoryPath,
+        });
+        await expect(page.getByTestId("host-picker-trigger")).toContainText(SECONDARY_HOST_LABEL);
+        await expectProjectDirectory(directoryPath);
+      } finally {
+        await rm(parentDirectory, { recursive: true, force: true });
+      }
+    });
+  });
+
+  test("keyboard directory search adds the selected Project", async ({
+    page,
+    projectPickerFixture,
+  }) => {
+    await gotoAppShell(page);
+    await openAddProjectFlow(page);
+
+    await page.keyboard.press("Enter");
+    await expectAddProjectPage(page, "directory-search");
+    await page.keyboard.type(projectPickerFixture.fuzzyQuery);
+    await expect(addProjectFlow(page)).toContainText(projectPickerFixture.projectName, {
+      timeout: 30_000,
+    });
+    await page.keyboard.press("Enter");
+
+    const projectId = await expectOpenedProject(page, projectPickerFixture.projectName);
+    projectPickerFixture.rememberProjectId(projectId);
+    await expectNewWorkspaceForAddedProject(page, {
+      serverId: getServerId(),
+      projectId,
+      projectName: projectPickerFixture.projectName,
+      projectPath: projectPickerFixture.projectPath,
+    });
+    await expectProjectHasNoWorkspaces(projectId);
+  });
+
+  test("the current daemon advertises Clone from GitHub and New directory", async ({ page }) => {
+    await gotoAppShell(page);
+    await openAddProjectFlow(page);
+
+    await expect(addProjectFlowMethod(page, "github")).toContainText("Clone from GitHub");
+    await expect(addProjectFlowMethod(page, "new-directory")).toContainText("New directory");
+  });
+
+  test("a complete repository URL remains selectable without a GitHub search result", async ({
+    page,
+  }) => {
+    await gotoAppShell(page);
+    await openAddProjectFlow(page);
+    await chooseAddProjectMethod(page, "github");
+
+    const remote = "https://github.invalid/acme/manual.git";
+    await addProjectFlowInput(page).fill(remote);
+    await expect(addProjectFlow(page).getByText("manual", { exact: true })).toBeVisible();
+    await page.keyboard.press("Enter");
+
+    await expectAddProjectPage(page, "github-location");
+    const title = addProjectFlow(page).getByTestId("add-project-flow-title");
+    await expect(title.getByText("Choose destination", { exact: true })).toBeVisible();
+    await expect(title.getByText("localhost", { exact: true })).toBeVisible();
+    await expect(title).not.toContainText("Where should Paseo create");
+    await addProjectFlowBack(page).click();
+    await expect(addProjectFlowInput(page)).toHaveValue(remote);
+  });
+
+  test("New directory validates the name, restores parent and name state, then creates a Project", async ({
+    page,
+  }) => {
+    const parentDirectory = await mkdtemp(path.join(tmpdir(), "paseo-e2e-new-project-"));
+    const directoryName = `created-${randomUUID().slice(0, 8)}`;
+    const directoryPath = path.join(parentDirectory, directoryName);
+    let projectId: string | null = null;
+
+    try {
+      await gotoAppShell(page);
+      await openAddProjectFlow(page);
+      await chooseAddProjectMethod(page, "new-directory");
+
+      await page.keyboard.type(parentDirectory);
+      await page.keyboard.press("Enter");
+      await expectAddProjectPage(page, "new-directory-name");
+      await page.keyboard.type("../invalid");
+      await page.keyboard.press("Enter");
+
+      const error = page.getByTestId("add-project-flow-error");
+      await expect(error).toBeVisible();
+      await expect(error).toContainText(/name|separator|directory/i);
+      await expectAddProjectPage(page, "new-directory-name");
+
+      await addProjectFlowInput(page).fill(directoryName);
+      await addProjectFlowBack(page).click();
+      await expectAddProjectPage(page, "new-directory-parent");
+      await expect(addProjectFlowInput(page)).toHaveValue(parentDirectory);
+      await page.keyboard.press("Enter");
+      await expectAddProjectPage(page, "new-directory-name");
+      await expect(addProjectFlowInput(page)).toHaveValue(directoryName);
+      await page.keyboard.press("Enter");
+
+      projectId = await expectOpenedProject(page, directoryName);
+      await expectNewWorkspaceForAddedProject(page, {
+        serverId: getServerId(),
+        projectId,
+        projectName: directoryName,
+        projectPath: directoryPath,
+      });
+      await expectProjectHasNoWorkspaces(projectId);
+      await expectProjectDirectory(directoryPath);
+    } finally {
+      await removeCreatedProject(directoryPath, projectId).catch(() => undefined);
+      await rm(parentDirectory, { recursive: true, force: true });
+    }
+  });
+});

packages/app/e2e/add-project-github.real.spec.ts

@@ -0,0 +1,96 @@
+import { mkdir, mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { expect, test } from "./fixtures";
+import {
+  addProjectFlow,
+  addProjectFlowBack,
+  addProjectFlowInput,
+  chooseAddProjectMethod,
+  expectAddProjectPage,
+  expectNewWorkspaceForAddedProject,
+  openAddProjectFlow,
+} from "./helpers/add-project-flow";
+import { gotoAppShell } from "./helpers/app";
+import { createTempGithubRepo, hasGithubAuth, type GhRepoFixture } from "./helpers/github-fixtures";
+import { expectOpenedProject } from "./helpers/project-picker-ui";
+import { connectSeedClient } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+
+test.describe("Add Project GitHub flow", () => {
+  test.describe.configure({ timeout: 300_000 });
+
+  test("searches the host's repositories and clones into a clearly shown final path", async ({
+    page,
+  }) => {
+    test.skip(!hasGithubAuth(), "Requires GitHub authentication (gh auth login)");
+
+    let repository: GhRepoFixture | null = null;
+    const parentDirectory = await mkdtemp(path.join(tmpdir(), "paseo-e2e-github-clone-"));
+    let projectId: string | null = null;
+
+    try {
+      repository = await createTempGithubRepo({ category: "add-project" });
+      const checkoutPath = path.join(parentDirectory, repository.name);
+
+      await gotoAppShell(page);
+      await openAddProjectFlow(page);
+      await chooseAddProjectMethod(page, "github");
+
+      await addProjectFlowInput(page).fill("getpaseo/paseo");
+      await expect(addProjectFlow(page).getByText("getpaseo/paseo", { exact: true })).toBeVisible({
+        timeout: 30_000,
+      });
+      await addProjectFlowInput(page).fill("");
+
+      const repositoryRow = addProjectFlow(page).getByText(repository.fullName, { exact: true });
+      await expect(repositoryRow).toBeVisible({ timeout: 30_000 });
+      await repositoryRow.click();
+      await expectAddProjectPage(page, "github-location");
+
+      await addProjectFlowInput(page).fill(parentDirectory);
+      await expect(addProjectFlow(page)).toContainText(checkoutPath, { timeout: 30_000 });
+
+      await addProjectFlowBack(page).click();
+      await expectAddProjectPage(page, "github-search");
+      await expect(repositoryRow).toBeVisible();
+      await repositoryRow.click();
+      await expectAddProjectPage(page, "github-location");
+      await expect(addProjectFlowInput(page)).toHaveValue(parentDirectory);
+
+      await mkdir(checkoutPath);
+      await page.keyboard.press("Enter");
+      await expect(page.getByTestId("add-project-flow-error")).toHaveText(
+        `Checkout path already exists: ${checkoutPath}`,
+      );
+
+      await rm(checkoutPath, { recursive: true });
+      await page.keyboard.press("Enter");
+      projectId = await expectOpenedProject(page, repository.name);
+      await expectNewWorkspaceForAddedProject(page, {
+        serverId: getServerId(),
+        projectId,
+        projectName: repository.name,
+        projectPath: checkoutPath,
+      });
+      const client = await connectSeedClient();
+      try {
+        expect((await client.fetchWorkspaces({ filter: { projectId } })).entries).toEqual([]);
+      } finally {
+        await client.close();
+      }
+      await expect.poll(async () => (await stat(checkoutPath)).isDirectory()).toBe(true);
+    } finally {
+      if (projectId) {
+        const client = await connectSeedClient();
+        try {
+          await client.removeProject(projectId).catch(() => undefined);
+        } finally {
+          await client.close();
+        }
+      }
+      await repository?.cleanup();
+      await rm(parentDirectory, { recursive: true, force: true });
+    }
+  });
+});

packages/app/e2e/agent-stream-ui.spec.ts

@@ -8,6 +8,7 @@ import {
 } from "./helpers/agent-stream";
 import {
   expectScrollStaysFixed,
+  clickToolCallBesideScrollToBottomButton,
   readScrollMetrics,
   scrollAgentChatToBottom,
   scrollChatAwayFromBottom,
@@ -37,6 +38,91 @@ test.describe("Agent stream UI", () => {
     }
   });
 
+  test("keeps the active Markdown root mounted across streamed text updates", async ({
+    page,
+  }, testInfo) => {
+    test.setTimeout(120_000);
+    const agent = await startRunningMockAgent(page, {
+      prefix: "stream-markdown-root-",
+      model: "one-minute-stream",
+      prompt: "Stream for Markdown root stability test.",
+    });
+    try {
+      const assistantMessage = page.getByTestId("assistant-message").last();
+      await expect(assistantMessage).toContainText("walking through", { timeout: 30_000 });
+
+      const activeBlock = assistantMessage.locator(":scope > *").last();
+      const initialText = (await activeBlock.textContent()) ?? "";
+      const activeBlockHandle = await activeBlock.elementHandle();
+      if (!activeBlockHandle) {
+        throw new Error("Expected the active assistant message to contain a block");
+      }
+      const markdownRoot = await activeBlock.locator(":scope > *").first().elementHandle();
+      if (!markdownRoot) {
+        throw new Error("Expected the active assistant block to contain a Markdown root");
+      }
+
+      await page.evaluate((block) => {
+        const evidence = {
+          addedNodes: 0,
+          characterDataMutations: 0,
+          removedNodes: 0,
+        };
+        const observer = new MutationObserver((records) => {
+          for (const record of records) {
+            evidence.addedNodes += record.addedNodes.length;
+            evidence.removedNodes += record.removedNodes.length;
+            if (record.type === "characterData") {
+              evidence.characterDataMutations += 1;
+            }
+          }
+        });
+        observer.observe(block, { characterData: true, childList: true, subtree: true });
+        Object.assign(window, {
+          __markdownRootEvidence: evidence,
+          __markdownRootObserver: observer,
+        });
+      }, activeBlockHandle);
+
+      await expect
+        .poll(async () => ((await activeBlock.textContent()) ?? "").length)
+        .toBeGreaterThan(initialText.length + 80);
+
+      const evidence = await page.evaluate((root) => {
+        const state = window as typeof window & {
+          __markdownRootEvidence?: {
+            addedNodes: number;
+            characterDataMutations: number;
+            removedNodes: number;
+          };
+          __markdownRootObserver?: MutationObserver;
+        };
+        state.__markdownRootObserver?.disconnect();
+        const messages = document.querySelectorAll('[data-testid="assistant-message"]');
+        const message = messages.item(messages.length - 1);
+        const block = message?.lastElementChild;
+        return {
+          ...state.__markdownRootEvidence,
+          connected: root.isConnected,
+          sameRoot: block?.firstElementChild === root,
+        };
+      }, markdownRoot);
+
+      await testInfo.attach("markdown-root-stability", {
+        body: JSON.stringify(evidence, null, 2),
+        contentType: "application/json",
+      });
+      expect(evidence.connected).toBe(true);
+      expect(evidence.sameRoot).toBe(true);
+      expect(
+        evidence.removedNodes,
+        `Streaming Markdown replaced mounted descendants: ${JSON.stringify(evidence)}`,
+      ).toBe(0);
+    } finally {
+      await agent.cleanup();
+    }
+  });
+
   test("keeps the viewport fixed after the user scrolls away during a stream", async ({ page }) => {
     test.setTimeout(120_000);
     const agent = await seedMockAgentWorkspace({
@@ -120,6 +206,37 @@ test.describe("Agent stream UI", () => {
     await expectScrollStaysFixed(page, baseline);
   });
 
+  test("keeps tool calls clickable beside the scroll-to-bottom button", async ({ page }) => {
+    test.setTimeout(60_000);
+    const agent = await seedMockAgentWorkspace({
+      repoPrefix: "stream-scroll-button-hit-area-",
+      title: "Scroll button hit area",
+      model: "ten-second-stream",
+      initialPrompt: "Stream enough content to exercise the scroll button hit area.",
+    });
+    try {
+      await agent.client.waitForFinish(agent.agentId, 30_000);
+      await openAgentRoute(page, {
+        workspaceId: agent.workspaceId,
+        agentId: agent.agentId,
+      });
+      await waitForScrollableChat(page, {
+        minScrollableDistance: SCROLL_AWAY_MIN_SCROLLABLE_DISTANCE,
+        timeout: 30_000,
+      });
+
+      const hitArea = await clickToolCallBesideScrollToBottomButton(page);
+
+      expect(hitArea).toEqual({
+        outsideButton: true,
+        toolCallReceivesPointer: true,
+        withinButtonBand: true,
+      });
+    } finally {
+      await agent.cleanup();
+    }
+  });
+
   test("working-indicator transitions to copy-button when stream ends", async ({ page }) => {
     test.setTimeout(60_000);
     const agent = await startRunningMockAgent(page, {

packages/app/e2e/assistant-fork-menu.spec.ts

@@ -1,7 +1,7 @@
 import { expect, test as base, type Page } from "./fixtures";
 import { scrollAgentChatToBottom } from "./helpers/agent-bottom-anchor";
 import { awaitAssistantMessage } from "./helpers/agent-stream";
-import { expectComposerVisible } from "./helpers/composer";
+import { expectComposerVisible, submitMessage } from "./helpers/composer";
 import { getE2EDaemonPort } from "./helpers/daemon-port";
 import {
   openAgentRoute,
@@ -11,6 +11,7 @@ import {
 } from "./helpers/mock-agent";
 import { getServerId } from "./helpers/server-id";
 import { seedSavedSettingsHosts } from "./helpers/settings";
+import { submitNewWorkspaceEmpty } from "./helpers/new-workspace";
 
 const test = base.extend<{
   seedForkWorkspace: (options: MockAgentOptions) => Promise<MockAgentWorkspace>;
@@ -53,14 +54,73 @@ async function expectChatHistoryPill(page: Page): Promise<void> {
 test.describe("Assistant fork menu", () => {
   test.describe.configure({ timeout: 180_000 });
 
-  test("forks an assistant turn into a new workspace draft tab", async ({
+  test("forks a failed assistant turn that has no provider message id", async ({
     page,
     seedForkWorkspace,
   }) => {
     const session = await seedForkWorkspace({
-      repoPrefix: "assistant-fork-tab-",
-      title: "Assistant fork tab",
-      initialPrompt: "emit 1 coalesced agent stream updates for assistant fork tab.",
+      repoPrefix: "assistant-fork-failed-turn-",
+      title: "Assistant fork failed turn",
+      model: "ten-second-stream",
+    });
+
+    await openAgentRoute(page, session);
+    await expectComposerVisible(page);
+    await submitMessage(page, "Emit a synthetic turn failure.");
+    await expect(page.getByText("[System Error] Requested mock provider failure")).toBeVisible({
+      timeout: 30_000,
+    });
+
+    await openAssistantForkMenu(page);
+    await page.getByTestId("assistant-fork-menu-new-tab").click();
+    await expectChatHistoryPill(page);
+  });
+
+  test("focuses a forked assistant turn in a new workspace draft tab", async ({
+    page,
+    seedForkWorkspace,
+  }) => {
+    const session = await seedForkWorkspace({
+      repoPrefix: "assistant-fork-focused-tab-",
+      title: "Assistant fork focused tab",
+      initialPrompt: "emit 1 coalesced agent stream updates for initial assistant fork turn.",
+      model: "ten-second-stream",
+    });
+
+    await openAgentRoute(page, session);
+    await expectComposerVisible(page);
+    await awaitAssistantMessage(page);
+    await session.client.waitForFinish(session.agentId, 45_000);
+
+    await submitMessage(page, "emit 1 coalesced agent stream updates while this tab is visible.");
+    await session.client.waitForFinish(session.agentId, 45_000);
+    await awaitAssistantMessage(page);
+
+    const agentTab = page.getByTestId(`workspace-tab-agent_${session.agentId}`);
+    await expect(agentTab).toHaveAttribute("aria-selected", "true");
+
+    await openAssistantForkMenu(page);
+    await page.getByTestId("assistant-fork-menu-new-tab").click();
+
+    const selectedTab = page
+      .getByTestId("workspace-tabs-row")
+      .getByRole("button")
+      .and(page.locator('[aria-selected="true"]'));
+    await expect(selectedTab).toHaveAttribute("data-testid", /^workspace-tab-draft_/, {
+      timeout: 30_000,
+    });
+    await expect(agentTab).toHaveAttribute("aria-selected", "false");
+    await expectChatHistoryPill(page);
+  });
+
+  test("keeps the fork attachment after submitting an existing-workspace draft tab", async ({
+    page,
+    seedForkWorkspace,
+  }) => {
+    const session = await seedForkWorkspace({
+      repoPrefix: "assistant-fork-tab-submit-",
+      title: "Assistant fork tab submit",
+      initialPrompt: "emit 1 coalesced agent stream updates for assistant fork tab submit.",
       model: "ten-second-stream",
     });
 
@@ -71,8 +131,13 @@ test.describe("Assistant fork menu", () => {
 
     await openAssistantForkMenu(page);
     await page.getByTestId("assistant-fork-menu-new-tab").click();
-
     await expectChatHistoryPill(page);
+
+    await submitMessage(page, "");
+
+    const userMessage = page.getByTestId("user-message").filter({ hasText: "Chat history" }).last();
+    await expect(userMessage).toBeVisible({ timeout: 30_000 });
+    await expect(userMessage).not.toContainText("Source agent:");
   });
 
   test("forks an assistant turn into New Workspace and keeps the attachment across host changes", async ({
@@ -118,4 +183,31 @@ test.describe("Assistant fork menu", () => {
       .click();
     await expectChatHistoryPill(page);
   });
+
+  test("keeps the fork attachment after the new agent receives its user message", async ({
+    page,
+    seedForkWorkspace,
+  }) => {
+    const session = await seedForkWorkspace({
+      repoPrefix: "assistant-fork-submit-",
+      title: "Assistant fork submit",
+      initialPrompt: "emit 1 coalesced agent stream updates for assistant fork submit.",
+      model: "ten-second-stream",
+    });
+
+    await openAgentRoute(page, session);
+    await expectComposerVisible(page);
+    await awaitAssistantMessage(page);
+    await session.client.waitForFinish(session.agentId, 45_000);
+
+    await openAssistantForkMenu(page);
+    await page.getByTestId("assistant-fork-menu-new-workspace").click();
+    await expectChatHistoryPill(page);
+
+    await submitNewWorkspaceEmpty(page);
+
+    const userMessage = page.getByTestId("user-message").filter({ hasText: "Chat history" }).last();
+    await expect(userMessage).toBeVisible({ timeout: 30_000 });
+    await expect(userMessage).not.toContainText("Source agent:");
+  });
 });

packages/app/e2e/command-center-host.spec.ts

@@ -5,6 +5,7 @@ import { gotoAppShell } from "./helpers/app";
 import { createIdleAgent } from "./helpers/archive-tab";
 import { openCommandCenter } from "./helpers/command-center";
 import { addOfflineHostAndReload } from "./helpers/hosts";
+import { expectAgentTabActive } from "./helpers/launcher";
 import { seedWorkspace } from "./helpers/seed-client";
 import { getServerId } from "./helpers/server-id";
 
@@ -46,4 +47,26 @@ test.describe("Command center host labels", () => {
       await seeded.cleanup();
     }
   });
+
+  test("selecting an agent result opens its workspace tab", async ({ page }) => {
+    const seeded = await seedWorkspace({ repoPrefix: "command-center-agent-navigation-" });
+    const title = `cc-navigation-${randomUUID().slice(0, 8)}`;
+
+    try {
+      const agent = await createIdleAgent(seeded.client, {
+        cwd: seeded.repoPath,
+        workspaceId: seeded.workspaceId,
+        title,
+      });
+
+      await gotoAppShell(page);
+      const panel = await openCommandCenter(page);
+      await panel.getByTestId("command-center-input").fill(title);
+      await page.keyboard.press("Enter");
+
+      await expectAgentTabActive(page, agent.id);
+    } finally {
+      await seeded.cleanup();
+    }
+  });
 });

packages/app/e2e/command-center-workspaces.spec.ts

@@ -0,0 +1,106 @@
+import { execFileSync } from "node:child_process";
+import { expect } from "@playwright/test";
+import { test } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { createIdleAgent } from "./helpers/archive-tab";
+import { openCommandCenter } from "./helpers/command-center";
+import { addOfflineHostAndReload } from "./helpers/hosts";
+import { expectAppRoute } from "./helpers/route-assertions";
+import { seedWorkspace } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { buildHostWorkspaceRoute } from "@/utils/host-routes";
+
+const PRIMARY_HOST_LABEL = "Primary Host";
+const SECONDARY_HOST_ID = "host-command-center-workspaces-secondary";
+const WORKSPACE_TITLE = "Payments Refactor";
+const WORKSPACE_BRANCH = "feature/cmd-k-workspaces";
+const AGENT_TITLE = "Fix checkout retries";
+
+test.describe("Command center workspaces", () => {
+  test.describe.configure({ timeout: 180_000 });
+
+  test("workspace results show their title, host, and branch and open the workspace", async ({
+    page,
+  }) => {
+    const seeded = await seedWorkspace({
+      repoPrefix: "command-center-workspace-",
+      title: WORKSPACE_TITLE,
+    });
+
+    try {
+      execFileSync("git", ["checkout", "-b", WORKSPACE_BRANCH], {
+        cwd: seeded.repoPath,
+        stdio: "ignore",
+      });
+      const refreshed = await seeded.client.checkoutRefresh(seeded.repoPath);
+      if (!refreshed.success) {
+        throw new Error(`Failed to refresh checkout: ${JSON.stringify(refreshed.error)}`);
+      }
+      const agent = await createIdleAgent(seeded.client, {
+        cwd: seeded.repoPath,
+        workspaceId: seeded.workspaceId,
+        title: AGENT_TITLE,
+      });
+
+      await gotoAppShell(page);
+      await addOfflineHostAndReload(page, {
+        serverId: SECONDARY_HOST_ID,
+        label: "Secondary Host",
+        primaryLabel: PRIMARY_HOST_LABEL,
+      });
+
+      const panel = await openCommandCenter(page);
+      const row = panel.getByTestId(
+        `command-center-workspace-${getServerId()}:${seeded.workspaceId}`,
+      );
+      await expect(row).toBeVisible({ timeout: 30_000 });
+      await expect(row).toContainText(WORKSPACE_TITLE);
+      await expect(row).toContainText(PRIMARY_HOST_LABEL);
+      await expect(row).toContainText(WORKSPACE_BRANCH);
+
+      const agentRow = panel.getByTestId(`command-center-agent-${getServerId()}:${agent.id}`);
+      await expect(agentRow).toContainText(AGENT_TITLE);
+      await expect(agentRow).toContainText(PRIMARY_HOST_LABEL);
+      await expect(agentRow).toContainText(WORKSPACE_TITLE);
+      await expect(agentRow).not.toContainText(seeded.repoPath);
+
+      const workspaceSectionTop = await panel
+        .getByText("Workspaces", { exact: true })
+        .evaluate((element) => element.getBoundingClientRect().top);
+      const agentSectionTop = await panel
+        .getByText("Agents", { exact: true })
+        .evaluate((element) => element.getBoundingClientRect().top);
+      expect(workspaceSectionTop).toBeLessThan(agentSectionTop);
+
+      const input = panel.getByTestId("command-center-input");
+      await input.fill(PRIMARY_HOST_LABEL);
+      await expect(row).toBeVisible();
+      await expect(agentRow).toBeVisible();
+
+      await input.fill(WORKSPACE_BRANCH);
+      await expect(row).toBeVisible();
+      await expect(agentRow).not.toBeVisible();
+
+      await input.fill(WORKSPACE_TITLE);
+      await expect(row).toBeVisible();
+      await expect(agentRow).toBeVisible();
+
+      await input.fill(seeded.repoPath);
+      await expect(agentRow).toBeVisible();
+      await expect(row).not.toBeVisible();
+
+      await input.fill(AGENT_TITLE);
+      await expect(agentRow).toBeVisible();
+      await expect(row).not.toBeVisible();
+
+      await input.fill(WORKSPACE_TITLE);
+      await page.keyboard.press("Enter");
+
+      await expectAppRoute(page, buildHostWorkspaceRoute(getServerId(), seeded.workspaceId), {
+        timeout: 30_000,
+      });
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+});

packages/app/e2e/empty-project-persists.spec.ts

@@ -1,6 +1,12 @@
 import path from "node:path";
+import { existsSync } from "node:fs";
 import { test, expect, type Page } from "./fixtures";
 import { gotoAppShell } from "./helpers/app";
+import {
+  addProjectFlowInput,
+  chooseAddProjectMethod,
+  openAddProjectFlow,
+} from "./helpers/add-project-flow";
 import { expectOpenedProject } from "./helpers/project-picker-ui";
 import { connectSeedClient, seedWorkspace } from "./helpers/seed-client";
 import { getServerId } from "./helpers/server-id";
@@ -11,7 +17,7 @@ function workspaceRowTestId(workspaceId: string): string {
   return `sidebar-workspace-row-${getServerId()}:${workspaceId}`;
 }
 
-async function hideWorkspaceFromSidebar(page: Page, workspaceId: string): Promise<void> {
+async function archiveWorkspaceFromSidebar(page: Page, workspaceId: string): Promise<void> {
   const serverId = getServerId();
   const row = page.getByTestId(workspaceRowTestId(workspaceId));
   await expect(row).toBeVisible({ timeout: 30_000 });
@@ -21,10 +27,6 @@ async function hideWorkspaceFromSidebar(page: Page, workspaceId: string): Promis
   await expect(kebab).toBeVisible({ timeout: 10_000 });
   await kebab.click();
 
-  // Hiding a checkout from the sidebar raises a browser confirm; accept it so the
-  // user-confirmed archive proceeds deterministically.
-  page.once("dialog", (dialog) => void dialog.accept());
-
   const archiveItem = page.getByTestId(`sidebar-workspace-menu-archive-${serverId}:${workspaceId}`);
   await expect(archiveItem).toBeVisible({ timeout: 10_000 });
   await archiveItem.click();
@@ -49,10 +51,10 @@ async function removeProjectFromSidebar(page: Page, projectId: string): Promise<
 }
 
 async function addProjectFromPicker(page: Page, projectPath: string): Promise<string> {
-  await page.getByTestId("sidebar-add-project").click();
+  await openAddProjectFlow(page);
+  await chooseAddProjectMethod(page, "directory-search");
 
-  const input = page.getByTestId("project-picker-input");
-  await expect(input).toBeVisible({ timeout: 30_000 });
+  const input = addProjectFlowInput(page);
   await input.fill(projectPath);
   await page.keyboard.press("Enter");
 
@@ -81,10 +83,10 @@ test.describe("Project picker search", () => {
   }) => {
     await gotoAppShell(page);
     await waitForSidebarProjectListReady(page);
-    await page.getByTestId("sidebar-add-project").click();
+    await openAddProjectFlow(page);
+    await chooseAddProjectMethod(page, "directory-search");
 
-    const input = page.getByTestId("project-picker-input");
-    await expect(input).toBeVisible({ timeout: 30_000 });
+    const input = addProjectFlowInput(page);
     await input.fill(projectPickerFixture.fuzzyQuery);
 
     const suggestion = page.getByText(projectPickerFixture.projectName, { exact: false }).first();
@@ -100,14 +102,14 @@ test.describe("Project picker search", () => {
   }) => {
     await gotoAppShell(page);
     await waitForSidebarProjectListReady(page);
-    await page.getByTestId("sidebar-add-project").click();
+    await openAddProjectFlow(page);
+    await chooseAddProjectMethod(page, "directory-search");
 
-    const input = page.getByTestId("project-picker-input");
-    await expect(input).toBeVisible({ timeout: 30_000 });
+    const input = addProjectFlowInput(page);
     await input.fill("paseo-loading-state-no-match");
 
     await expect(page.getByText("Start typing a path", { exact: true })).toHaveCount(0);
-    await expect(page.getByText("Searching...", { exact: true })).toBeVisible();
+    await expect(page.getByText("Loading...", { exact: true })).toBeVisible();
   });
 });
 
@@ -159,17 +161,21 @@ test.describe("Project with no workspaces persists", () => {
       await gotoAppShell(page);
       await waitForSidebarHydration(page);
       await expect(projectRow).toBeVisible({ timeout: 30_000 });
-      await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toBeVisible({
+      const workspaceRow = page.getByTestId(workspaceRowTestId(workspace.workspaceId));
+      await expect(workspaceRow).toBeVisible({
         timeout: 30_000,
       });
+      await workspaceRow.click();
+      await expect(page.getByTestId("changes-primary-cta")).toHaveCount(0);
 
-      await hideWorkspaceFromSidebar(page, workspace.workspaceId);
+      await archiveWorkspaceFromSidebar(page, workspace.workspaceId);
 
       // The workspace row goes away, but its project parent stays and exposes a
       // child row for creating the next workspace.
       await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toHaveCount(0, {
         timeout: 30_000,
       });
+      expect(existsSync(workspace.repoPath)).toBe(true);
       await expect(projectRow).toBeVisible({ timeout: 30_000 });
       await expect(newWorkspaceRow).toBeVisible({ timeout: 30_000 });
       await expect(newWorkspaceRow).toContainText("New workspace");

packages/app/e2e/helpers/add-project-flow.ts

@@ -0,0 +1,95 @@
+import { expect, type Locator, type Page } from "@playwright/test";
+
+export type AddProjectFlowPage =
+  | "host"
+  | "method"
+  | "directory-search"
+  | "github-search"
+  | "github-location"
+  | "new-directory-parent"
+  | "new-directory-name";
+
+export type AddProjectMethod = "directory-search" | "browse" | "github" | "new-directory";
+
+const METHOD_DESTINATIONS: Record<Exclude<AddProjectMethod, "browse">, AddProjectFlowPage> = {
+  "directory-search": "directory-search",
+  github: "github-search",
+  "new-directory": "new-directory-parent",
+};
+
+export function addProjectFlow(page: Page): Locator {
+  return page.getByTestId("add-project-flow");
+}
+
+export function addProjectFlowInput(page: Page): Locator {
+  return page.getByTestId("add-project-flow-input");
+}
+
+export function addProjectFlowBack(page: Page): Locator {
+  return page.getByTestId("add-project-flow-back");
+}
+
+export function addProjectFlowHost(page: Page, serverId: string): Locator {
+  return page.getByTestId(`add-project-flow-host-${serverId}`);
+}
+
+export function addProjectFlowMethod(page: Page, method: AddProjectMethod): Locator {
+  return page.getByTestId(`add-project-flow-method-${method}`);
+}
+
+export async function waitForConnectedHost(
+  page: Page,
+  input: { serverId: string; endpoint: string },
+): Promise<void> {
+  await page.getByTestId("sidebar-hosts-trigger").click();
+  const host = page.getByTestId(`sidebar-host-row-${input.serverId}`);
+  await expect(host).toContainText(input.endpoint, { timeout: 30_000 });
+  await page.keyboard.press("Escape");
+  await expect(host).not.toBeVisible();
+}
+
+export async function expectAddProjectPage(page: Page, kind: AddProjectFlowPage): Promise<Locator> {
+  const currentPage = page.getByTestId(`add-project-flow-page-${kind}`);
+  await expect(currentPage).toBeVisible({ timeout: 30_000 });
+  return currentPage;
+}
+
+export async function openAddProjectFlow(
+  page: Page,
+  expectedPage: "host" | "method" = "method",
+): Promise<void> {
+  await page.getByTestId("sidebar-add-project").click();
+  await expect(addProjectFlow(page)).toBeVisible({ timeout: 30_000 });
+  await expectAddProjectPage(page, expectedPage);
+  await expect(addProjectFlowInput(page)).toBeFocused();
+}
+
+export async function chooseAddProjectMethod(page: Page, method: AddProjectMethod): Promise<void> {
+  const option = addProjectFlowMethod(page, method);
+  await expect(option).toBeVisible();
+  await option.click();
+  if (method !== "browse") {
+    await expectAddProjectPage(page, METHOD_DESTINATIONS[method]);
+  }
+}
+
+export async function expectNewWorkspaceForAddedProject(
+  page: Page,
+  input: {
+    serverId: string;
+    projectId: string;
+    projectName: string;
+    projectPath: string;
+  },
+): Promise<void> {
+  await expect(page).toHaveURL(/\/new\?.*projectId=/u, { timeout: 30_000 });
+  const url = new URL(page.url());
+  expect(url.pathname).toBe("/new");
+  expect(url.searchParams.get("serverId")).toBe(input.serverId);
+  expect(url.searchParams.get("projectId")).toBe(input.projectId);
+  expect(url.searchParams.get("dir")).toBe(input.projectPath);
+  await expect(page.getByRole("button", { name: "Workspace project" })).toContainText(
+    input.projectName,
+    { timeout: 30_000 },
+  );
+}

packages/app/e2e/helpers/agent-bottom-anchor.ts

@@ -124,6 +124,111 @@ export async function scrollChatAwayFromBottom(
   return readScrollMetrics(page);
 }
 
+export async function clickToolCallBesideScrollToBottomButton(page: Page): Promise<{
+  outsideButton: boolean;
+  toolCallReceivesPointer: boolean;
+  withinButtonBand: boolean;
+}> {
+  await scrollChatAwayFromBottom(page, {
+    deltaY: -900,
+    minDistanceFromBottom: 300,
+  });
+
+  const scrollToBottomButton = page.getByRole("button", { name: "Scroll to bottom" });
+  await expect(scrollToBottomButton).toBeVisible();
+
+  const buttonBounds = await scrollToBottomButton.boundingBox();
+  expect(buttonBounds, "Expected visible scroll-to-bottom button bounds").not.toBeNull();
+  const visibleButtonBounds = buttonBounds!;
+
+  const toolCalls = page.locator('[data-testid="tool-call-badge"] [role="button"]');
+  const toolCallBounds = await Promise.all(
+    Array.from({ length: await toolCalls.count() }, async (_, index) => ({
+      index,
+      bounds: await toolCalls.nth(index).boundingBox(),
+    })),
+  );
+  const buttonCenterY = visibleButtonBounds.y + visibleButtonBounds.height / 2;
+  const candidate = toolCallBounds
+    .filter(
+      (entry): entry is { index: number; bounds: NonNullable<typeof entry.bounds> } =>
+        entry.bounds !== null && entry.bounds.width > 0,
+    )
+    .sort(
+      (left, right) =>
+        Math.abs(left.bounds.y + left.bounds.height / 2 - buttonCenterY) -
+        Math.abs(right.bounds.y + right.bounds.height / 2 - buttonCenterY),
+    )[0];
+  expect(
+    candidate,
+    `Expected at least one rendered tool-call badge: ${JSON.stringify({
+      buttonBounds,
+      scrollMetrics: await readScrollMetrics(page),
+      toolCallBounds,
+    })}`,
+  ).toBeDefined();
+  const visibleToolCall = candidate!;
+  const initialToolCallCenterY = visibleToolCall.bounds.y + visibleToolCall.bounds.height / 2;
+  await getVisibleChatScroll(page).evaluate((scroll, deltaY) => {
+    (scroll as HTMLElement).scrollTop += deltaY;
+  }, initialToolCallCenterY - buttonCenterY);
+
+  const alignedToolCall = toolCalls.nth(visibleToolCall.index);
+  await expect
+    .poll(async () => {
+      const [currentButtonBounds, currentToolCallBounds] = await Promise.all([
+        scrollToBottomButton.boundingBox(),
+        alignedToolCall.boundingBox(),
+      ]);
+      if (!currentButtonBounds || !currentToolCallBounds) {
+        return false;
+      }
+      const toolCallCenterY = currentToolCallBounds.y + currentToolCallBounds.height / 2;
+      return (
+        toolCallCenterY >= currentButtonBounds.y &&
+        toolCallCenterY <= currentButtonBounds.y + currentButtonBounds.height
+      );
+    })
+    .toBe(true);
+
+  const [alignedButtonBounds, visibleToolCallBounds] = await Promise.all([
+    scrollToBottomButton.boundingBox(),
+    alignedToolCall.boundingBox(),
+  ]);
+  expect(alignedButtonBounds, "Expected scroll-to-bottom button to remain visible").not.toBeNull();
+  expect(
+    visibleToolCallBounds,
+    "Expected aligned tool-call badge to remain visible",
+  ).not.toBeNull();
+  const finalButtonBounds = alignedButtonBounds!;
+  const finalToolCallBounds = visibleToolCallBounds!;
+
+  const clickPoint = {
+    x: finalToolCallBounds.x + 24,
+    y: finalToolCallBounds.y + finalToolCallBounds.height / 2,
+  };
+  const toolCallReceivesPointer = await alignedToolCall.evaluate((toolCall, point) => {
+    const hit = document.elementFromPoint(point.x, point.y);
+    return hit !== null && toolCall.contains(hit);
+  }, clickPoint);
+  const hitArea = {
+    clickPoint,
+    outsideButton:
+      clickPoint.x < finalButtonBounds.x ||
+      clickPoint.x > finalButtonBounds.x + finalButtonBounds.width,
+    toolCallReceivesPointer,
+    withinButtonBand:
+      clickPoint.y >= finalButtonBounds.y &&
+      clickPoint.y <= finalButtonBounds.y + finalButtonBounds.height,
+  };
+  await page.mouse.click(hitArea.clickPoint.x, hitArea.clickPoint.y);
+  return {
+    outsideButton: hitArea.outsideButton,
+    toolCallReceivesPointer: hitArea.toolCallReceivesPointer,
+    withinButtonBand: hitArea.withinButtonBand,
+  };
+}
+
 export async function expectScrollStaysFixed(
   page: Page,
   baseline: ScrollMetrics,

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

@@ -40,6 +40,7 @@ export interface IdleAgentSeedClient {
     provider: string;
     model: string;
     modeId: string;
+    featureValues?: Record<string, unknown>;
     cwd: string;
     workspaceId: string;
     title: string;
@@ -58,7 +59,11 @@ export async function createIdleAgent(
   const created = await client.createAgent({
     provider: "opencode",
     model: "opencode/gpt-5-nano",
-    modeId: "bypassPermissions",
+    // OpenCode has no "bypassPermissions" mode (that's Claude's). Use build with
+    // auto_accept for unattended full access — mode validation now rejects modes
+    // the provider doesn't define.
+    modeId: "build",
+    featureValues: { auto_accept: true },
     cwd: input.cwd,
     workspaceId: input.workspaceId,
     title: input.title,

packages/app/e2e/helpers/isolated-host-daemon.ts

@@ -0,0 +1,129 @@
+import { once } from "node:events";
+import { spawn, execSync, type ChildProcess } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import net from "node:net";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { withDisabledE2ESpeechEnv } from "./speech-env";
+
+export interface IsolatedHostDaemon {
+  serverId: string;
+  port: number;
+  close(): Promise<void>;
+}
+
+async function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close(() => reject(new Error("Failed to acquire an isolated daemon port")));
+        return;
+      }
+      server.close(() => resolve(address.port));
+    });
+  });
+}
+
+async function waitForServer(port: number, child: ChildProcess): Promise<void> {
+  const deadline = Date.now() + 20_000;
+  let lastError: unknown = null;
+
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      throw new Error(`Isolated host daemon exited before listening (exit ${child.exitCode})`);
+    }
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const socket = net.connect(port, "127.0.0.1", () => {
+          socket.end();
+          resolve();
+        });
+        socket.setTimeout(1_000, () => {
+          socket.destroy();
+          reject(new Error(`Connection timed out to isolated daemon port ${port}`));
+        });
+        socket.on("error", reject);
+      });
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+
+  throw new Error(
+    `Isolated host daemon did not listen on ${port}: ${
+      lastError instanceof Error ? lastError.message : String(lastError)
+    }`,
+  );
+}
+
+async function stopProcess(child: ChildProcess): Promise<void> {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  const timeout = setTimeout(() => {
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  }, 5_000);
+  try {
+    await once(child, "exit");
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function startIsolatedHostDaemon(serverId: string): Promise<IsolatedHostDaemon> {
+  const primaryPort = Number(process.env.E2E_DAEMON_PORT ?? 0);
+  let port = await getAvailablePort();
+  while (port === 6767 || port === primaryPort) port = await getAvailablePort();
+
+  const metroPort = process.env.E2E_METRO_PORT;
+  if (!metroPort) throw new Error("E2E_METRO_PORT is required to start an isolated host daemon");
+
+  const paseoHome = await mkdtemp(path.join(tmpdir(), "paseo-e2e-secondary-host-"));
+  const serverDir = path.resolve(__dirname, "../../../server");
+  const tsxBin = execSync("which tsx").toString().trim();
+  const child = spawn(tsxBin, ["scripts/supervisor-entrypoint.ts", "--dev"], {
+    cwd: serverDir,
+    env: withDisabledE2ESpeechEnv({
+      ...process.env,
+      PASEO_HOME: paseoHome,
+      PASEO_SERVER_ID: serverId,
+      PASEO_LISTEN: `127.0.0.1:${port}`,
+      PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
+      PASEO_RELAY_ENABLED: "0",
+      PASEO_NODE_ENV: "development",
+      NODE_ENV: "development",
+    }),
+    stdio: ["ignore", "ignore", "pipe"],
+    detached: false,
+  });
+
+  let stderr = "";
+  child.stderr?.on("data", (chunk: Buffer) => {
+    stderr += chunk.toString("utf8");
+    stderr = stderr.split("\n").slice(-40).join("\n");
+  });
+
+  try {
+    await waitForServer(port, child);
+  } catch (error) {
+    await stopProcess(child);
+    await rm(paseoHome, { recursive: true, force: true });
+    throw new Error(
+      `${error instanceof Error ? error.message : String(error)}\nDaemon stderr:\n${stderr}`,
+      { cause: error },
+    );
+  }
+
+  return {
+    serverId,
+    port,
+    close: async () => {
+      await stopProcess(child);
+      await rm(paseoHome, { recursive: true, force: true });
+    },
+  };
+}

packages/app/e2e/helpers/new-workspace.ts

@@ -181,6 +181,21 @@ export async function expectNewWorkspaceProjectSelected(
   await expect(projectPicker).toContainText(projectDisplayName);
 }
 
+export async function fillNewWorkspaceDraft(page: Page, draft: string): Promise<void> {
+  const composer = page.getByRole("textbox", { name: "Message agent..." });
+  await expect(composer).toBeVisible({ timeout: 30_000 });
+  await composer.fill(draft);
+}
+
+export async function expectNewWorkspaceDraft(page: Page, draft: string): Promise<void> {
+  await expect(page.getByRole("textbox", { name: "Message agent..." })).toHaveValue(draft);
+}
+
+export async function selectNewWorkspaceHost(page: Page, hostLabel: string): Promise<void> {
+  await page.getByTestId("host-picker-trigger").click();
+  await page.getByText(hostLabel, { exact: true }).click();
+}
+
 export async function submitNewWorkspacePrompt(
   page: Page,
   prompt = "Hello from e2e",

packages/app/e2e/helpers/rewind-flow.ts

@@ -154,6 +154,10 @@ export async function launchAgent(input: {
   provider: RewindFlowProvider;
   cwd: string;
   mode: "full-access";
+  providerConfig?: {
+    model?: string;
+    extra?: { codex?: { features?: { multi_agent_v2?: boolean } } };
+  };
 }): Promise<AgentHandle> {
   execFileSync("git", ["init", "-b", "main"], { cwd: input.cwd, stdio: "ignore" });
   execFileSync("git", ["config", "user.email", "paseo-test@example.com"], {
@@ -180,6 +184,7 @@ export async function launchAgent(input: {
   }
   const agent = await client.createAgent({
     ...fullAccessConfig(input.provider),
+    ...input.providerConfig,
     cwd: input.cwd,
     workspaceId: createdWorkspace.workspace.id,
     title: `rewind-flow-${input.provider}-${randomUUID()}`,

packages/app/e2e/helpers/seed-client.ts

@@ -183,6 +183,7 @@ export interface SeededWorkspace {
 
 export async function seedWorkspace(options: {
   repoPrefix: string;
+  title?: string;
   /** Repo fixture options; only applies to git projects (the default). */
   repo?: Parameters<typeof createTempGitRepo>[1];
   /** Set to false to seed a plain non-git directory instead of a git repo. */
@@ -196,6 +197,7 @@ export async function seedWorkspace(options: {
   try {
     const created = await client.createWorkspace({
       source: { kind: "directory", path: project.path },
+      title: options.title,
     });
     if (!created.workspace) {
       throw new Error(created.error ?? `Failed to create workspace ${project.path}`);

packages/app/e2e/helpers/sidebar.ts

@@ -39,10 +39,9 @@ export async function clickArchiveWorkspaceMenuItem(
   await archiveItem.click();
 }
 
-export async function archiveWorktreeFromSidebar(page: Page, workspaceId: string): Promise<void> {
-  // A clean worktree archives with no prompt; if the host reports unsynced work the app
-  // raises a browser confirm. Accept it so the user-confirmed archive stays deterministic
-  // either way.
+export async function archiveWorkspaceFromSidebar(page: Page, workspaceId: string): Promise<void> {
+  // A clean workspace archives with no prompt. Managed worktree backing may raise
+  // a browser confirm for unsynced work, so accept it when present.
   page.once("dialog", (dialog) => void dialog.accept());
   await clickArchiveWorkspaceMenuItem(page, workspaceId);
 }
@@ -62,13 +61,14 @@ export async function openMobileAgentSidebar(page: Page): Promise<void> {
 
 export async function closeMobileAgentSidebar(page: Page): Promise<void> {
   const closeButton = page.getByTestId("sidebar-close");
-  await expect(closeButton).toBeInViewport({ timeout: 5_000 });
-  await closeButton.click({ force: true });
+  await expect(closeButton).toBeInViewport({ ratio: 1, timeout: 5_000 });
+  await closeButton.click();
 }
 
-// The mobile sidebar panel animates via translateX; toBeInViewport reflects the rendered position.
+// The mobile sidebar panel animates via translateX. Waiting for its header to be fully visible
+// prevents a close click from targeting a button while the panel is still moving.
 export async function expectMobileAgentSidebarVisible(page: Page): Promise<void> {
-  await expect(page.getByTestId("sidebar-sessions")).toBeInViewport({ timeout: 5_000 });
+  await expect(page.getByTestId("sidebar-sessions")).toBeInViewport({ ratio: 1, timeout: 5_000 });
 }
 
 export async function expectMobileAgentSidebarHidden(page: Page): Promise<void> {

packages/app/e2e/helpers/subagents.ts

@@ -14,6 +14,17 @@ export interface SeededSubagentPair {
   workspaceId: string;
 }
 
+export interface SeededCrossWorkspaceSubagentPair {
+  parent: {
+    id: string;
+    workspaceId: string;
+  };
+  child: {
+    id: string;
+    workspaceId: string;
+  };
+}
+
 export async function seedParentWithSubagent(
   workspace: Pick<SeededWorkspace, "client" | "repoPath" | "workspaceId">,
   input: { parentTitle: string; childTitle: string },
@@ -51,6 +62,60 @@ export async function seedParentWithSubagent(
   };
 }
 
+export async function seedParentWithCrossWorkspaceSubagent(
+  workspace: Pick<SeededWorkspace, "client" | "repoPath" | "workspaceId" | "projectId">,
+  input: { parentTitle: string; childTitle: string },
+): Promise<SeededCrossWorkspaceSubagentPair> {
+  const parent = await workspace.client.createAgent({
+    provider: "mock",
+    cwd: workspace.repoPath,
+    workspaceId: workspace.workspaceId,
+    title: input.parentTitle,
+    modeId: "load-test",
+    model: "ten-second-stream",
+  });
+  const createdWorkspace = await workspace.client.createWorkspace({
+    source: {
+      kind: "directory",
+      path: workspace.repoPath,
+      projectId: workspace.projectId,
+    },
+    title: "Subagent workspace",
+  });
+  if (!createdWorkspace.workspace) {
+    throw new Error(createdWorkspace.error ?? "Failed to create subagent workspace");
+  }
+
+  const child = await workspace.client.createAgent({
+    provider: "mock",
+    cwd: workspace.repoPath,
+    workspaceId: createdWorkspace.workspace.id,
+    title: input.childTitle,
+    modeId: "load-test",
+    model: "five-minute-stream",
+    initialPrompt: "stay running",
+    labels: {
+      [PARENT_AGENT_ID_LABEL]: parent.id,
+    },
+  });
+  await workspace.client.waitForAgentUpsert(
+    child.id,
+    (snapshot) => snapshot.status === "running",
+    15_000,
+  );
+
+  return {
+    parent: {
+      id: parent.id,
+      workspaceId: workspace.workspaceId,
+    },
+    child: {
+      id: child.id,
+      workspaceId: createdWorkspace.workspace.id,
+    },
+  };
+}
+
 export async function openSubagentsTrack(page: Page): Promise<void> {
   await page.getByTestId("subagents-track-header").click();
 }

packages/app/e2e/new-workspace-composer-draft.spec.ts

@@ -0,0 +1,88 @@
+import { test } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { getE2EDaemonPort } from "./helpers/daemon-port";
+import {
+  expectNewWorkspaceDraft,
+  expectNewWorkspaceProjectSelected,
+  fillNewWorkspaceDraft,
+  openGlobalNewWorkspaceComposer,
+  openNewWorkspaceComposer,
+  selectNewWorkspaceHost,
+  selectNewWorkspaceProject,
+} from "./helpers/new-workspace";
+import { seedWorkspace, type SeededWorkspace } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { seedSavedSettingsHosts } from "./helpers/settings";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+
+const DRAFT = `Please investigate the workspace startup failure.
+
+Trace the request from the app through the daemon, preserve the existing behavior, and explain the root cause before making changes.`;
+
+test.describe("New workspace composer draft", () => {
+  test.describe.configure({ timeout: 240_000 });
+
+  test("keeps the draft when the project changes", async ({ page }) => {
+    const firstProject: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "new-workspace-draft-project-a-",
+    });
+    const secondProject: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "new-workspace-draft-project-b-",
+    });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await openNewWorkspaceComposer(page, {
+        projectKey: firstProject.projectId,
+        projectDisplayName: firstProject.projectDisplayName,
+      });
+      await expectNewWorkspaceProjectSelected(page, firstProject.projectDisplayName);
+
+      await fillNewWorkspaceDraft(page, DRAFT);
+
+      await selectNewWorkspaceProject(page, {
+        projectKey: secondProject.projectId,
+        projectDisplayName: secondProject.projectDisplayName,
+      });
+
+      await expectNewWorkspaceDraft(page, DRAFT);
+    } finally {
+      await secondProject.cleanup();
+      await firstProject.cleanup();
+    }
+  });
+
+  test("keeps the draft when the host changes", async ({ page }) => {
+    const project: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "new-workspace-draft-host-",
+    });
+    const secondaryServerId = "new-workspace-draft-secondary-host";
+
+    try {
+      await seedSavedSettingsHosts(page, [
+        {
+          serverId: getServerId(),
+          label: "Primary host",
+          endpoint: `127.0.0.1:${getE2EDaemonPort()}`,
+        },
+        {
+          serverId: secondaryServerId,
+          label: "Secondary host",
+          endpoint: "127.0.0.1:9",
+        },
+      ]);
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await openGlobalNewWorkspaceComposer(page);
+
+      await fillNewWorkspaceDraft(page, DRAFT);
+      await selectNewWorkspaceHost(page, "Secondary host");
+
+      await expectNewWorkspaceDraft(page, DRAFT);
+    } finally {
+      await project.cleanup();
+    }
+  });
+});

packages/app/e2e/new-workspace.spec.ts

@@ -35,6 +35,9 @@ import {
   hasGithubAuth,
 } from "./helpers/github-fixtures";
 import { getServerId } from "./helpers/server-id";
+import { getE2EDaemonPort } from "./helpers/daemon-port";
+import { chooseAddProjectMethod, expectAddProjectPage } from "./helpers/add-project-flow";
+import { seedSavedSettingsHosts } from "./helpers/settings";
 import {
   expectSidebarWorkspaceSelected,
   expectWorkspaceHeader,
@@ -209,6 +212,54 @@ test.describe("New workspace flow", () => {
     await client?.close().catch(() => undefined);
   });
 
+  test("adds a project from the selected empty host", async ({ page }) => {
+    const repo = await createTempGitRepo("new-workspace-project-picker-");
+    const primaryServerId = getServerId();
+    const emptyServerId = "empty-new-workspace-host";
+
+    try {
+      const openedProject = await openProjectViaDaemon(client, repo.path);
+      localWorkspaceIds.add(openedProject.workspaceId);
+      await seedSavedSettingsHosts(page, [
+        {
+          serverId: primaryServerId,
+          label: "Primary host",
+          endpoint: `127.0.0.1:${getE2EDaemonPort()}`,
+        },
+        {
+          serverId: emptyServerId,
+          label: "Empty host",
+          endpoint: "127.0.0.1:9",
+        },
+      ]);
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await openGlobalNewWorkspaceComposer(page);
+
+      const projectTrigger = page.getByTestId("new-workspace-project-picker-trigger");
+      await projectTrigger.click();
+      await page.getByPlaceholder("Search projects").fill("no matching project");
+      await expect(page.getByTestId("new-workspace-project-picker-add-project")).toBeVisible();
+      await page.keyboard.press("Escape");
+
+      await page.getByTestId("host-picker-trigger").click();
+      await page.getByTestId(`new-workspace-host-picker-option-${emptyServerId}`).click();
+      await expect(projectTrigger).toContainText("Choose project");
+      await projectTrigger.click();
+
+      const addProject = page.getByTestId("new-workspace-project-picker-add-project");
+      await expect(addProject).toContainText("Add project");
+      await expect(addProject).toContainText(/(?:⌘|Ctrl\+)O/);
+      await addProject.click();
+
+      await expectAddProjectPage(page, "method");
+      await chooseAddProjectMethod(page, "directory-search");
+    } finally {
+      await repo.cleanup();
+    }
+  });
+
   test("sidebar workspace navigation updates URL and header", async ({ page }) => {
     const serverId = getServerId();
 

packages/app/e2e/project-picker-desktop.spec.ts

@@ -2,7 +2,9 @@ import { test, expect } from "./fixtures";
 import { gotoAppShell } from "./helpers/app";
 import { injectDesktopBridge, waitForDirectoryDialog } from "./helpers/desktop-updates";
 import { expectOpenedProject } from "./helpers/project-picker-ui";
+import { expectNewWorkspaceForAddedProject } from "./helpers/add-project-flow";
 import { getServerId } from "./helpers/server-id";
+import { connectSeedClient } from "./helpers/seed-client";
 
 test.skip(process.env.E2E_DESKTOP_RUNTIME !== "1", "requires Metro's Electron platform overlay");
 
@@ -18,15 +20,27 @@ test("Browse opens the folder selected by the desktop dialog", async ({
   await gotoAppShell(page);
 
   await page.getByTestId("sidebar-add-project").click();
-  const browse = page.getByRole("button", { name: "Browse…" });
+  const browse = page.getByRole("button", { name: /^Browse/ });
   await expect(browse).toBeVisible({ timeout: 30_000 });
   await browse.click();
 
   const projectId = await expectOpenedProject(page, projectPickerFixture.projectName);
   projectPickerFixture.rememberProjectId(projectId);
+  await expectNewWorkspaceForAddedProject(page, {
+    serverId: getServerId(),
+    projectId,
+    projectName: projectPickerFixture.projectName,
+    projectPath: projectPickerFixture.projectPath,
+  });
+  const client = await connectSeedClient();
+  try {
+    expect((await client.fetchWorkspaces({ filter: { projectId } })).entries).toEqual([]);
+  } finally {
+    await client.close();
+  }
 });
 
-test("Browse owns Enter without opening the active typed path", async ({
+test("canceling Browse returns to the Add Project methods", async ({
   page,
   projectPickerFixture,
 }) => {
@@ -38,20 +52,17 @@ test("Browse owns Enter without opening the active typed path", async ({
   await gotoAppShell(page);
 
   await page.getByTestId("sidebar-add-project").click();
-  const input = page.getByTestId("project-picker-input");
-  await expect(input).toBeVisible({ timeout: 30_000 });
-  await input.fill(projectPickerFixture.projectPath);
-
-  const browse = page.getByRole("button", { name: "Browse…" });
+  const browse = page.getByRole("button", { name: /^Browse/ });
   await expect(browse).toBeVisible({ timeout: 30_000 });
-  await browse.press("Enter");
+  await browse.click();
 
   const dialogOptions = await waitForDirectoryDialog(page);
   expect(dialogOptions).toEqual({
+    createDirectory: true,
     directory: true,
     multiple: false,
   });
-  await expect(input).toBeVisible();
+  await expect(browse).toBeVisible();
   await expect(
     page
       .locator('[data-testid^="sidebar-project-row-"]')

packages/app/e2e/projects-settings.spec.ts

@@ -31,6 +31,11 @@ import {
   unblockPaseoConfigWrites,
 } from "./helpers/project-settings";
 import { gotoAppShell } from "./helpers/app";
+import {
+  addProjectFlowInput,
+  chooseAddProjectMethod,
+  openAddProjectFlow,
+} from "./helpers/add-project-flow";
 import { createTempGitRepo } from "./helpers/workspace";
 
 const updatedSetup = ["npm install", "npm run build"];
@@ -134,10 +139,10 @@ async function readProjectConfigFile(project: ProjectsSettingsProject): Promise<
 }
 
 async function addProjectFromSidebar(page: Page, projectPath: string): Promise<string> {
-  await page.getByTestId("sidebar-add-project").click();
+  await openAddProjectFlow(page);
+  await chooseAddProjectMethod(page, "directory-search");
 
-  const input = page.getByTestId("project-picker-input");
-  await expect(input).toBeVisible({ timeout: 30_000 });
+  const input = addProjectFlowInput(page);
   await input.fill(projectPath);
   await page.keyboard.press("Enter");
 

packages/app/e2e/provider-subagents.real.spec.ts

@@ -0,0 +1,98 @@
+import { mkdtempSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test, expect } from "./fixtures";
+import {
+  cleanupRewindFlow,
+  launchAgent,
+  sendMessage,
+  type AgentHandle,
+  type RewindFlowProvider,
+} from "./helpers/rewind-flow";
+import { openSubagentsTrack } from "./helpers/subagents";
+
+interface ProviderSubagentCase {
+  provider: RewindFlowProvider;
+  sentinel: string;
+  expectedName: string;
+  prompt: string;
+  providerConfig?: Parameters<typeof launchAgent>[0]["providerConfig"];
+}
+
+const cases: ProviderSubagentCase[] = [
+  {
+    provider: "claude",
+    sentinel: "CLAUDE_CHILD_SENTINEL",
+    expectedName: "sentinel_child",
+    providerConfig: { model: "opus" },
+    prompt:
+      'Use Claude Code\'s native Task tool exactly once. Set its subagent_type input to "Explore" and its name input to "sentinel_child". Ask it to reply with exactly CLAUDE_CHILD_SENTINEL and do nothing else. Wait for it, then reply ROOT_DONE. Do not use Paseo tools.',
+  },
+  {
+    provider: "codex",
+    sentinel: "CODEX_CHILD_SENTINEL",
+    expectedName: "Sentinel child",
+    providerConfig: { extra: { codex: { features: { multi_agent_v2: true } } } },
+    prompt:
+      'Use the native collaboration.spawn_agent tool exactly once with task_name "sentinel_child" and fork_turns "none". Ask it to reply with exactly CODEX_CHILD_SENTINEL and do nothing else. Wait for it with collaboration.wait_agent, then reply ROOT_DONE. Do not use Paseo tools.',
+  },
+  {
+    provider: "opencode",
+    sentinel: "OPENCODE_CHILD_SENTINEL",
+    expectedName: "Explore",
+    prompt:
+      "Use the task tool exactly once with the explore subagent. Ask it to reply with exactly OPENCODE_CHILD_SENTINEL and do nothing else. Wait for it, then reply ROOT_DONE.",
+  },
+];
+
+test.describe("real provider subagent timelines", () => {
+  test.setTimeout(600_000);
+
+  for (const scenario of cases) {
+    test(`${scenario.provider} exposes native child output from the subagent track`, async ({
+      page,
+    }) => {
+      const cwd = realpathSync(
+        mkdtempSync(path.join(tmpdir(), `paseo-provider-subagent-${scenario.provider}-`)),
+      );
+      let handle: AgentHandle | undefined;
+
+      try {
+        handle = await launchAgent({
+          page,
+          provider: scenario.provider,
+          cwd,
+          mode: "full-access",
+          providerConfig: scenario.providerConfig,
+        });
+        await sendMessage(handle, scenario.prompt);
+        await openSubagentsTrack(page);
+
+        const rows = page.locator('[data-testid^="subagents-track-row-"]');
+        await expect(rows).toHaveCount(1, { timeout: 60_000 });
+        await expect(rows.first()).toContainText(scenario.expectedName);
+        await rows.first().click();
+
+        const panel = page.getByTestId("provider-subagent-panel");
+        await expect(panel).toBeVisible({ timeout: 30_000 });
+        await expect(
+          panel.getByTestId("assistant-message").filter({ hasText: scenario.sentinel }),
+        ).toBeVisible({ timeout: 30_000 });
+        await expect(
+          panel.getByText("Start chatting with this agent...", { exact: true }),
+        ).toHaveCount(0);
+
+        await page.getByTestId(`workspace-tab-agent_${handle.agentId}`).first().click();
+        await expect(
+          page.getByTestId("assistant-message").filter({ hasText: "ROOT_DONE" }).last(),
+        ).toBeVisible({ timeout: 60_000 });
+        const archiveFinished = page.getByTestId("subagents-track-archive-finished");
+        await expect(archiveFinished).toBeVisible({ timeout: 30_000 });
+        await archiveFinished.click();
+        await expect(rows).toHaveCount(0, { timeout: 30_000 });
+      } finally {
+        await cleanupRewindFlow({ handle, cwd });
+      }
+    });
+  }
+});

packages/app/e2e/sidebar-help.spec.ts

@@ -0,0 +1,105 @@
+import { expect, test, type Page } from "./fixtures";
+import { gotoAppShell, openSettings } from "./helpers/app";
+import { openSettingsSection } from "./helpers/settings";
+
+const DISCORD_DESTINATION =
+  /^https:\/\/(?:discord\.gg\/jz8T2uahpH|discord\.com\/invite\/jz8T2uahpH)(?:[/?#]|$)/;
+const GITHUB_ISSUE_DESTINATION =
+  /^https:\/\/github\.com\/(?:getpaseo\/paseo\/issues\/new(?:\/choose)?(?:[/?#]|$)|login\?return_to=https%3A%2F%2Fgithub\.com%2Fgetpaseo%2Fpaseo%2Fissues%2Fnew$)/;
+const CHANGELOG_DESTINATION = /^https:\/\/paseo\.sh\/changelog(?:[/?#]|$)/;
+const APP_VERSION = /^Paseo v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+async function openHelpMenu(page: Page): Promise<void> {
+  await page.getByTestId("sidebar-help").click();
+  await expect(page.getByTestId("sidebar-help-menu")).toBeVisible();
+}
+
+async function expectDiagnosticReport(page: Page): Promise<void> {
+  const sheet = page.getByTestId("app-diagnostic-sheet");
+  await expect(sheet).toBeVisible();
+  await expect(sheet.getByRole("button", { name: "Copy diagnostic" })).toBeEnabled();
+  await expect(page.getByText(/App version:/).first()).toBeVisible();
+}
+
+async function closeSheet(page: Page, testID: string): Promise<void> {
+  const sheet = page.getByTestId(testID);
+  await sheet.getByLabel("Close").click();
+  await expect(sheet).not.toBeVisible();
+}
+
+async function expectExternalPage(
+  page: Page,
+  actionTestID: string,
+  expectedUrl: RegExp,
+): Promise<void> {
+  const popupPromise = page.waitForEvent("popup");
+  await page.getByTestId(actionTestID).click();
+  const popup = await popupPromise;
+  expect(popup.url()).toMatch(expectedUrl);
+  await popup.close();
+}
+
+test("opens troubleshooting tools from the sidebar help menu", async ({ page }) => {
+  await gotoAppShell(page);
+  await expect(page.getByTestId("sidebar-help")).toBeVisible();
+
+  await openHelpMenu(page);
+  const triggerBox = await page.getByTestId("sidebar-help").evaluate((element) => {
+    const { y, height } = element.getBoundingClientRect();
+    return { y, height };
+  });
+  const menuBox = await page.getByTestId("sidebar-help-menu").evaluate((element) => {
+    const { y, height } = element.getBoundingClientRect();
+    return { y, height };
+  });
+  expect(menuBox.y + menuBox.height).toBeLessThanOrEqual(triggerBox.y);
+  await expect(page.getByText("Help", { exact: true })).toBeVisible();
+  await expect(page.getByText("Report an issue", { exact: true })).toBeVisible();
+  await expect(page.getByText("What's new", { exact: true })).toBeVisible();
+  await expect(page.getByTestId("sidebar-help-version")).toHaveText(APP_VERSION);
+
+  await page.getByTestId("sidebar-help-diagnostics").click();
+  await expectDiagnosticReport(page);
+  await closeSheet(page, "app-diagnostic-sheet");
+
+  await openHelpMenu(page);
+  await page.getByTestId("sidebar-help-shortcuts").click();
+  await expect(page.getByTestId("keyboard-shortcuts-dialog")).toBeVisible();
+  await closeSheet(page, "keyboard-shortcuts-dialog");
+});
+
+test("opens support and release destinations", async ({ page }) => {
+  await gotoAppShell(page);
+
+  await openHelpMenu(page);
+  await expectExternalPage(page, "sidebar-help-discord", DISCORD_DESTINATION);
+
+  await openHelpMenu(page);
+  await expectExternalPage(page, "sidebar-help-github", GITHUB_ISSUE_DESTINATION);
+
+  await openHelpMenu(page);
+  await expectExternalPage(page, "sidebar-help-changelog", CHANGELOG_DESTINATION);
+});
+
+test("keeps diagnostics available from Settings after globalizing the sheet", async ({ page }) => {
+  await gotoAppShell(page);
+  await openSettings(page);
+  await openSettingsSection(page, "diagnostics");
+
+  await page.getByRole("button", { name: "Run", exact: true }).click();
+  await expectDiagnosticReport(page);
+});
+
+test.describe("compact sidebar help", () => {
+  test.use({ viewport: { width: 390, height: 844 }, isMobile: true, hasTouch: true });
+
+  test("offers diagnostics without advertising disabled keyboard shortcuts", async ({ page }) => {
+    await gotoAppShell(page);
+    await page.getByRole("button", { name: "Open menu", exact: true }).click();
+
+    await openHelpMenu(page);
+    await expect(page.getByTestId("sidebar-help-shortcuts")).toHaveCount(0);
+    await page.getByTestId("sidebar-help-diagnostics").click();
+    await expectDiagnosticReport(page);
+  });
+});

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

@@ -165,3 +165,132 @@ test.describe("Mobile sidebar panelState transition", () => {
     await expectMobileAgentSidebarHidden(page);
   });
 });
+
+test.describe("Half-screen desktop layout", () => {
+  test.use({ viewport: { width: 751, height: 982 } });
+
+  test("keeps the sidebar scroll position across close and reopen", async ({ page }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "sidebar-retained-scroll-" });
+
+    try {
+      let lastWorkspaceId = workspace.workspaceId;
+      for (let index = 0; index < 24; index += 1) {
+        const created = await workspace.client.createWorkspace({
+          source: {
+            kind: "directory",
+            path: workspace.repoPath,
+            projectId: workspace.projectId,
+          },
+          title: `Retained sidebar ${index + 1}`,
+        });
+        if (!created.workspace) {
+          throw new Error(created.error ?? "Failed to fill the retained sidebar");
+        }
+        lastWorkspaceId = created.workspace.id;
+      }
+
+      await gotoAppShell(page);
+      await waitForSidebarWorkspace(page, lastWorkspaceId);
+
+      const sidebarScroll = page.getByTestId("sidebar-project-workspace-list-scroll");
+      const scrollTop = await sidebarScroll.evaluate((element) => {
+        element.scrollTop = 160;
+        return element.scrollTop;
+      });
+      expect(scrollTop).toBe(160);
+
+      await page.getByTestId("menu-button").click();
+      await expect(page.getByTestId("sidebar-global-new-workspace")).not.toBeVisible();
+
+      await page.getByTestId("menu-button").click();
+      await expect(page.getByTestId("sidebar-global-new-workspace")).toBeVisible();
+      await expect(sidebarScroll).toHaveJSProperty("scrollTop", scrollTop);
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+
+  test("keeps the pinned sidebar at half of a 14-inch Mac display", async ({ page }) => {
+    await gotoAppShell(page);
+    await expect(page.getByTestId("sidebar-global-new-workspace")).toBeVisible();
+    await expect(page.getByTestId("agent-list-backdrop")).not.toBeVisible();
+  });
+
+  test("keeps the left toggle center-owned without left window controls", async ({ page }) => {
+    await gotoAppShell(page);
+
+    const openToggle = page.getByTestId("menu-button");
+    const openBounds = await openToggle.locator("svg").first().boundingBox();
+    expect(openBounds).not.toBeNull();
+    expect(openBounds?.x).toBeGreaterThan(12);
+
+    await openToggle.click();
+    await expect(page.getByTestId("sidebar-global-new-workspace")).not.toBeVisible();
+
+    const closedToggle = page.getByTestId("menu-button");
+    const closedBounds = await closedToggle.locator("svg").first().boundingBox();
+    expect(closedBounds).not.toBeNull();
+    expect(closedBounds?.x).toBeCloseTo(12, 0);
+    expect(closedBounds?.y).toBe(openBounds?.y);
+  });
+
+  test("yields app navigation to the settings split", async ({ page }) => {
+    await gotoAppShell(page);
+    await page.getByTestId("sidebar-settings").click();
+
+    await expect(page.getByTestId("settings-sidebar")).toBeVisible();
+    await expect(page.getByTestId("settings-detail-pane")).toBeVisible();
+    await expect(page.getByTestId("sidebar-settings")).not.toBeVisible();
+  });
+
+  test("yields app navigation to the Explorer", async ({ page }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "sidebar-half-screen-explorer-" });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarProject(page, path.basename(workspace.repoPath));
+      await openWorkspaceFromSidebar(page, workspace.workspaceId);
+
+      await page.getByTestId("workspace-explorer-toggle").first().click();
+      await expect(
+        page.getByTestId("explorer-tab-files").filter({ visible: true }).first(),
+      ).toBeVisible();
+      await expect(page.getByTestId("workspace-explorer-toggle").first()).toBeVisible();
+      await expect(page.getByTestId("explorer-close")).toBeVisible();
+      await expect(page.getByTestId("sidebar-global-new-workspace")).not.toBeVisible();
+
+      const centerBounds = await page.getByTestId("workspace-tabs-row").first().boundingBox();
+      const headerGlyphBounds = await page
+        .getByTestId("menu-button")
+        .locator("svg")
+        .first()
+        .boundingBox();
+      const tabGlyphBounds = await page
+        .locator('[data-testid^="workspace-tab-"]')
+        .first()
+        .locator("svg")
+        .first()
+        .boundingBox();
+      expect(centerBounds).not.toBeNull();
+      expect(headerGlyphBounds).not.toBeNull();
+      expect(tabGlyphBounds).not.toBeNull();
+      expect((headerGlyphBounds?.x ?? 0) - (centerBounds?.x ?? 0)).toBeCloseTo(
+        (tabGlyphBounds?.x ?? 0) - (centerBounds?.x ?? 0),
+        0,
+      );
+
+      await expect
+        .poll(
+          async () =>
+            (await page.getByTestId("workspace-tabs-row").first().boundingBox())?.width ?? 0,
+        )
+        .toBeGreaterThanOrEqual(400);
+
+      await page.getByTestId("explorer-close").click();
+      await expect(page.getByTestId("explorer-tab-files")).not.toBeVisible();
+      await expect(page.getByTestId("workspace-explorer-toggle").first()).toBeVisible();
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+});

packages/app/e2e/workspace-archive-shortcut.spec.ts

@@ -0,0 +1,26 @@
+import { existsSync } from "node:fs";
+import { expect, test } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { seedWorkspace } from "./helpers/seed-client";
+import { expectWorkspaceAbsentFromSidebar, selectWorkspaceInSidebar } from "./helpers/sidebar";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+
+test.describe("Workspace archive shortcut", () => {
+  test("archives the selected workspace without removing its local checkout", async ({ page }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "archive-shortcut-" });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await selectWorkspaceInSidebar(page, workspace.workspaceId);
+
+      const modifier = process.platform === "darwin" ? "Meta" : "Control";
+      await page.keyboard.press(`${modifier}+Shift+Backspace`);
+
+      await expectWorkspaceAbsentFromSidebar(page, workspace.workspaceId);
+      expect(existsSync(workspace.repoPath)).toBe(true);
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+});

packages/app/e2e/workspace-model-regressions.spec.ts

@@ -1,4 +1,5 @@
 import { test, expect } from "./fixtures";
+import { expectWorkspaceTabVisible } from "./helpers/archive-tab";
 import { expectComposerEditable, expectComposerVisible, submitMessage } from "./helpers/composer";
 import { clickNewChat, gotoWorkspace } from "./helpers/launcher";
 import {
@@ -12,6 +13,11 @@ import {
 } from "./helpers/new-workspace";
 import { getServerId } from "./helpers/server-id";
 import { seedWorkspace, type SeededWorkspace } from "./helpers/seed-client";
+import {
+  expectSubagentRowVisible,
+  openSubagentsTrack,
+  seedParentWithCrossWorkspaceSubagent,
+} from "./helpers/subagents";
 import { expectWorkspaceHeader, waitForSidebarHydration } from "./helpers/workspace-ui";
 import { getVisibleWorkspaceAgentTabIds } from "./helpers/workspace-tabs";
 
@@ -527,4 +533,39 @@ test.describe("Workspace model regressions", () => {
       await seeded.cleanup();
     }
   });
+
+  test("cross-workspace subagent opens in its workspace and keeps its parent relationship", async ({
+    page,
+  }) => {
+    const serverId = getServerId();
+    const seeded = await seedWorkspace({ repoPrefix: "workspace-cross-subagent-" });
+
+    try {
+      const agents = await seedParentWithCrossWorkspaceSubagent(seeded, {
+        parentTitle: "Parent agent",
+        childTitle: "Cross-workspace subagent",
+      });
+
+      await gotoWorkspace(page, agents.child.workspaceId);
+      await waitForSidebarHydration(page);
+      await expectWorkspaceTabVisible(page, agents.child.id);
+
+      const parentRowTestId = `sidebar-workspace-row-${serverId}:${agents.parent.workspaceId}`;
+      const childRowTestId = `sidebar-workspace-row-${serverId}:${agents.child.workspaceId}`;
+      await expectWorkspaceRowHasOnlyIndicator(page, {
+        rowTestId: childRowTestId,
+        indicator: "running",
+      });
+      await expectWorkspaceRowHasOnlyIndicator(page, {
+        rowTestId: parentRowTestId,
+        indicator: "done",
+      });
+
+      await gotoWorkspace(page, agents.parent.workspaceId);
+      await openSubagentsTrack(page);
+      await expectSubagentRowVisible(page, agents.child.id);
+    } finally {
+      await seeded.cleanup();
+    }
+  });
 });

packages/app/e2e/worktree-archive-risk-warning.spec.ts

@@ -76,7 +76,7 @@ async function clickArchiveAndAnswerWarning(
   return warning;
 }
 
-test.describe("Worktree archive risk warning", () => {
+test.describe("Workspace archive risk warning for worktree backing", () => {
   let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
   let tempRepo: { path: string; cleanup: () => Promise<void> };
   const createdWorktreeDirectories = new Set<string>();
@@ -97,7 +97,7 @@ test.describe("Worktree archive risk warning", () => {
     await tempRepo?.cleanup().catch(() => undefined);
   });
 
-  test("a risky worktree archive is gated by confirmation and removes the directory after acceptance", async ({
+  test("a risky workspace archive is gated by confirmation and removes its worktree after acceptance", async ({
     page,
   }) => {
     const serverId = getServerId();

packages/app/e2e/worktree-archive.spec.ts

@@ -8,11 +8,11 @@ import {
   openProjectViaDaemon,
 } from "./helpers/new-workspace";
 import { getServerId } from "./helpers/server-id";
-import { archiveWorktreeFromSidebar, expectWorkspaceAbsentFromSidebar } from "./helpers/sidebar";
+import { archiveWorkspaceFromSidebar, expectWorkspaceAbsentFromSidebar } from "./helpers/sidebar";
 import { createTempGitRepo } from "./helpers/workspace";
 import { waitForSidebarHydration, waitForWorkspaceInSidebar } from "./helpers/workspace-ui";
 
-test.describe("Worktree archive", () => {
+test.describe("Workspace archive with worktree backing", () => {
   let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
   let tempRepo: { path: string; cleanup: () => Promise<void> };
   const createdWorktreeDirectories = new Set<string>();
@@ -33,9 +33,7 @@ test.describe("Worktree archive", () => {
     await tempRepo?.cleanup().catch(() => undefined);
   });
 
-  test("archiving a worktree from the sidebar removes its row and worktree directory", async ({
-    page,
-  }) => {
+  test("archiving the final workspace removes its managed worktree directory", async ({ page }) => {
     const serverId = getServerId();
     await openProjectViaDaemon(client, tempRepo.path);
     const worktree = await createWorktreeViaDaemon(client, {
@@ -49,11 +47,51 @@ test.describe("Worktree archive", () => {
     await waitForSidebarHydration(page);
     await waitForWorkspaceInSidebar(page, { serverId, workspaceId: worktree.workspaceId });
 
-    await archiveWorktreeFromSidebar(page, worktree.workspaceId);
+    await archiveWorkspaceFromSidebar(page, worktree.workspaceId);
 
     await expectWorkspaceAbsentFromSidebar(page, worktree.workspaceId);
     await expect
       .poll(() => existsSync(worktree.workspaceDirectory), { timeout: 30_000 })
       .toBe(false);
   });
+
+  test("a managed worktree remains until its last workspace is archived", async ({ page }) => {
+    const serverId = getServerId();
+    await openProjectViaDaemon(client, tempRepo.path);
+    const first = await createWorktreeViaDaemon(client, {
+      cwd: tempRepo.path,
+      slug: `shared-archive-${Date.now()}`,
+    });
+    createdWorktreeDirectories.add(first.workspaceDirectory);
+
+    const siblingPayload = await client.createWorkspace({
+      source: {
+        kind: "directory",
+        path: first.workspaceDirectory,
+      },
+      title: "Second workspace",
+    });
+    if (!siblingPayload.workspace) {
+      throw new Error(siblingPayload.error ?? "Failed to create a workspace on the worktree");
+    }
+    const sibling = siblingPayload.workspace;
+    expect(sibling.workspaceKind).toBe("worktree");
+    expect(sibling.workspaceDirectory).toBe(first.workspaceDirectory);
+
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await waitForWorkspaceInSidebar(page, { serverId, workspaceId: first.workspaceId });
+    await waitForWorkspaceInSidebar(page, { serverId, workspaceId: sibling.id });
+
+    await archiveWorkspaceFromSidebar(page, first.workspaceId);
+
+    await expectWorkspaceAbsentFromSidebar(page, first.workspaceId);
+    expect(existsSync(first.workspaceDirectory)).toBe(true);
+    await waitForWorkspaceInSidebar(page, { serverId, workspaceId: sibling.id });
+
+    await archiveWorkspaceFromSidebar(page, sibling.id);
+
+    await expectWorkspaceAbsentFromSidebar(page, sibling.id);
+    await expect.poll(() => existsSync(first.workspaceDirectory), { timeout: 30_000 }).toBe(false);
+  });
 });

packages/app/eas.json

@@ -1,7 +1,7 @@
 {
   "cli": {
     "version": ">= 14.0.0",
-    "appVersionSource": "remote"
+    "appVersionSource": "local"
   },
   "build": {
     "development": {
@@ -19,9 +19,6 @@
       "channel": "production",
       "env": {
         "APP_VARIANT": "production"
-      },
-      "android": {
-        "autoIncrement": "versionCode"
       }
     },
     "production-apk": {

packages/app/metro.config.cjs

@@ -7,6 +7,11 @@ const projectRoot = __dirname;
 const appNodeModulesRoot = path.resolve(projectRoot, "node_modules");
 const appSrcRoot = path.resolve(projectRoot, "src");
 const relaySrcRoot = path.resolve(projectRoot, "../relay/src");
+const isFdroidBuild = process.env.PASEO_FDROID_BUILD === "1";
+const fdroidModuleOverrides = {
+  "expo-camera": path.resolve(appSrcRoot, "fdroid/expo-camera.tsx"),
+  "expo-notifications": path.resolve(appSrcRoot, "fdroid/expo-notifications.ts"),
+};
 const customWebPlatform = (process.env.PASEO_WEB_PLATFORM ?? "")
   .trim()
   .replace(/^\./, "")
@@ -72,6 +77,10 @@ function resolveWithCustomWebOverlay(context, moduleName, platform) {
 }
 
 config.resolver.resolveRequest = (context, moduleName, platform) => {
+  if (isFdroidBuild && platform === "android" && fdroidModuleOverrides[moduleName]) {
+    return resolveWithCustomWebOverlay(context, fdroidModuleOverrides[moduleName], platform);
+  }
+
   const origin = context.originModulePath;
   if (origin && origin.startsWith(relaySrcRoot) && moduleName.endsWith(".js")) {
     const tsModuleName = moduleName.replace(/\.js$/, ".ts");

packages/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/app",
-  "version": "0.1.105",
+  "version": "0.1.110",
   "private": true,
   "main": "index.ts",
   "scripts": {
@@ -128,6 +128,7 @@
     "eas-cli": "^16.24.1",
     "eslint": "^9.25.0",
     "eslint-config-expo": "~10.0.0",
+    "expo-gradle-jvmargs": "^1.1.2",
     "jsdom": "^20.0.3",
     "material-icon-theme": "^5.32.0",
     "playwright": "^1.56.1",

packages/app/plugins/with-fdroid-autolinking.js

@@ -0,0 +1,85 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { withAppBuildGradle, withDangerousMod, withSettingsGradle } = require("expo/config-plugins");
+
+const EXCLUDED_ANDROID_MODULES = [
+  "expo-camera",
+  "expo-notifications",
+  "expo-dev-client",
+  "expo-dev-launcher",
+  "expo-dev-menu",
+  "expo-dev-menu-interface",
+];
+
+function withFdroidAutolinking(config) {
+  config = withDangerousMod(config, [
+    "android",
+    async (modConfig) => {
+      const packageJsonPath = path.join(modConfig.modRequest.projectRoot, "package.json");
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+      const expo = packageJson.expo ?? {};
+      const autolinking = expo.autolinking ?? {};
+      const android = autolinking.android ?? {};
+      const fdroidPackageJson = {
+        ...packageJson,
+        expo: {
+          ...expo,
+          autolinking: {
+            ...autolinking,
+            android: {
+              ...android,
+              buildFromSource: [".*"],
+              exclude: EXCLUDED_ANDROID_MODULES,
+            },
+          },
+        },
+      };
+      const overlayRoot = path.join(modConfig.modRequest.platformProjectRoot, "fdroid-autolinking");
+
+      await fs.mkdir(overlayRoot, { recursive: true });
+      await fs.writeFile(
+        path.join(overlayRoot, "package.json"),
+        `${JSON.stringify(fdroidPackageJson, null, 2)}\n`,
+      );
+      return modConfig;
+    },
+  ]);
+
+  config = withSettingsGradle(config, (modConfig) => {
+    const fdroidProjectRoot =
+      'expoAutolinking.projectRoot = new File(rootDir, "fdroid-autolinking")';
+    if (modConfig.modResults.contents.includes(fdroidProjectRoot)) {
+      return modConfig;
+    }
+
+    const useExpoModules = "expoAutolinking.useExpoModules()";
+    if (!modConfig.modResults.contents.includes(useExpoModules)) {
+      throw new Error("Could not configure F-Droid Expo autolinking in settings.gradle");
+    }
+
+    modConfig.modResults.contents = modConfig.modResults.contents.replace(
+      useExpoModules,
+      `${fdroidProjectRoot}\n${useExpoModules}`,
+    );
+    return modConfig;
+  });
+
+  return withAppBuildGradle(config, (modConfig) => {
+    if (modConfig.modResults.contents.includes("dependenciesInfo {")) {
+      return modConfig;
+    }
+
+    const androidBlock = "android {";
+    if (!modConfig.modResults.contents.includes(androidBlock)) {
+      throw new Error("Could not disable F-Droid dependency metadata in app/build.gradle");
+    }
+
+    modConfig.modResults.contents = modConfig.modResults.contents.replace(
+      androidBlock,
+      `${androidBlock}\n    dependenciesInfo {\n        includeInApk = false\n        includeInBundle = false\n    }`,
+    );
+    return modConfig;
+  });
+}
+
+module.exports = withFdroidAutolinking;

packages/app/src/add-project-flow/model.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it } from "vitest";
+import {
+  backAddProjectPage,
+  chooseAddProjectHost,
+  currentAddProjectPage,
+  moveAddProjectActiveIndex,
+  moveAddProjectSelection,
+  openAddProjectFlow,
+  openDirectorySearchPage,
+  openGithubLocationPage,
+  openNewDirectoryNamePage,
+  openNewDirectoryParentPage,
+  setAddProjectActiveIndex,
+  setAddProjectPageInput,
+  setNewDirectoryName,
+  type AddProjectHost,
+} from "./model";
+import {
+  buildAddProjectMethods,
+  buildCloneLocationOptions,
+  buildManualGithubRepositoryChoices,
+} from "./options";
+
+const HOST: AddProjectHost = {
+  serverId: "host-1",
+  label: "Local",
+  canAddProject: true,
+  canBrowse: true,
+  canCloneGithubRepositories: true,
+  canSearchGithubRepositories: true,
+  canCreateDirectory: true,
+};
+
+describe("Add Project navigation", () => {
+  it("skips a single connected host without adding it to history", () => {
+    const state = openAddProjectFlow({ hosts: [HOST] });
+
+    expect(currentAddProjectPage(state)).toEqual({
+      kind: "method",
+      hostId: "host-1",
+      query: "",
+      activeIndex: 0,
+      error: null,
+    });
+    expect(backAddProjectPage(state)).toBeNull();
+  });
+
+  it("restores page input and selection after Back", () => {
+    const secondHost = { ...HOST, serverId: "host-2", label: "Remote" };
+    let state = openAddProjectFlow({ hosts: [HOST, secondHost] });
+    state = setAddProjectPageInput(state, "rem");
+    state = setAddProjectActiveIndex(state, 1);
+    state = chooseAddProjectHost(state, secondHost.serverId);
+    state = openDirectorySearchPage(state, secondHost.serverId);
+
+    state = backAddProjectPage(state) ?? state;
+    state = backAddProjectPage(state) ?? state;
+
+    expect(currentAddProjectPage(state)).toEqual({
+      kind: "host",
+      query: "rem",
+      activeIndex: 1,
+      error: null,
+    });
+  });
+
+  it("wraps keyboard selection in both directions", () => {
+    expect(moveAddProjectActiveIndex(2, 3, "next")).toBe(0);
+    expect(moveAddProjectActiveIndex(0, 3, "previous")).toBe(2);
+    expect(moveAddProjectSelection(0, [true, false, true], "next")).toBe(2);
+  });
+
+  it("restores a directory name after returning to and reselecting its parent", () => {
+    let state = openAddProjectFlow({ hosts: [HOST] });
+    state = openNewDirectoryParentPage(state, HOST.serverId);
+    state = openNewDirectoryNamePage(state, HOST.serverId, "~/dev");
+    state = setNewDirectoryName(state, "command-center");
+    state = backAddProjectPage(state) ?? state;
+    state = openNewDirectoryNamePage(state, HOST.serverId, "~/dev");
+
+    expect(currentAddProjectPage(state)).toMatchObject({
+      kind: "new-directory-name",
+      parentPath: "~/dev",
+      name: "command-center",
+    });
+  });
+
+  it("restores the GitHub destination query and active parent when reopening a repository", () => {
+    const repository = {
+      id: "repo-1",
+      nameWithOwner: "getpaseo/paseo",
+      cloneUrl: "git@github.com:getpaseo/paseo.git",
+      description: null,
+      visibility: "public",
+      updatedAt: null,
+    };
+    let state = openAddProjectFlow({ hosts: [HOST] });
+    state = openGithubLocationPage(state, HOST.serverId, repository);
+    state = setAddProjectPageInput(state, "~/dev");
+    state = setAddProjectActiveIndex(state, 2);
+    state = backAddProjectPage(state) ?? state;
+    state = openGithubLocationPage(state, HOST.serverId, repository);
+
+    expect(currentAddProjectPage(state)).toMatchObject({
+      kind: "github-location",
+      query: "~/dev",
+      activeIndex: 2,
+    });
+  });
+});
+
+describe("Add Project options", () => {
+  it("keeps host-upgrade methods discoverable while hiding local-only Browse", () => {
+    expect(
+      buildAddProjectMethods({
+        ...HOST,
+        canBrowse: false,
+        canCloneGithubRepositories: false,
+        canSearchGithubRepositories: false,
+        canCreateDirectory: false,
+      }),
+    ).toEqual([
+      {
+        id: "directory-search",
+        label: "Search for directory",
+        description: "Find a directory on Local",
+      },
+      {
+        id: "github",
+        label: "Clone from GitHub",
+        description: "Update this host to clone GitHub repositories",
+        disabled: true,
+      },
+      {
+        id: "new-directory",
+        label: "New directory",
+        description: "Update this host to create directories",
+        disabled: true,
+      },
+    ]);
+  });
+
+  it("offers manual URL and protocol-specific owner/repo clone choices", () => {
+    expect(buildManualGithubRepositoryChoices("git@github.com:getpaseo/paseo.git")).toEqual([
+      expect.objectContaining({
+        id: "manual:git@github.com:getpaseo/paseo.git",
+        nameWithOwner: "getpaseo/paseo",
+        cloneUrl: "git@github.com:getpaseo/paseo.git",
+      }),
+    ]);
+    expect(buildManualGithubRepositoryChoices("getpaseo/paseo")).toEqual([
+      expect.objectContaining({ cloneProtocol: "https", cloneUrl: "getpaseo/paseo" }),
+      expect.objectContaining({ cloneProtocol: "ssh", cloneUrl: "getpaseo/paseo" }),
+    ]);
+    expect(buildManualGithubRepositoryChoices("paseo")).toEqual([]);
+  });
+
+  it("shows final clone paths while retaining parent paths as values", () => {
+    expect(
+      buildCloneLocationOptions({
+        parents: ["~/dev", "~/workspace"],
+        repositoryName: "paseo",
+        existingPaths: ["~/workspace/paseo"],
+      }),
+    ).toEqual([
+      {
+        id: "~/dev",
+        path: "~/dev",
+        displayPath: "~/dev/paseo",
+        secondaryText: "Parent directory: ~/dev",
+        disabled: false,
+      },
+      {
+        id: "~/workspace",
+        path: "~/workspace",
+        displayPath: "~/workspace/paseo",
+        secondaryText: "Already exists",
+        disabled: true,
+      },
+    ]);
+  });
+
+  it("shows equivalent absolute-home and tilde destinations only once", () => {
+    expect(
+      buildCloneLocationOptions({
+        parents: ["/Users/moboudra/dev", "~/dev"],
+        repositoryName: "dotfiles",
+        existingPaths: [],
+      }),
+    ).toEqual([
+      {
+        id: "/Users/moboudra/dev",
+        path: "/Users/moboudra/dev",
+        displayPath: "/Users/moboudra/dev/dotfiles",
+        secondaryText: "Parent directory: /Users/moboudra/dev",
+        disabled: false,
+      },
+    ]);
+  });
+});

packages/app/src/add-project-flow/model.ts

@@ -0,0 +1,293 @@
+export interface AddProjectHost {
+  serverId: string;
+  label: string;
+  canAddProject: boolean;
+  canBrowse: boolean;
+  canCloneGithubRepositories: boolean;
+  canSearchGithubRepositories: boolean;
+  canCreateDirectory: boolean;
+}
+
+export interface GithubRepositoryChoice {
+  id: string;
+  nameWithOwner: string;
+  cloneUrl: string;
+  cloneProtocol?: "https" | "ssh";
+  description: string | null;
+  visibility: string | null;
+  updatedAt: string | null;
+}
+
+interface SearchPageState {
+  query: string;
+  activeIndex: number;
+  error: string | null;
+}
+
+export type AddProjectPage =
+  | ({ kind: "host" } & SearchPageState)
+  | ({ kind: "method"; hostId: string } & SearchPageState)
+  | ({ kind: "directory-search"; hostId: string; isSubmitting: boolean } & SearchPageState)
+  | ({ kind: "github-search"; hostId: string } & SearchPageState)
+  | ({
+      kind: "github-location";
+      hostId: string;
+      repository: GithubRepositoryChoice;
+      isSubmitting: boolean;
+    } & SearchPageState)
+  | ({ kind: "new-directory-parent"; hostId: string } & SearchPageState)
+  | {
+      kind: "new-directory-name";
+      hostId: string;
+      parentPath: string;
+      name: string;
+      activeIndex: number;
+      error: string | null;
+      isSubmitting: boolean;
+    };
+
+export interface AddProjectFlowState {
+  hosts: AddProjectHost[];
+  pages: AddProjectPage[];
+  newDirectoryNameDrafts: Record<string, string>;
+  githubLocationDrafts: Record<string, { query: string; activeIndex: number }>;
+}
+
+export interface OpenAddProjectFlowInput {
+  hosts: AddProjectHost[];
+  preferredHostId?: string;
+}
+
+function searchPage<TKind extends AddProjectPage["kind"]>(kind: TKind) {
+  return { kind, query: "", activeIndex: 0, error: null } as const;
+}
+
+function methodPage(hostId: string): AddProjectPage {
+  return { ...searchPage("method"), hostId };
+}
+
+export function openAddProjectFlow(input: OpenAddProjectFlowInput): AddProjectFlowState {
+  const preferredHost = input.preferredHostId
+    ? input.hosts.find((host) => host.serverId === input.preferredHostId)
+    : null;
+  const onlyHost = input.hosts.length === 1 ? input.hosts[0] : null;
+  const initialHost = preferredHost ?? onlyHost;
+
+  return {
+    hosts: input.hosts,
+    pages: initialHost ? [methodPage(initialHost.serverId)] : [searchPage("host")],
+    newDirectoryNameDrafts: {},
+    githubLocationDrafts: {},
+  };
+}
+
+export function applyAvailableAddProjectHosts(
+  state: AddProjectFlowState,
+  hosts: AddProjectHost[],
+  preferredHostId?: string,
+): AddProjectFlowState {
+  const current = currentAddProjectPage(state);
+  if (state.pages.length !== 1 || current.kind !== "host") {
+    return { ...state, hosts };
+  }
+  const preferredHost = preferredHostId
+    ? hosts.find((host) => host.serverId === preferredHostId)
+    : null;
+  const onlyHost = hosts.length === 1 ? hosts[0] : null;
+  const initialHost = preferredHost ?? onlyHost;
+  return {
+    ...state,
+    hosts,
+    pages: initialHost ? [methodPage(initialHost.serverId)] : state.pages,
+  };
+}
+
+export function currentAddProjectPage(state: AddProjectFlowState): AddProjectPage {
+  const page = state.pages[state.pages.length - 1];
+  if (!page) {
+    throw new Error("Add Project flow must always contain a page");
+  }
+  return page;
+}
+
+export function updateCurrentAddProjectPage(
+  state: AddProjectFlowState,
+  update: (page: AddProjectPage) => AddProjectPage,
+): AddProjectFlowState {
+  const index = state.pages.length - 1;
+  return {
+    ...state,
+    pages: state.pages.map((page, pageIndex) => (pageIndex === index ? update(page) : page)),
+  };
+}
+
+export function pushAddProjectPage(
+  state: AddProjectFlowState,
+  page: AddProjectPage,
+): AddProjectFlowState {
+  return { ...state, pages: [...state.pages, page] };
+}
+
+export function backAddProjectPage(state: AddProjectFlowState): AddProjectFlowState | null {
+  if (state.pages.length === 1) {
+    return null;
+  }
+  return { ...state, pages: state.pages.slice(0, -1) };
+}
+
+export function chooseAddProjectHost(
+  state: AddProjectFlowState,
+  hostId: string,
+): AddProjectFlowState {
+  return pushAddProjectPage(state, methodPage(hostId));
+}
+
+export function openDirectorySearchPage(
+  state: AddProjectFlowState,
+  hostId: string,
+): AddProjectFlowState {
+  return pushAddProjectPage(state, {
+    ...searchPage("directory-search"),
+    hostId,
+    isSubmitting: false,
+  });
+}
+
+export function openGithubSearchPage(
+  state: AddProjectFlowState,
+  hostId: string,
+): AddProjectFlowState {
+  return pushAddProjectPage(state, { ...searchPage("github-search"), hostId });
+}
+
+export function openGithubLocationPage(
+  state: AddProjectFlowState,
+  hostId: string,
+  repository: GithubRepositoryChoice,
+): AddProjectFlowState {
+  const draft = state.githubLocationDrafts[githubLocationDraftKey(hostId, repository.id)];
+  return pushAddProjectPage(state, {
+    kind: "github-location",
+    query: draft?.query ?? "",
+    activeIndex: draft?.activeIndex ?? 0,
+    error: null,
+    hostId,
+    repository,
+    isSubmitting: false,
+  });
+}
+
+export function openNewDirectoryParentPage(
+  state: AddProjectFlowState,
+  hostId: string,
+): AddProjectFlowState {
+  return pushAddProjectPage(state, { ...searchPage("new-directory-parent"), hostId });
+}
+
+export function openNewDirectoryNamePage(
+  state: AddProjectFlowState,
+  hostId: string,
+  parentPath: string,
+): AddProjectFlowState {
+  const draftKey = newDirectoryDraftKey(hostId, parentPath);
+  return pushAddProjectPage(state, {
+    kind: "new-directory-name",
+    hostId,
+    parentPath,
+    name: state.newDirectoryNameDrafts[draftKey] ?? "",
+    activeIndex: 0,
+    error: null,
+    isSubmitting: false,
+  });
+}
+
+export function setAddProjectPageInput(
+  state: AddProjectFlowState,
+  value: string,
+): AddProjectFlowState {
+  const page = currentAddProjectPage(state);
+  const updated = updateCurrentAddProjectPage(state, (current) => {
+    if (current.kind === "new-directory-name") {
+      return { ...current, name: value, activeIndex: 0, error: null };
+    }
+    return { ...current, query: value, activeIndex: 0, error: null };
+  });
+  if (page.kind !== "github-location") return updated;
+  const draftKey = githubLocationDraftKey(page.hostId, page.repository.id);
+  return {
+    ...updated,
+    githubLocationDrafts: {
+      ...updated.githubLocationDrafts,
+      [draftKey]: { query: value, activeIndex: 0 },
+    },
+  };
+}
+
+export function setNewDirectoryName(
+  state: AddProjectFlowState,
+  value: string,
+): AddProjectFlowState {
+  const page = currentAddProjectPage(state);
+  if (page.kind !== "new-directory-name") return state;
+  const draftKey = newDirectoryDraftKey(page.hostId, page.parentPath);
+  const updated = setAddProjectPageInput(state, value);
+  return {
+    ...updated,
+    newDirectoryNameDrafts: {
+      ...updated.newDirectoryNameDrafts,
+      [draftKey]: value,
+    },
+  };
+}
+
+function newDirectoryDraftKey(hostId: string, parentPath: string): string {
+  return `${hostId}\u0000${parentPath}`;
+}
+
+function githubLocationDraftKey(hostId: string, repositoryId: string): string {
+  return `${hostId}\u0000${repositoryId}`;
+}
+
+export function setAddProjectActiveIndex(
+  state: AddProjectFlowState,
+  activeIndex: number,
+): AddProjectFlowState {
+  const page = currentAddProjectPage(state);
+  const updated = updateCurrentAddProjectPage(state, (current) => ({ ...current, activeIndex }));
+  if (page.kind !== "github-location") return updated;
+  const draftKey = githubLocationDraftKey(page.hostId, page.repository.id);
+  return {
+    ...updated,
+    githubLocationDrafts: {
+      ...updated.githubLocationDrafts,
+      [draftKey]: { query: page.query, activeIndex },
+    },
+  };
+}
+
+export function moveAddProjectActiveIndex(
+  activeIndex: number,
+  optionCount: number,
+  direction: "next" | "previous",
+): number {
+  if (optionCount === 0) return 0;
+  const delta = direction === "next" ? 1 : -1;
+  const next = activeIndex + delta;
+  if (next < 0) return optionCount - 1;
+  if (next >= optionCount) return 0;
+  return next;
+}
+
+export function moveAddProjectSelection(
+  activeIndex: number,
+  selectable: readonly boolean[],
+  direction: "next" | "previous",
+): number {
+  if (!selectable.some(Boolean)) return 0;
+  let next = activeIndex;
+  for (let count = 0; count < selectable.length; count += 1) {
+    next = moveAddProjectActiveIndex(next, selectable.length, direction);
+    if (selectable[next]) return next;
+  }
+  return activeIndex;
+}

packages/app/src/add-project-flow/options.ts

@@ -0,0 +1,179 @@
+import {
+  isCompleteGitRemote,
+  parseGitHubRemoteUrl,
+  parseGitRemoteLocation,
+} from "@getpaseo/protocol/git-remote";
+import { shortenPath } from "@/utils/shorten-path";
+import type { AddProjectHost, GithubRepositoryChoice } from "./model";
+
+export type AddProjectMethodId = "directory-search" | "browse" | "github" | "new-directory";
+
+export interface AddProjectMethodOption {
+  id: AddProjectMethodId;
+  label: string;
+  description: string;
+  disabled?: boolean;
+}
+
+export interface AddProjectPathOption {
+  id: string;
+  path: string;
+  displayPath: string;
+  secondaryText: string | null;
+  disabled: boolean;
+}
+
+export function filterAddProjectHosts(hosts: AddProjectHost[], query: string): AddProjectHost[] {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return hosts;
+  return hosts.filter(
+    (host) =>
+      host.label.toLowerCase().includes(normalized) ||
+      host.serverId.toLowerCase().includes(normalized),
+  );
+}
+
+export function buildAddProjectMethods(host: AddProjectHost): AddProjectMethodOption[] {
+  const options: AddProjectMethodOption[] = [];
+  if (host.canAddProject) {
+    options.push({
+      id: "directory-search",
+      label: "Search for directory",
+      description: `Find a directory on ${host.label}`,
+    });
+  }
+  if (host.canBrowse) {
+    options.push({
+      id: "browse",
+      label: "Browse",
+      description: "Choose or create a directory in Finder",
+    });
+  }
+  options.push({
+    id: "github",
+    label: "Clone from GitHub",
+    description: githubMethodDescription(host),
+    disabled: !host.canCloneGithubRepositories,
+  });
+  options.push({
+    id: "new-directory",
+    label: "New directory",
+    description: host.canCreateDirectory
+      ? `Create an empty directory on ${host.label}`
+      : "Update this host to create directories",
+    disabled: !host.canCreateDirectory,
+  });
+  return options;
+}
+
+function githubMethodDescription(host: AddProjectHost): string {
+  if (!host.canCloneGithubRepositories) {
+    return "Update this host to clone GitHub repositories";
+  }
+  if (host.canSearchGithubRepositories) {
+    return "Search projects available to your GitHub account";
+  }
+  return "Enter a GitHub URL or owner/repo";
+}
+
+export function pathBaseName(path: string): string {
+  const trimmed = path.replace(/[\\/]+$/, "");
+  const parts = trimmed.split(/[\\/]/);
+  return parts[parts.length - 1] ?? trimmed;
+}
+
+export function buildManualGithubRepositoryChoices(query: string): GithubRepositoryChoice[] {
+  const repo = query.trim();
+  if (!repo) return [];
+
+  if (isCompleteGitRemote(repo)) {
+    const identity = parseGitHubRemoteUrl(repo);
+    const location = parseGitRemoteLocation(repo);
+    const remoteName = location ? pathBaseName(location.path).replace(/\.git$/u, "") : repo;
+    return [
+      {
+        id: `manual:${repo}`,
+        nameWithOwner: identity?.repo ?? remoteName,
+        cloneUrl: repo,
+        description: "Clone this repository URL",
+        visibility: null,
+        updatedAt: null,
+      },
+    ];
+  }
+
+  const shorthand = repo.match(/^([^\s/]+)\/([^\s/]+)$/u);
+  if (!shorthand) return [];
+  const nameWithOwner = `${shorthand[1]}/${shorthand[2]}`;
+  return (["https", "ssh"] as const).map((cloneProtocol) => ({
+    id: `manual:${cloneProtocol}:${nameWithOwner}`,
+    nameWithOwner,
+    cloneUrl: nameWithOwner,
+    cloneProtocol,
+    description: `Clone owner/repo via ${cloneProtocol.toUpperCase()}`,
+    visibility: null,
+    updatedAt: null,
+  }));
+}
+
+export function parentDirectory(path: string): string | null {
+  const trimmed = path.replace(/[\\/]+$/, "");
+  const index = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  if (index < 0) return null;
+  if (index === 0) return trimmed.slice(0, 1);
+  return trimmed.slice(0, index);
+}
+
+export function joinDirectoryPath(parent: string, name: string): string {
+  const trimmedParent = parent.replace(/[\\/]+$/, "");
+  const separator = trimmedParent.includes("\\") && !trimmedParent.includes("/") ? "\\" : "/";
+  return `${trimmedParent}${separator}${name}`;
+}
+
+export function buildSuggestedParentDirectories(projectPaths: string[]): string[] {
+  const values = [
+    ...projectPaths.flatMap((path) => {
+      const parent = parentDirectory(path);
+      return parent ? [parent] : [];
+    }),
+    "~/dev",
+    "~/Developer",
+    "~/src",
+    "~/projects",
+    "~/workspace",
+    "~",
+  ];
+  return [...new Set(values)];
+}
+
+export function buildCloneLocationOptions(input: {
+  parents: string[];
+  repositoryName: string;
+  existingPaths: string[];
+}): AddProjectPathOption[] {
+  const existing = new Set(input.existingPaths.map(pathIdentity));
+  const seen = new Set<string>();
+  return input.parents.flatMap((parent) => {
+    const path = joinDirectoryPath(parent, input.repositoryName);
+    const identity = pathIdentity(path);
+    if (seen.has(identity)) return [];
+    seen.add(identity);
+    const pathExists = existing.has(identity);
+    return [
+      {
+        id: parent,
+        path: parent,
+        displayPath: path,
+        secondaryText: pathExists ? "Already exists" : `Parent directory: ${parent}`,
+        disabled: pathExists,
+      },
+    ];
+  });
+}
+
+function pathIdentity(path: string): string {
+  const normalized = shortenPath(path.trim()).replace(/\\/g, "/").replace(/\/+$/u, "");
+  return /^[A-Za-z]:\//u.test(normalized) || normalized.startsWith("//")
+    ? normalized.toLowerCase()
+    : normalized;
+}

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

@@ -33,6 +33,24 @@ const DEFAULT_MAINTAIN_VISIBLE_CONTENT_POSITION = Object.freeze({
 });
 const HISTORY_START_THRESHOLD_PX = 96;
 
+interface HistoryRowDisplayVariants {
+  regular?: StreamItem;
+  compact?: StreamItem;
+}
+
+const historyRowDisplayVariants = new WeakMap<StreamItem, HistoryRowDisplayVariants>();
+
+function getHistoryRowDisplayVariant(item: StreamItem, compact: boolean): StreamItem {
+  let variants = historyRowDisplayVariants.get(item);
+  if (!variants) {
+    variants = {};
+    historyRowDisplayVariants.set(item, variants);
+  }
+  const key = compact ? "compact" : "regular";
+  variants[key] ??= { ...item };
+  return variants[key];
+}
+
 function keyExtractor(item: { id: string }): string {
   return item.id;
 }
@@ -41,6 +59,8 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
   const {
     agentId,
     segments,
+    historyRowRevision,
+    liveHeadRowRevision,
     boundary,
     renderers,
     listEmptyComponent,
@@ -73,12 +93,33 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
   const nativeViewportSettlingFrameIdRef = useRef<number | null>(null);
   const historyStartReadyRef = useRef(false);
 
-  const historyRows = useMemo(() => {
+  const historyItems = useMemo(() => {
     if (segments.historyVirtualized.length === 0) {
       return segments.historyMounted;
     }
     return [...segments.historyVirtualized, ...segments.historyMounted];
   }, [segments.historyMounted, segments.historyVirtualized]);
+  // Keep unchanged item identities intact so live updates only rerender rows
+  // whose projected content or local display state actually changed. A rare
+  // breakpoint change intentionally refreshes the whole history window.
+  const globallyRevisedHistoryRows = useMemo(() => {
+    const globalDisplayState = historyRowRevision?.globalDisplayState ?? false;
+    return historyItems.map((item) => getHistoryRowDisplayVariant(item, globalDisplayState));
+  }, [historyItems, historyRowRevision?.globalDisplayState]);
+  const displayStateHistoryRows = useMemo(
+    () =>
+      globallyRevisedHistoryRows.map((item) =>
+        historyRowRevision?.displayStateById.has(item.id) ? { ...item } : item,
+      ),
+    [globallyRevisedHistoryRows, historyRowRevision?.displayStateById],
+  );
+  const historyRows = useMemo(
+    () =>
+      displayStateHistoryRows.map((item) =>
+        historyRowRevision?.contentById.has(item.id) ? { ...item } : item,
+      ),
+    [displayStateHistoryRows, historyRowRevision?.contentById],
+  );
 
   const clearNativeViewportSettling = useCallback(() => {
     if (nativeViewportSettlingFrameIdRef.current !== null) {
@@ -307,12 +348,15 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
 
   const renderItem = useStableEvent(
     ({ item, index }: ListRenderItemInfo<StreamItem>): ReactElement | null => {
-      const rendered = renderHistoryMountedRow(item, index, historyRows);
+      const rendered = renderHistoryMountedRow(item, index, historyItems);
       return (rendered ?? null) as ReactElement | null;
     },
   );
 
   const liveHeaderContent = useMemo(() => {
+    // Stable render events read the latest expansion state; this revision makes
+    // the memo invoke them again when that state changes.
+    void liveHeadRowRevision;
     const liveHeadRows = segments.liveHead.map((item, index) => (
       <Fragment key={item.id}>{renderLiveHeadRow(item, index, segments.liveHead)}</Fragment>
     ));
@@ -331,7 +375,14 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
         {liveAuxiliary}
       </Fragment>
     );
-  }, [boundary, listEmptyComponent, renderLiveAuxiliary, renderLiveHeadRow, segments.liveHead]);
+  }, [
+    boundary,
+    listEmptyComponent,
+    liveHeadRowRevision,
+    renderLiveAuxiliary,
+    renderLiveHeadRow,
+    segments.liveHead,
+  ]);
 
   const historyFooterContent = useMemo(() => {
     if (!isLoadingOlderHistory) {
@@ -344,12 +395,15 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
     );
   }, [isLoadingOlderHistory]);
 
+  // RN's FlatList strictMode keeps its internal renderItem wrapper stable when
+  // data or the live header changes, preserving the row identities above.
   return (
     <FlatList
       ref={flatListRef}
       data={historyRows}
       renderItem={renderItem}
       keyExtractor={keyExtractor}
+      strictMode
       testID="agent-chat-scroll"
       nativeID="agent-chat-scroll-native-virtualized"
       ListHeaderComponent={liveHeaderContent ?? undefined}

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

@@ -6,7 +6,7 @@ import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { StreamItem } from "@/types/stream";
-import type { StreamSegmentRenderers, StreamViewportHandle } from "./strategy";
+import type { StreamRenderInput, StreamSegmentRenderers, StreamViewportHandle } from "./strategy";
 import { createWebStreamStrategy } from "./strategy-web";
 
 vi.hoisted(() => {
@@ -25,8 +25,6 @@ vi.hoisted(() => {
   });
 });
 
-vi.mock("@/components/use-web-scrollbar", () => ({ useWebElementScrollbar: () => null }));
-
 function userMessage(index: number): StreamItem {
   return {
     kind: "user_message",
@@ -148,6 +146,59 @@ describe("createWebStreamStrategy", () => {
     expect(rowRenderCount.mock.calls.length).toBeLessThanOrEqual(historyVirtualized.length);
   });
 
+  it("rerenders a stable live-head row when its revision changes", () => {
+    const strategy = createWebStreamStrategy({ isMobileBreakpoint: false });
+    const viewportRef = React.createRef<StreamViewportHandle>();
+    const liveHead = [userMessage(1)];
+    let label = "collapsed";
+    const renderLiveHeadRow = vi.fn(() => <div>{label}</div>);
+    const renderInput: StreamRenderInput = {
+      agentId: "agent",
+      segments: {
+        historyVirtualized: [],
+        historyMounted: [],
+        liveHead,
+      },
+      boundary: {
+        hasVirtualizedHistory: false,
+        hasMountedHistory: false,
+        hasLiveHead: true,
+      },
+      renderers: {
+        ...createRenderers(vi.fn()),
+        renderLiveHeadRow,
+      },
+      listEmptyComponent: null,
+      viewportRef,
+      routeBottomAnchorRequest: null,
+      isAuthoritativeHistoryReady: true,
+      onNearBottomChange: vi.fn(),
+      onNearHistoryStart: vi.fn(),
+      isLoadingOlderHistory: false,
+      hasOlderHistory: false,
+      scrollEnabled: true,
+      listStyle: null,
+      baseListContentContainerStyle: null,
+      forwardListContentContainerStyle: null,
+    };
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+
+    act(() => {
+      root?.render(strategy.render({ ...renderInput, liveHeadRowRevision: 0 }));
+    });
+    expect(container.textContent).toContain("collapsed");
+
+    label = "expanded";
+    act(() => {
+      root?.render(strategy.render({ ...renderInput, liveHeadRowRevision: 1 }));
+    });
+
+    expect(container.textContent).toContain("expanded");
+    expect(renderLiveHeadRow).toHaveBeenCalledTimes(2);
+  });
+
   it("fires near-history-start when the user scrolls near the top", async () => {
     const strategy = createWebStreamStrategy({ isMobileBreakpoint: true });
     const viewportRef = React.createRef<StreamViewportHandle>();

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

@@ -25,7 +25,6 @@ const USER_SCROLL_DELTA_EPSILON = 1;
 const AUTO_SCROLL_BOTTOM_THRESHOLD_PX = 64;
 const AUTO_SCROLL_RESUME_THRESHOLD_PX = 1;
 const HISTORY_START_THRESHOLD_PX = 96;
-import { useWebElementScrollbar } from "@/components/use-web-scrollbar";
 
 const historyStartSlotStyle: CSSProperties = {
   display: "flex",
@@ -95,6 +94,7 @@ function isScrollContainerOverscrolledPastBottom(
 function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: boolean }) {
   const {
     segments,
+    liveHeadRowRevision,
     boundary,
     renderers,
     listEmptyComponent,
@@ -131,11 +131,6 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
   const pendingAutoScrollTimeoutRef = useRef<number | null>(null);
   const pendingVirtualRowMeasureFramesRef = useRef(new Map<Element, number>());
   const historyStartReadyRef = useRef(false);
-  const showDesktopWebScrollbar = !isMobileBreakpoint;
-  const scrollbarOverlay = useWebElementScrollbar(scrollContainerRef, {
-    enabled: showDesktopWebScrollbar,
-    contentRef,
-  });
   const shouldUseVirtualizer = segments.historyVirtualized.length > 0;
   const {
     renderHistoryVirtualizedRow,
@@ -152,6 +147,7 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
 
   const rowVirtualizer = useVirtualizer({
     count: segments.historyVirtualized.length,
+    enabled: shouldUseVirtualizer,
     getScrollElement: () => scrollContainerRef.current,
     getItemKey: (index: number) => segments.historyVirtualized[index]?.id ?? index,
     estimateSize: (index: number) => {
@@ -539,10 +535,11 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
     ));
   }, [renderHistoryMountedRow, segments.historyMounted]);
   const liveHeadRows = useMemo(() => {
+    void liveHeadRowRevision;
     return segments.liveHead.map((item, index) => (
       <Fragment key={item.id}>{renderLiveHeadRow(item, index, segments.liveHead)}</Fragment>
     ));
-  }, [renderLiveHeadRow, segments.liveHead]);
+  }, [liveHeadRowRevision, renderLiveHeadRow, segments.liveHead]);
   const liveAuxiliary = useMemo(() => {
     return renderLiveAuxiliary();
   }, [renderLiveAuxiliary]);
@@ -563,47 +560,40 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
     !liveAuxiliary;
 
   return (
-    <>
-      <div
-        ref={handleScrollContainerRef}
-        data-testid="agent-chat-scroll"
-        id={`agent-chat-scroll-${shouldUseVirtualizer ? "web-dom-virtualized" : "web-dom-scroll"}`}
-        style={scrollContainerStyle}
-      >
-        <div ref={handleContentRef} style={contentContainerStyle}>
-          {historyStartSlot}
-          {shouldUseVirtualizer ? (
-            <div style={virtualRowsContainerStyle}>
-              {virtualRows.map((virtualRow) => {
-                const item = segments.historyVirtualized[virtualRow.index];
-                if (!item) {
-                  return null;
-                }
-                return (
-                  <div
-                    key={virtualRow.key}
-                    data-index={virtualRow.index}
-                    ref={measureVirtualizedRowElement}
-                    style={renderVirtualRowStyle(virtualRow.start)}
-                  >
-                    {renderHistoryVirtualizedRow(
-                      item,
-                      virtualRow.index,
-                      segments.historyVirtualized,
-                    )}
-                  </div>
-                );
-              })}
-            </div>
-          ) : null}
-          {mountedHistoryRows}
-          {liveHeadRows}
-          {liveAuxiliary}
-          {shouldRenderEmpty ? listEmptyComponent : null}
-        </div>
+    <div
+      ref={handleScrollContainerRef}
+      data-testid="agent-chat-scroll"
+      id={`agent-chat-scroll-${shouldUseVirtualizer ? "web-dom-virtualized" : "web-dom-scroll"}`}
+      style={scrollContainerStyle}
+    >
+      <div ref={handleContentRef} style={contentContainerStyle}>
+        {historyStartSlot}
+        {shouldUseVirtualizer ? (
+          <div style={virtualRowsContainerStyle}>
+            {virtualRows.map((virtualRow) => {
+              const item = segments.historyVirtualized[virtualRow.index];
+              if (!item) {
+                return null;
+              }
+              return (
+                <div
+                  key={virtualRow.key}
+                  data-index={virtualRow.index}
+                  ref={measureVirtualizedRowElement}
+                  style={renderVirtualRowStyle(virtualRow.start)}
+                >
+                  {renderHistoryVirtualizedRow(item, virtualRow.index, segments.historyVirtualized)}
+                </div>
+              );
+            })}
+          </div>
+        ) : null}
+        {mountedHistoryRows}
+        {liveHeadRows}
+        {liveAuxiliary}
+        {shouldRenderEmpty ? listEmptyComponent : null}
       </div>
-      {scrollbarOverlay}
-    </>
+    </div>
   );
 }
 

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

@@ -51,9 +51,17 @@ export interface StreamSegmentRenderers {
   renderLiveAuxiliary: () => ReactNode;
 }
 
+export interface StreamHistoryRowRevision {
+  contentById: { has(id: string): boolean };
+  displayStateById: { has(id: string): boolean };
+  globalDisplayState: boolean;
+}
+
 export interface StreamRenderInput {
   agentId: string;
   segments: StreamRenderSegments;
+  historyRowRevision?: StreamHistoryRowRevision;
+  liveHeadRowRevision?: unknown;
   boundary: StreamHistoryBoundary;
   renderers: StreamSegmentRenderers;
   listEmptyComponent: ReactNode;

packages/app/src/agent-stream/turn-boundary.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { StreamItem } from "@/types/stream";
-import { resolveAssistantTurnBoundaryMessageId } from "./turn-boundary";
+import { resolveAssistantTurnForkBoundary } from "./turn-boundary";
 
 function timestamp(seed: number): Date {
   return new Date(`2026-01-01T00:00:${seed.toString().padStart(2, "0")}.000Z`);
@@ -29,35 +29,86 @@ function assistantMessage(
   };
 }
 
-describe("resolveAssistantTurnBoundaryMessageId", () => {
-  it("uses the selected assistant message id", () => {
-    const selected = assistantMessage("assistant-1", 2, "msg-assistant-1");
+describe("resolveAssistantTurnForkBoundary", () => {
+  it("forks a failed assistant turn from its Paseo timeline cursor without a provider message id", () => {
+    const failedTurn = {
+      ...assistantMessage("assistant-error", 2),
+      timelineCursor: { epoch: "timeline-1", seq: 42 },
+    };
 
     expect(
-      resolveAssistantTurnBoundaryMessageId({
-        items: [userMessage("user-1", 1), selected],
+      resolveAssistantTurnForkBoundary({
+        items: [userMessage("user-1", 1), failedTurn],
         startIndex: 1,
+        supportsTimelineCursor: true,
       }),
-    ).toBe("msg-assistant-1");
+    ).toEqual({
+      boundaryCursor: { epoch: "timeline-1", seq: 42 },
+    });
   });
 
-  it("does not borrow a boundary id from another assistant in the same turn", () => {
+  it("includes the provider message id with a supported timeline cursor", () => {
+    const selected = {
+      ...assistantMessage("assistant-1", 2, "msg-assistant-1"),
+      timelineCursor: { epoch: "timeline-1", seq: 42 },
+    };
+
+    expect(
+      resolveAssistantTurnForkBoundary({
+        items: [selected],
+        startIndex: 0,
+        supportsTimelineCursor: true,
+      }),
+    ).toEqual({
+      boundaryCursor: { epoch: "timeline-1", seq: 42 },
+      boundaryMessageId: "msg-assistant-1",
+    });
+  });
+
+  it("falls back to the provider message id when timeline cursors are unsupported", () => {
+    const selected = {
+      ...assistantMessage("assistant-1", 2, "msg-assistant-1"),
+      timelineCursor: { epoch: "timeline-1", seq: 42 },
+    };
+
+    expect(
+      resolveAssistantTurnForkBoundary({
+        items: [selected],
+        startIndex: 0,
+        supportsTimelineCursor: false,
+      }),
+    ).toEqual({ boundaryMessageId: "msg-assistant-1" });
+  });
+
+  it("does not borrow a provider message id from another assistant in the same turn", () => {
     const first = assistantMessage("assistant-1", 2, "msg-assistant-1");
     const selected = assistantMessage("assistant-2", 3);
 
     expect(
-      resolveAssistantTurnBoundaryMessageId({
+      resolveAssistantTurnForkBoundary({
         items: [userMessage("user-1", 1), first, selected],
         startIndex: 2,
+        supportsTimelineCursor: false,
       }),
     ).toBeUndefined();
   });
 
   it("requires the selected item to be an assistant message", () => {
     expect(
-      resolveAssistantTurnBoundaryMessageId({
+      resolveAssistantTurnForkBoundary({
         items: [userMessage("user-1", 1), assistantMessage("assistant-1", 2, "msg-assistant-1")],
         startIndex: 0,
+        supportsTimelineCursor: false,
+      }),
+    ).toBeUndefined();
+  });
+
+  it("does not offer an unavailable boundary", () => {
+    expect(
+      resolveAssistantTurnForkBoundary({
+        items: [assistantMessage("assistant-1", 2)],
+        startIndex: 0,
+        supportsTimelineCursor: false,
       }),
     ).toBeUndefined();
   });

packages/app/src/agent-stream/turn-boundary.ts

@@ -1,13 +1,23 @@
-import type { StreamItem } from "@/types/stream";
+import type { StreamItem, TimelinePosition } from "@/types/stream";
 
-export function resolveAssistantTurnBoundaryMessageId(input: {
+export type AssistantTurnForkBoundary =
+  | { boundaryCursor: TimelinePosition; boundaryMessageId?: string }
+  | { boundaryCursor?: undefined; boundaryMessageId: string };
+
+export function resolveAssistantTurnForkBoundary(input: {
   items: readonly StreamItem[];
   startIndex: number;
-}): string | undefined {
+  supportsTimelineCursor: boolean;
+}): AssistantTurnForkBoundary | undefined {
   const item = input.items[input.startIndex];
   if (item?.kind !== "assistant_message") {
     return undefined;
   }
-  // Forking without the selected assistant's durable message id would send the wrong slice.
-  return item.messageId || undefined;
+  if (input.supportsTimelineCursor && item.timelineCursor) {
+    return {
+      boundaryCursor: item.timelineCursor,
+      ...(item.messageId ? { boundaryMessageId: item.messageId } : {}),
+    };
+  }
+  return item.messageId ? { boundaryMessageId: item.messageId } : undefined;
 }

packages/app/src/agent-stream/turn-footer.tsx

@@ -9,7 +9,7 @@ import {
   collectAssistantTurnContentForStreamRenderStrategy,
   type StreamStrategy,
 } from "./strategy";
-import { resolveAssistantTurnBoundaryMessageId } from "./turn-boundary";
+import { resolveAssistantTurnForkBoundary, type AssistantTurnForkBoundary } from "./turn-boundary";
 import {
   AssistantTurnFooter,
   LiveElapsed,
@@ -18,6 +18,7 @@ import {
 } from "@/components/message";
 import type { TurnFooterHost } from "./layout";
 import { SyncedLoader } from "@/components/synced-loader";
+import { useRetainedPanelActive } from "@/components/retained-panel";
 
 const ThemedSyncedLoader = withUnistyles(SyncedLoader);
 const workingIndicatorColorMapping = (theme: Theme) => ({
@@ -30,7 +31,7 @@ const workingIndicatorColorMapping = (theme: Theme) => ({
 export type TurnContentStrategy = StreamStrategy;
 export type AssistantTurnForkHandler = (input: {
   target: AssistantForkTarget;
-  boundaryMessageId?: string;
+  boundary: AssistantTurnForkBoundary;
 }) => Promise<void> | void;
 
 export const TurnFooter = memo(function TurnFooter({
@@ -38,12 +39,14 @@ export const TurnFooter = memo(function TurnFooter({
   inFlightTurnStartedAt,
   host,
   strategy,
+  supportsTimelineCursor,
   onForkAssistantTurn,
 }: {
   isRunning: boolean;
   inFlightTurnStartedAt: Date | null;
   host: TurnFooterHost | null;
   strategy: TurnContentStrategy;
+  supportsTimelineCursor: boolean;
   onForkAssistantTurn?: AssistantTurnForkHandler;
 }) {
   if (isRunning) {
@@ -62,6 +65,7 @@ export const TurnFooter = memo(function TurnFooter({
       items={host.items}
       timing={host.timing}
       startIndex={host.startIndex}
+      supportsTimelineCursor={supportsTimelineCursor}
       onForkAssistantTurn={onForkAssistantTurn}
     />
   );
@@ -72,12 +76,14 @@ export const CompletedTurnFooterRow = memo(function CompletedTurnFooterRow({
   items,
   timing,
   startIndex,
+  supportsTimelineCursor,
   onForkAssistantTurn,
 }: {
   strategy: TurnContentStrategy;
   items: StreamItem[];
   timing?: TurnTiming;
   startIndex: number;
+  supportsTimelineCursor: boolean;
   onForkAssistantTurn?: AssistantTurnForkHandler;
 }) {
   return (
@@ -87,6 +93,7 @@ export const CompletedTurnFooterRow = memo(function CompletedTurnFooterRow({
         items={items}
         timing={timing}
         startIndex={startIndex}
+        supportsTimelineCursor={supportsTimelineCursor}
         onForkAssistantTurn={onForkAssistantTurn}
       />
     </TurnFooterRow>
@@ -98,6 +105,7 @@ const WorkingIndicator = memo(function WorkingIndicator({
 }: {
   inFlightTurnStartedAt?: Date | null;
 }) {
+  const active = useRetainedPanelActive();
   return (
     <View style={stylesheet.turnFooterContent}>
       <View style={stylesheet.workingLoader}>
@@ -106,6 +114,7 @@ const WorkingIndicator = memo(function WorkingIndicator({
       {inFlightTurnStartedAt ? (
         <LiveElapsed
           startedAt={inFlightTurnStartedAt}
+          active={active}
           style={stylesheet.workingElapsed}
           testID="turn-working-elapsed"
         />
@@ -127,12 +136,14 @@ function CompletedTurnFooter({
   items,
   timing,
   startIndex,
+  supportsTimelineCursor,
   onForkAssistantTurn,
 }: {
   strategy: TurnContentStrategy;
   items: StreamItem[];
   timing?: TurnTiming;
   startIndex: number;
+  supportsTimelineCursor: boolean;
   onForkAssistantTurn?: AssistantTurnForkHandler;
 }) {
   const getContent = useCallback(
@@ -144,18 +155,27 @@ function CompletedTurnFooter({
       }),
     [strategy, items, startIndex],
   );
-  const boundaryMessageId = resolveAssistantTurnBoundaryMessageId({
+  const boundary = resolveAssistantTurnForkBoundary({
     items,
     startIndex,
+    supportsTimelineCursor,
   });
+  const handleFork = useCallback(
+    (target: AssistantForkTarget) => {
+      if (!boundary) {
+        return;
+      }
+      return onForkAssistantTurn?.({ target, boundary });
+    },
+    [boundary, onForkAssistantTurn],
+  );
   return (
     <View style={stylesheet.turnFooterSlot}>
       <AssistantTurnFooter
         getContent={getContent}
         completedAt={timing?.completedAt}
         durationMs={timing?.durationMs}
-        forkBoundaryMessageId={boundaryMessageId}
-        onFork={onForkAssistantTurn}
+        onFork={boundary && onForkAssistantTurn ? handleFork : undefined}
       />
     </View>
   );

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

@@ -2,7 +2,6 @@ import React, {
   forwardRef,
   memo,
   useCallback,
-  useContext,
   useEffect,
   useImperativeHandle,
   useMemo,
@@ -58,6 +57,11 @@ import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import { ToolCallDetailsContent } from "@/components/tool-call-details";
 import { QuestionFormCard } from "@/components/question-form-card";
 import { ToolCallSheetProvider } from "@/components/tool-call-sheet";
+import {
+  prepareToolCallHistory,
+  projectToolCallDetailLevel,
+} from "@/tool-calls/detail-level/projection";
+import { OverviewToolCallGroupView } from "@/tool-calls/detail-level/overview/view";
 import { type AgentStreamRenderModel, buildAgentStreamRenderModel } from "./model";
 import { resolveStreamRenderStrategy } from "./strategy-resolver";
 import { type StreamSegmentRenderers, type StreamViewportHandle } from "./strategy";
@@ -82,13 +86,13 @@ import {
   type OpenFileDisposition,
   type WorkspaceFileOpenRequest,
 } from "@/workspace/file-open";
-import { navigateToPreparedWorkspaceTab } from "@/utils/workspace-navigation";
+import { navigateToWorkspace } from "@/stores/navigation-active-workspace-store";
 import { buildNewWorkspaceRoute } from "@/utils/host-routes";
 import { useStableEvent } from "@/hooks/use-stable-event";
 import { isWeb } from "@/constants/platform";
 import type { Theme } from "@/styles/theme";
 import { recordRenderProfileReasons } from "@/utils/render-profiler";
-import { MountedTabActiveContext } from "@/components/split-container";
+import { useRetainedPanelActive } from "@/components/retained-panel";
 import { generateDraftId } from "@/stores/draft-keys";
 import {
   buildDraftWorkspaceAttachmentScopeKey,
@@ -138,6 +142,7 @@ function renderStreamItemWithTurnFooter(input: {
   content: ReactNode;
   layoutItem: StreamLayoutItem;
   strategy: TurnContentStrategy;
+  supportsTimelineCursor: boolean;
   onForkAssistantTurn?: AssistantTurnForkHandler;
 }): ReactNode {
   if (!input.content) {
@@ -151,6 +156,7 @@ function renderStreamItemWithTurnFooter(input: {
       items={footerHost.items}
       timing={footerHost.timing}
       startIndex={footerHost.startIndex}
+      supportsTimelineCursor={input.supportsTimelineCursor}
       onForkAssistantTurn={input.onForkAssistantTurn}
     />
   ) : null;
@@ -229,13 +235,20 @@ export interface AgentStreamViewHandle {
 export interface AgentStreamViewProps {
   agentId: string;
   serverId?: string;
-  agent: AgentScreenAgent;
+  context: AgentScreenAgent;
   streamItems: StreamItem[];
+  streamHead?: StreamItem[];
   pendingPermissions: Map<string, PendingPermission>;
   routeBottomAnchorRequest?: BottomAnchorRouteRequest | null;
   isAuthoritativeHistoryReady?: boolean;
   toast?: ToastApi | null;
   onOpenWorkspaceFile?: (request: WorkspaceFileOpenRequest) => void;
+  readOnly?: boolean;
+  historyPagination?: {
+    hasOlder: boolean;
+    isLoadingOlder: boolean;
+    onLoadOlder: () => void;
+  };
 }
 
 const AGENT_CAPABILITY_FLAG_KEYS: (keyof AgentCapabilityFlags)[] = [
@@ -251,6 +264,7 @@ const AGENT_CAPABILITY_FLAG_KEYS: (keyof AgentCapabilityFlags)[] = [
 ];
 
 const EMPTY_STREAM_HEAD: StreamItem[] = [];
+const GROUPED_TOOL_CALL_DETAIL_MAX_HEIGHT = 200;
 
 function buildChatHistoryAttachment(input: {
   draftId: string;
@@ -270,6 +284,7 @@ function buildChatHistoryAttachment(input: {
       serverId: input.serverId,
       agentId: input.agentId,
       boundaryMessageId: input.payload.boundaryMessageId,
+      boundaryCursor: input.payload.boundaryCursor,
       itemCount: input.payload.itemCount,
     },
   };
@@ -307,19 +322,23 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     {
       agentId,
       serverId,
-      agent,
+      context,
       streamItems,
+      streamHead: providedStreamHead,
       pendingPermissions,
       routeBottomAnchorRequest = null,
       isAuthoritativeHistoryReady = true,
       toast,
       onOpenWorkspaceFile,
+      readOnly = false,
+      historyPagination,
     },
     ref,
   ) {
     const { t } = useTranslation();
     const router = useRouter();
     const autoExpandReasoning = useSettings((settings) => settings.autoExpandReasoning);
+    const toolCallDetailLevel = useSettings((settings) => settings.toolCallDetailLevel);
     const viewportRef = useRef<StreamViewportHandle | null>(null);
     const isMobile = useIsCompactFormFactor();
     const streamRenderStrategy = useMemo(
@@ -334,31 +353,48 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     const [expandedInlineToolCallIds, setExpandedInlineToolCallIds] = useState<Set<string>>(
       new Set(),
     );
+    const [expandedToolCallGroupIds, setExpandedToolCallGroupIds] = useState<Set<string>>(
+      new Set(),
+    );
     const openFileExplorerForCheckout = usePanelStore((state) => state.openFileExplorerForCheckout);
     const setExplorerTabForCheckout = usePanelStore((state) => state.setExplorerTabForCheckout);
 
     // Get serverId (fallback to agent's serverId if not provided)
-    const resolvedServerId = serverId ?? agent.serverId ?? "";
+    const resolvedServerId = serverId ?? context.serverId ?? "";
 
     const client = useSessionStore((state) => state.sessions[resolvedServerId]?.client ?? null);
-    const streamHead = useSessionStore((state) =>
+    const sessionStreamHead = useSessionStore((state) =>
       state.sessions[resolvedServerId]?.agentStreamHead?.get(agentId),
     );
+    const streamHead = providedStreamHead ?? sessionStreamHead;
     const supportsAgentForkContext = useSessionStore(
-      (state) => state.sessions[resolvedServerId]?.serverInfo?.features?.agentForkContext === true,
+      (state) =>
+        !readOnly &&
+        state.sessions[resolvedServerId]?.serverInfo?.features?.agentForkContext === true,
+    );
+    const supportsAgentForkContextCursor = useSessionStore(
+      (state) =>
+        state.sessions[resolvedServerId]?.serverInfo?.features?.agentForkContextCursor === true,
     );
 
-    const workspaceRoot = agent.cwd?.trim() || "";
+    const workspaceRoot = context.cwd?.trim() || "";
     const { requestDirectoryListing } = useFileExplorerActions({
       serverId: resolvedServerId,
-      workspaceId: agent.workspaceId,
+      workspaceId: context.workspaceId,
       workspaceRoot,
     });
-    const { isLoadingOlder, hasOlder, loadOlder } = useLoadOlderAgentHistory({
+    const agentHistoryPagination = useLoadOlderAgentHistory({
       serverId: resolvedServerId,
       agentId,
       toast,
     });
+    const { isLoadingOlder, hasOlder, loadOlder } = historyPagination
+      ? {
+          isLoadingOlder: historyPagination.isLoadingOlder,
+          hasOlder: historyPagination.hasOlder,
+          loadOlder: historyPagination.onLoadOlder,
+        }
+      : agentHistoryPagination;
     // Keep entry/exit animations off on Android due to RN dispatchDraw crashes
     // tracked in react-native-reanimated#8422.
     const shouldDisableEntryExitAnimations = Platform.OS === "android";
@@ -372,6 +408,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     useEffect(() => {
       setIsNearBottom(true);
       setExpandedInlineToolCallIds(new Set());
+      setExpandedToolCallGroupIds(new Set());
     }, [agentId]);
 
     const handleInlinePathPress = useStableEvent(
@@ -380,7 +417,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           return;
         }
 
-        const normalized = normalizeInlinePathTarget(target.path, agent.cwd);
+        const normalized = normalizeInlinePathTarget(target.path, context.cwd);
         if (!normalized) {
           return;
         }
@@ -403,10 +440,10 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             return;
           }
 
-          if (agent.workspaceId) {
-            navigateToPreparedWorkspaceTab({
+          if (context.workspaceId) {
+            navigateToWorkspace({
               serverId: resolvedServerId,
-              workspaceId: agent.workspaceId,
+              workspaceId: context.workspaceId,
               target: createWorkspaceFileTabTarget(location),
             });
           }
@@ -420,8 +457,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
 
         const checkout = {
           serverId: resolvedServerId,
-          cwd: agent.cwd,
-          isGit: agent.projectPlacement?.checkout?.isGit ?? true,
+          cwd: context.cwd,
+          isGit: context.projectPlacement?.checkout?.isGit ?? true,
         };
         setExplorerTabForCheckout({ ...checkout, tab: "files" });
         openFileExplorerForCheckout({
@@ -436,7 +473,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     });
 
     const handleForkAssistantTurn: AssistantTurnForkHandler = useStableEvent(
-      async ({ target, boundaryMessageId }) => {
+      async ({ target, boundary }) => {
         try {
           if (!supportsAgentForkContext) {
             toast?.error(t("message.actions.forkUnavailable"));
@@ -445,13 +482,10 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           if (!client) {
             throw new Error(t("workspace.terminal.hostDisconnected"));
           }
-          const draftSetup = buildForkDraftSetup(agent);
+          const draftSetup = buildForkDraftSetup(context);
           const prepareForkDraft = async () => {
             const draftId = generateDraftId();
-            const payload = await client.buildAgentForkContext(
-              agentId,
-              boundaryMessageId ? { boundaryMessageId } : {},
-            );
+            const payload = await client.buildAgentForkContext(agentId, boundary);
             const attachment = buildChatHistoryAttachment({
               draftId,
               serverId: resolvedServerId,
@@ -467,12 +501,12 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           };
 
           if (target === "tab") {
-            const workspaceId = agent.workspaceId;
+            const workspaceId = context.workspaceId;
             if (!workspaceId) {
               throw new Error(t("message.actions.forkMissingWorkspace"));
             }
             const draftId = await prepareForkDraft();
-            navigateToPreparedWorkspaceTab({
+            navigateToWorkspace({
               serverId: resolvedServerId,
               workspaceId,
               target: buildForkDraftTabTarget(draftSetup, draftId),
@@ -482,7 +516,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
 
           const draftId = await prepareForkDraft();
           const sourceDirectory =
-            agent.projectPlacement?.checkout?.cwd?.trim() || agent.cwd.trim() || undefined;
+            context.projectPlacement?.checkout?.cwd?.trim() || context.cwd.trim() || undefined;
           if (draftSetup) {
             useWorkspaceDraftSubmissionStore.getState().setDraftSetup({
               draftId,
@@ -494,8 +528,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             buildNewWorkspaceRoute({
               serverId: resolvedServerId,
               sourceDirectory,
-              displayName: agent.projectPlacement?.projectName,
-              projectId: agent.projectPlacement?.projectKey,
+              displayName: context.projectPlacement?.projectName,
+              projectId: context.projectPlacement?.projectKey,
               draftId,
             }),
           );
@@ -509,7 +543,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     // cell-window renders on every 48ms flush from background agents.
     // When isActive flips back to true, the context change triggers a re-render and
     // the component reads the current (fresh) streamItems/streamHead from props.
-    const isActive = useContext(MountedTabActiveContext);
+    const isActive = useRetainedPanelActive();
     const frozenStreamItemsRef = useRef(streamItems);
     const frozenStreamHeadRef = useRef(streamHead);
     if (isActive) {
@@ -518,27 +552,49 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     }
     const effectiveStreamItems = isActive ? streamItems : frozenStreamItemsRef.current;
     const effectiveStreamHead = isActive ? streamHead : frozenStreamHeadRef.current;
+    // Keep retained history outside the 48ms live-head flush path.
+    const preparedToolCallHistory = useMemo(
+      () => prepareToolCallHistory(toolCallDetailLevel, effectiveStreamItems),
+      [effectiveStreamItems, toolCallDetailLevel],
+    );
+    const projectedToolCalls = useMemo(
+      () =>
+        projectToolCallDetailLevel({
+          level: toolCallDetailLevel,
+          tail: effectiveStreamItems,
+          head: effectiveStreamHead ?? EMPTY_STREAM_HEAD,
+          preparedHistory: preparedToolCallHistory,
+          isTurnActive: context.status === "running",
+        }),
+      [
+        context.status,
+        effectiveStreamHead,
+        effectiveStreamItems,
+        preparedToolCallHistory,
+        toolCallDetailLevel,
+      ],
+    );
 
     const baseRenderModel = useMemo(() => {
       return buildAgentStreamRenderModel({
-        agentStatus: agent.status,
-        tail: effectiveStreamItems,
-        head: effectiveStreamHead ?? EMPTY_STREAM_HEAD,
+        agentStatus: context.status,
+        tail: projectedToolCalls.tail,
+        head: projectedToolCalls.head,
         platform: isWeb ? "web" : "native",
         isMobileBreakpoint: isMobile,
       });
-    }, [agent.status, isMobile, effectiveStreamHead, effectiveStreamItems]);
+    }, [context.status, isMobile, projectedToolCalls.head, projectedToolCalls.tail]);
     const streamLayout = useMemo(
       () =>
         layoutStream({
           strategy: streamRenderStrategy,
-          agentStatus: agent.status,
+          agentStatus: context.status,
           history: baseRenderModel.history,
           liveHead: baseRenderModel.segments.liveHead,
           timingByAssistantId: baseRenderModel.turnTiming.byAssistantId,
         }),
       [
-        agent.status,
+        context.status,
         baseRenderModel.history,
         baseRenderModel.segments.liveHead,
         baseRenderModel.turnTiming.byAssistantId,
@@ -580,6 +636,18 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [streamRenderStrategy],
     );
 
+    const setToolCallGroupExpanded = useCallback((groupId: string, expanded: boolean) => {
+      setExpandedToolCallGroupIds((previous) => {
+        const next = new Set(previous);
+        if (expanded) {
+          next.add(groupId);
+        } else {
+          next.delete(groupId);
+        }
+        return next;
+      });
+    }, []);
+
     const renderUserMessageItem = useCallback(
       (layoutItem: StreamLayoutItem, item: Extract<StreamItem, { kind: "user_message" }>) => {
         return (
@@ -591,14 +659,14 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             images={item.images}
             attachments={item.attachments}
             timestamp={item.timestamp.getTime()}
-            capabilities={agent.capabilities}
+            capabilities={context.capabilities}
             client={client}
             isFirstInGroup={layoutItem.isFirstInUserGroup}
             isLastInGroup={layoutItem.isLastInUserGroup}
           />
         );
       },
-      [agent.capabilities, agentId, client, resolvedServerId],
+      [context.capabilities, agentId, client, resolvedServerId],
     );
 
     const renderAssistantMessageItem = useCallback(
@@ -643,8 +711,12 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [autoExpandReasoning, setInlineDetailsExpanded],
     );
 
-    const renderToolCallItem = useCallback(
-      (layoutItem: StreamLayoutItem, item: Extract<StreamItem, { kind: "tool_call" }>) => {
+    const renderSingleToolCallItem = useCallback(
+      (
+        item: Extract<StreamItem, { kind: "tool_call" }>,
+        isLastInSequence: boolean,
+        maxDetailHeight?: number,
+      ) => {
         const { payload } = item;
 
         if (payload.source === "agent") {
@@ -669,10 +741,11 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
               error={data.error}
               status={data.status}
               detail={data.detail}
-              cwd={agent.cwd}
+              cwd={context.cwd}
               metadata={data.metadata}
-              isLastInSequence={layoutItem.isLastInToolSequence}
+              isLastInSequence={isLastInSequence}
               onOpenFilePath={handleToolCallOpenFile}
+              maxDetailHeight={maxDetailHeight}
             />
           );
         }
@@ -686,12 +759,49 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             args={data.arguments}
             result={data.result}
             status={data.status}
-            isLastInSequence={layoutItem.isLastInToolSequence}
+            isLastInSequence={isLastInSequence}
             onOpenFilePath={handleToolCallOpenFile}
+            maxDetailHeight={maxDetailHeight}
           />
         );
       },
-      [agent.cwd, setInlineDetailsExpanded, handleToolCallOpenFile],
+      [context.cwd, setInlineDetailsExpanded, handleToolCallOpenFile],
+    );
+
+    const renderToolCallItem = useCallback(
+      (layoutItem: StreamLayoutItem, item: Extract<StreamItem, { kind: "tool_call" }>) => {
+        const group = projectedToolCalls.groupsByHostId.get(item.id);
+        if (!group) {
+          return renderSingleToolCallItem(item, layoutItem.isLastInToolSequence);
+        }
+        const expanded = expandedToolCallGroupIds.has(group.run.id);
+        return (
+          <OverviewToolCallGroupView
+            group={group}
+            expanded={expanded}
+            isLastInSequence={layoutItem.isLastInToolSequence}
+            onExpandedChange={setToolCallGroupExpanded}
+          >
+            {expanded
+              ? group.run.calls.map((call, index) => (
+                  <React.Fragment key={call.id}>
+                    {renderSingleToolCallItem(
+                      call,
+                      index === group.run.calls.length - 1,
+                      GROUPED_TOOL_CALL_DETAIL_MAX_HEIGHT,
+                    )}
+                  </React.Fragment>
+                ))
+              : null}
+          </OverviewToolCallGroupView>
+        );
+      },
+      [
+        projectedToolCalls.groupsByHostId,
+        expandedToolCallGroupIds,
+        renderSingleToolCallItem,
+        setToolCallGroupExpanded,
+      ],
     );
 
     const renderStreamItemContent = useCallback(
@@ -748,10 +858,17 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           content,
           layoutItem,
           strategy: streamRenderStrategy,
-          onForkAssistantTurn: handleForkAssistantTurn,
+          supportsTimelineCursor: supportsAgentForkContextCursor,
+          onForkAssistantTurn: readOnly ? undefined : handleForkAssistantTurn,
         });
       },
-      [handleForkAssistantTurn, renderStreamItemContent, streamRenderStrategy],
+      [
+        handleForkAssistantTurn,
+        readOnly,
+        renderStreamItemContent,
+        streamRenderStrategy,
+        supportsAgentForkContextCursor,
+      ],
     );
 
     const pendingPermissionItems = useMemo(
@@ -759,7 +876,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [pendingPermissions, agentId],
     );
 
-    const showRunningTurnFooter = agent.status === "running";
+    const showRunningTurnFooter = context.status === "running";
     const pendingPermissionsNode = useMemo(
       () =>
         renderPendingPermissionsNode({
@@ -776,15 +893,18 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             inFlightTurnStartedAt={baseRenderModel.turnTiming.runningStartedAt}
             host={bottomTurnFooterHost}
             strategy={streamRenderStrategy}
-            onForkAssistantTurn={handleForkAssistantTurn}
+            supportsTimelineCursor={supportsAgentForkContextCursor}
+            onForkAssistantTurn={readOnly ? undefined : handleForkAssistantTurn}
           />
         ) : null,
       [
         handleForkAssistantTurn,
+        readOnly,
         showRunningTurnFooter,
         baseRenderModel.turnTiming.runningStartedAt,
         bottomTurnFooterHost,
         streamRenderStrategy,
+        supportsAgentForkContextCursor,
       ],
     );
     const renderModel = useMemo<AgentStreamRenderModel>(() => {
@@ -881,6 +1001,14 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     const streamScrollEnabled =
       !streamRenderStrategy.shouldDisableParentScrollOnInlineDetailsExpansion() ||
       expandedInlineToolCallIds.size === 0;
+    const historyRowRevision = useMemo(
+      () => ({
+        contentById: projectedToolCalls.historyGroupUpdatesByHostId,
+        displayStateById: expandedToolCallGroupIds,
+        globalDisplayState: isMobile,
+      }),
+      [expandedToolCallGroupIds, isMobile, projectedToolCalls.historyGroupUpdatesByHostId],
+    );
 
     return (
       <ToolCallSheetProvider>
@@ -889,6 +1017,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             {streamRenderStrategy.render({
               agentId,
               segments: renderModel.segments,
+              historyRowRevision,
+              liveHeadRowRevision: expandedToolCallGroupIds,
               boundary,
               renderers,
               listEmptyComponent,
@@ -906,12 +1036,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             })}
           </MessageOuterSpacingProvider>
           {!isNearBottom && (
-            <Animated.View
-              style={stylesheet.scrollToBottomContainer}
-              entering={scrollIndicatorFadeIn}
-              exiting={scrollIndicatorFadeOut}
-            >
-              <View style={stylesheet.scrollToBottomInner}>
+            <View style={stylesheet.scrollToBottomContainer} pointerEvents="box-none">
+              <Animated.View entering={scrollIndicatorFadeIn} exiting={scrollIndicatorFadeOut}>
                 <Pressable
                   style={stylesheet.scrollToBottomButton}
                   onPress={scrollToBottom}
@@ -921,8 +1047,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
                 >
                   <ChevronDown size={24} color={stylesheet.scrollToBottomIcon.color} />
                 </Pressable>
-              </View>
-            </Animated.View>
+              </Animated.View>
+            </View>
           )}
         </View>
       </ToolCallSheetProvider>
@@ -1005,6 +1131,17 @@ function bottomAnchorRouteRequestsEqual(
   );
 }
 
+function historyPaginationPropsEqual(
+  left: AgentStreamViewProps["historyPagination"],
+  right: AgentStreamViewProps["historyPagination"],
+): boolean {
+  return (
+    left?.hasOlder === right?.hasOlder &&
+    left?.isLoadingOlder === right?.isLoadingOlder &&
+    left?.onLoadOlder === right?.onLoadOlder
+  );
+}
+
 function agentStreamViewPropsEqual(
   left: AgentStreamViewProps,
   right: AgentStreamViewProps,
@@ -1012,8 +1149,9 @@ function agentStreamViewPropsEqual(
   const reasons: string[] = [];
   if (left.agentId !== right.agentId) reasons.push("agentId");
   if (left.serverId !== right.serverId) reasons.push("serverId");
-  reasons.push(...collectAgentScreenAgentDiffs(left.agent, right.agent));
+  reasons.push(...collectAgentScreenAgentDiffs(left.context, right.context));
   if (left.streamItems !== right.streamItems) reasons.push("streamItems");
+  if (left.streamHead !== right.streamHead) reasons.push("streamHead");
   if (left.pendingPermissions !== right.pendingPermissions) reasons.push("pendingPermissions");
   if (
     !bottomAnchorRouteRequestsEqual(left.routeBottomAnchorRequest, right.routeBottomAnchorRequest)
@@ -1025,6 +1163,10 @@ function agentStreamViewPropsEqual(
   }
   if (left.toast !== right.toast) reasons.push("toast");
   if (left.onOpenWorkspaceFile !== right.onOpenWorkspaceFile) reasons.push("onOpenWorkspaceFile");
+  if (left.readOnly !== right.readOnly) reasons.push("readOnly");
+  if (!historyPaginationPropsEqual(left.historyPagination, right.historyPagination)) {
+    reasons.push("historyPagination");
+  }
   recordRenderProfileReasons(`AgentStreamView:${right.agentId}`, reasons);
   return reasons.length === 0;
 }
@@ -1394,13 +1536,6 @@ const stylesheet = StyleSheet.create((theme) => ({
     left: 0,
     right: 0,
     alignItems: "center",
-    pointerEvents: "box-none",
-  },
-  scrollToBottomInner: {
-    width: "100%",
-    maxWidth: MAX_CONTENT_WIDTH,
-    alignSelf: "center",
-    alignItems: "center",
   },
   scrollToBottomButton: {
     width: 48,

packages/app/src/app/_layout.tsx

@@ -16,27 +16,38 @@ import {
   useState,
   useSyncExternalStore,
 } from "react";
-import { View } from "react-native";
+import { AppState, useWindowDimensions, View } from "react-native";
 import { GestureDetector, GestureHandlerRootView } from "react-native-gesture-handler";
 import { KeyboardProvider } from "react-native-keyboard-controller";
 import { SafeAreaProvider } from "react-native-safe-area-context";
 import { StyleSheet, UnistylesRuntime, useUnistyles } from "react-native-unistyles";
 import { CommandCenter } from "@/components/command-center";
+import { AddProjectFlowHost } from "@/components/add-project-flow-host";
 import { WorktreeSetupCalloutSource } from "@/components/worktree-setup-callout-source";
 import { DownloadToast } from "@/components/download-toast";
 import { QuittingOverlay } from "@/components/quitting-overlay";
 import { KeyboardShortcutsDialog } from "@/components/keyboard-shortcuts-dialog";
+import { AppDiagnosticHost } from "@/components/app-diagnostic-host";
 import { LeftSidebar } from "@/components/left-sidebar";
+import { WindowSidebarMenuToggle } from "@/components/headers/menu-header";
 import { SidebarModelProvider } from "@/components/sidebar/sidebar-model";
 import { CompactExplorerSidebarHost } from "@/components/compact-explorer-sidebar-host";
-import { ProjectPickerModal } from "@/components/project-picker-modal";
 import { ProviderSettingsHost } from "@/components/provider-settings-host";
 import { RootErrorBoundary } from "@/components/root-error-boundary";
 import { WorkspaceSetupDialog } from "@/components/workspace-setup-dialog";
 import { WorkspaceShortcutTargetsSubscriber } from "@/components/workspace-shortcut-targets-subscriber";
 import { FloatingPanelPortalHost } from "@/components/ui/floating-panel-portal";
 import { HostChooserModal, useHostChooser } from "@/hosts/host-chooser";
-import { getIsElectronRuntime, useIsCompactFormFactor } from "@/constants/layout";
+import {
+  getIsElectronRuntime,
+  HEADER_INNER_HEIGHT,
+  useIsCompactFormFactor,
+} from "@/constants/layout";
+import {
+  canDesktopAppSidebarShare,
+  resolveDesktopAppChromeLayout,
+  resolveDesktopAppContentMinimum,
+} from "@/components/desktop-sidebar-layout";
 import { isNative, isWeb } from "@/constants/platform";
 import { HorizontalScrollProvider } from "@/contexts/horizontal-scroll-context";
 import { SessionProvider } from "@/contexts/session-context";
@@ -52,6 +63,7 @@ import {
   type StartupBlocker,
 } from "@/navigation/host-runtime-bootstrap";
 import { registerWorkspaceRouteNavigationRef } from "@/navigation/workspace-route-navigation";
+import { ThemedStack } from "@/navigation/themed-stack";
 import { shouldUseDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
 import { listenToDesktopEvent } from "@/desktop/electron/events";
 import { updateDesktopWindowControls } from "@/desktop/electron/window";
@@ -84,10 +96,18 @@ import {
 } from "@/runtime/host-runtime";
 import { getDaemonStartService } from "@/runtime/daemon-start-service";
 import { applyAppearance } from "@/screens/settings/appearance/apply-appearance";
-import { usePanelStore } from "@/stores/panel-store";
+import { selectIsAgentListOpen, usePanelStore } from "@/stores/panel-store";
+import { flushDraftPersistStorage } from "@/stores/draft-store";
 import { THEME_TO_UNISTYLES, type ThemeName } from "@/styles/theme";
+import { installWebScrollbarStyles } from "@/styles/install-web-scrollbar-styles";
 import type { HostProfile } from "@/types/host-connection";
 import { toggleDesktopSidebarsWithCheckoutIntent } from "@/utils/desktop-sidebar-toggle";
+import {
+  useHasWindowChromeObstruction,
+  WindowChromeProvider,
+  WindowChromeRegion,
+  WindowChromeSafeArea,
+} from "@/utils/desktop-window";
 import { buildOpenProjectRoute, parseServerIdFromPathname } from "@/utils/host-routes";
 import { buildNotificationRoute, resolveNotificationTarget } from "@/utils/notification-routing";
 import { navigateToAgent } from "@/utils/navigate-to-agent";
@@ -395,6 +415,7 @@ interface AppContainerProps {
 }
 
 const THEME_CYCLE_ORDER: ThemeName[] = ["dark", "zinc", "midnight", "claude", "ghostty", "light"];
+const WINDOW_SIDEBAR_TOGGLE_HORIZONTAL_PADDING = 12;
 
 function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppContainerProps) {
   const daemons = useHosts();
@@ -406,6 +427,11 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
   const closeDesktopFileExplorer = usePanelStore((state) => state.closeDesktopFileExplorer);
   const toggleFocusMode = usePanelStore((state) => state.toggleFocusMode);
   const isFocusModeEnabled = usePanelStore((state) => state.desktop.focusModeEnabled);
+  const isDesktopAgentListOpen = usePanelStore((state) => state.desktop.agentListOpen);
+  const isDesktopFileExplorerOpen = usePanelStore((state) => state.desktop.fileExplorerOpen);
+  const sidebarWidth = usePanelStore((state) => state.sidebarWidth);
+  const explorerWidth = usePanelStore((state) => state.explorerWidth);
+  const { width: viewportWidth } = useWindowDimensions();
 
   const cycleTheme = useCallback(() => {
     const currentIndex = THEME_CYCLE_ORDER.indexOf(settings.theme as ThemeName);
@@ -451,15 +477,52 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
   useActiveWorktreeNewAction();
   useGlobalNewWorkspaceAction();
 
+  const appContentMinimumWidth = resolveDesktopAppContentMinimum({
+    isSettingsRoute: pathname.includes("/settings"),
+    isWorkspaceExplorerOpen: pathname.includes("/workspace/") && isDesktopFileExplorerOpen,
+    requestedExplorerWidth: explorerWidth,
+    viewportWidth,
+  });
+  const desktopSidebarMounted = chromeEnabled && !isFocusModeEnabled;
+  const desktopSidebarVisible =
+    !isCompactLayout &&
+    desktopSidebarMounted &&
+    isDesktopAgentListOpen &&
+    canDesktopAppSidebarShare({
+      contentMinimumWidth: appContentMinimumWidth,
+      requestedSidebarWidth: sidebarWidth,
+      viewportWidth,
+    });
+  const hasTopLeftWindowControls = useHasWindowChromeObstruction("top-left");
+  const appChromeLayout = resolveDesktopAppChromeLayout({
+    desktopSidebarRendered: desktopSidebarVisible,
+    hasTopLeftWindowControls,
+    sidebarControlsEnabled: chromeEnabled && !isFocusModeEnabled,
+  });
+  const sidebarChrome = (
+    <SidebarChrome
+      mounted={isCompactLayout ? chromeEnabled : desktopSidebarMounted}
+      visible={isCompactLayout ? chromeEnabled : desktopSidebarVisible}
+      keyboardShortcutsEnabled={keyboardShortcutsEnabled}
+    />
+  );
   const workspaceChrome = (
     <View style={rowStyle}>
-      {!isCompactLayout && chromeEnabled && !isFocusModeEnabled && <LeftSidebar />}
+      {!isCompactLayout ? (
+        <WindowChromeRegion corners={appChromeLayout.sidebarCorners}>
+          {sidebarChrome}
+        </WindowChromeRegion>
+      ) : null}
       {isCompactLayout && chromeEnabled ? (
         <CompactExplorerSidebarHost enabled={chromeEnabled}>
-          <View style={flexStyle}>{children}</View>
+          <WindowChromeRegion corners="both">
+            <View style={flexStyle}>{children}</View>
+          </WindowChromeRegion>
         </CompactExplorerSidebarHost>
       ) : (
-        <View style={flexStyle}>{children}</View>
+        <WindowChromeRegion corners={appChromeLayout.contentCorners}>
+          <View style={flexStyle}>{children}</View>
+        </WindowChromeRegion>
       )}
     </View>
   );
@@ -467,19 +530,31 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
   const surface = (
     <View style={layoutStyles.surfaceFill}>
       {workspaceChrome}
+      {!isCompactLayout && appChromeLayout.sidebarToggleOwner === "window" ? (
+        <WindowChromeRegion corners="top-left">
+          <WindowChromeSafeArea
+            placement="inline"
+            horizontalPadding={WINDOW_SIDEBAR_TOGGLE_HORIZONTAL_PADDING}
+            pointerEvents="box-none"
+            style={layoutStyles.windowSidebarToggle}
+          >
+            <WindowSidebarMenuToggle />
+          </WindowChromeSafeArea>
+        </WindowChromeRegion>
+      ) : null}
       <FloatingPanelPortalHost />
-      {isCompactLayout && chromeEnabled && <LeftSidebar />}
+      {isCompactLayout ? sidebarChrome : null}
       <DownloadToast />
       <RosettaCalloutSource />
       <UpdateCalloutSource />
       <WorktreeSetupCalloutSource />
       <CommandCenter />
+      <AddProjectFlowHost />
       <HostChooserModal />
-      <ProjectPickerModal />
       <ProviderSettingsHost />
-      <WorkspaceShortcutTargetsSubscriber enabled={keyboardShortcutsEnabled} />
       <WorkspaceSetupDialog />
       <KeyboardShortcutsDialog />
+      <AppDiagnosticHost />
       <QuittingOverlay />
     </View>
   );
@@ -490,7 +565,29 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
     surface
   );
 
-  return <SidebarModelProvider>{content}</SidebarModelProvider>;
+  return content;
+}
+
+function SidebarChrome({
+  mounted,
+  visible,
+  keyboardShortcutsEnabled,
+}: {
+  mounted: boolean;
+  visible: boolean;
+  keyboardShortcutsEnabled: boolean;
+}) {
+  const isCompactLayout = useIsCompactFormFactor();
+  const isOpen = usePanelStore((state) =>
+    selectIsAgentListOpen(state, { isCompact: isCompactLayout }),
+  );
+  const active = visible && isOpen;
+  return (
+    <SidebarModelProvider active={active}>
+      {mounted ? <LeftSidebar active={active} /> : null}
+      <WorkspaceShortcutTargetsSubscriber enabled={keyboardShortcutsEnabled} />
+    </SidebarModelProvider>
+  );
 }
 
 function MobileGestureWrapper({
@@ -504,7 +601,9 @@ function MobileGestureWrapper({
 
   return (
     <GestureDetector gesture={openGesture} touchAction={MOBILE_WEB_GESTURE_TOUCH_ACTION}>
-      {children}
+      <View collapsable={false} style={layoutStyles.surfaceFill}>
+        {children}
+      </View>
     </GestureDetector>
   );
 }
@@ -757,21 +856,15 @@ function FaviconStatusSync() {
   return null;
 }
 
+const ROOT_STACK_SCREEN_OPTIONS = {
+  headerShown: false,
+  animation: "none" as const,
+};
+
 function RootStack() {
   const storeReady = useStoreReady();
-  const { theme } = useUnistyles();
-  const stackScreenOptions = useMemo(
-    () => ({
-      headerShown: false,
-      animation: "none" as const,
-      contentStyle: {
-        backgroundColor: theme.colors.surface0,
-      },
-    }),
-    [theme.colors.surface0],
-  );
   return (
-    <Stack screenOptions={stackScreenOptions}>
+    <ThemedStack screenOptions={ROOT_STACK_SCREEN_OPTIONS}>
       <Stack.Screen name="index" />
       <Stack.Protected guard={storeReady}>
         <Stack.Screen name="welcome" />
@@ -788,7 +881,7 @@ function RootStack() {
       <Stack.Screen name="h/[serverId]" />
       <Stack.Screen name="settings/hosts/[serverId]/index" />
       <Stack.Screen name="settings/hosts/[serverId]/[hostSection]" />
-    </Stack>
+    </ThemedStack>
   );
 }
 
@@ -838,13 +931,15 @@ function RuntimeProviders({ children }: { children: ReactNode }) {
 function RootProviders({ children }: { children: ReactNode }) {
   return (
     <SafeAreaProvider>
-      <KeyboardProvider>
-        <KeyboardShiftProvider>
-          <PortalProvider>
-            <BottomSheetModalProvider>{children}</BottomSheetModalProvider>
-          </PortalProvider>
-        </KeyboardShiftProvider>
-      </KeyboardProvider>
+      <WindowChromeProvider>
+        <KeyboardProvider>
+          <KeyboardShiftProvider>
+            <PortalProvider>
+              <BottomSheetModalProvider>{children}</BottomSheetModalProvider>
+            </PortalProvider>
+          </KeyboardShiftProvider>
+        </KeyboardProvider>
+      </WindowChromeProvider>
     </SafeAreaProvider>
   );
 }
@@ -864,6 +959,16 @@ function RootAppTree() {
 }
 
 export default function RootLayout() {
+  useEffect(() => installWebScrollbarStyles(), []);
+  useEffect(() => {
+    const subscription = AppState.addEventListener("change", (nextState) => {
+      if (nextState !== "active") {
+        void flushDraftPersistStorage();
+      }
+    });
+    return () => subscription.remove();
+  }, []);
+
   return (
     <QueryProvider>
       <I18nProvider>
@@ -880,4 +985,15 @@ const layoutStyles = StyleSheet.create((theme) => ({
     flex: 1,
     backgroundColor: theme.colors.surface0,
   },
+  windowSidebarToggle: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    zIndex: 20,
+    height: HEADER_INNER_HEIGHT,
+    flexDirection: "row",
+    alignItems: "center",
+    borderBottomWidth: theme.borderWidth[1],
+    borderBottomColor: "transparent",
+  },
 }));

packages/app/src/app/h/[serverId]/_layout.tsx

@@ -2,6 +2,7 @@ import { Redirect, Stack, useLocalSearchParams } from "expo-router";
 import { useHostRuntimeBootstrapState } from "@/app/_layout";
 import { HostRouteProvider } from "@/navigation/host-route-context";
 import { resolveStartupRoute } from "@/navigation/host-runtime-bootstrap";
+import { ThemedStack } from "@/navigation/themed-stack";
 import { useHostRegistryStatus, useHosts } from "@/runtime/host-runtime";
 
 const HOST_STACK_SCREEN_OPTIONS = {
@@ -33,14 +34,14 @@ function KnownHostRoute() {
   }
 
   const stack = (
-    <Stack screenOptions={HOST_STACK_SCREEN_OPTIONS}>
+    <ThemedStack screenOptions={HOST_STACK_SCREEN_OPTIONS}>
       <Stack.Screen name="index" />
       <Stack.Screen name="workspace/[workspaceId]/index" />
       <Stack.Screen name="agent/[agentId]" options={AGENT_SCREEN_OPTIONS} />
       <Stack.Screen name="sessions" />
       <Stack.Screen name="open-project" />
       <Stack.Screen name="settings" />
-    </Stack>
+    </ThemedStack>
   );
 
   if (!routeServerId) {

packages/app/src/app/h/[serverId]/workspace/[workspaceId]/index.tsx

@@ -1,8 +1,9 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { useNavigation } from "@react-navigation/native";
 import { StyleSheet, View } from "react-native";
 import { useGlobalSearchParams, useLocalSearchParams, useRootNavigationState } from "expo-router";
 import { HostRouteBootstrapBoundary } from "@/components/host-route-bootstrap-boundary";
+import { RetainedPanel } from "@/components/retained-panel";
 import {
   type ActiveWorkspaceSelection,
   useActiveWorkspaceSelection,
@@ -15,6 +16,7 @@ import {
   areWorkspaceSelectionListsEqual,
   areWorkspaceSelectionsEqual,
   getWorkspaceSelectionKey,
+  orderWorkspaceSelectionsForStableRender,
   pruneMountedWorkspaceSelections,
   shouldKeepWorkspaceDeckEntryMounted,
   WORKSPACE_DECK_MAX_MOUNTED_WORKSPACES,
@@ -185,22 +187,25 @@ function WorkspaceDeck() {
     );
   }, []);
 
-  useEffect(() => {
-    if (!activeSelection) {
-      return;
-    }
-    setMountedSelections((current) => {
-      const next = pruneMountedWorkspaceSelections({
-        currentSelections: current,
+  const nextMountedSelections = useMemo(
+    () =>
+      pruneMountedWorkspaceSelections({
+        currentSelections: mountedSelections,
         activeSelection,
         maxMountedWorkspaces: WORKSPACE_DECK_MAX_MOUNTED_WORKSPACES,
-      });
-      if (areWorkspaceSelectionListsEqual(current, next)) {
-        return current;
-      }
-      return next;
-    });
-  }, [activeSelection]);
+      }),
+    [activeSelection, mountedSelections],
+  );
+  const renderedSelections = useMemo(
+    () => orderWorkspaceSelectionsForStableRender(nextMountedSelections),
+    [nextMountedSelections],
+  );
+
+  useLayoutEffect(() => {
+    if (!areWorkspaceSelectionListsEqual(mountedSelections, nextMountedSelections)) {
+      setMountedSelections(nextMountedSelections);
+    }
+  }, [mountedSelections, nextMountedSelections]);
 
   if (!activeSelection) {
     return null;
@@ -208,7 +213,7 @@ function WorkspaceDeck() {
 
   return (
     <View style={styles.deck}>
-      {mountedSelections.map((selection) => {
+      {renderedSelections.map((selection) => {
         return (
           <WorkspaceDeckEntry
             key={getWorkspaceSelectionKey(selection)}
@@ -251,8 +256,8 @@ function WorkspaceDeckEntry({
   }
 
   return (
-    <View
-      style={isActive ? styles.activeDeckEntry : styles.inactiveDeckEntry}
+    <RetainedPanel
+      active={isActive}
       testID={`workspace-deck-entry-${selection.serverId}:${selection.workspaceId}`}
     >
       <WorkspaceScreen
@@ -260,7 +265,7 @@ function WorkspaceDeckEntry({
         workspaceId={selection.workspaceId}
         isRouteFocused={isActive}
       />
-    </View>
+    </RetainedPanel>
   );
 }
 
@@ -268,11 +273,4 @@ const styles = StyleSheet.create({
   deck: {
     flex: 1,
   },
-  activeDeckEntry: {
-    flex: 1,
-  },
-  inactiveDeckEntry: {
-    display: "none",
-    flex: 1,
-  },
 });

packages/app/src/assistant-file-links/link.tsx

@@ -18,7 +18,6 @@ import { useStableEvent } from "@/hooks/use-stable-event";
 import { CODE_SURFACE_DATASET } from "@/styles/code-surface";
 import { useAssistantFileLinkResolverContext } from "./provider";
 import type { AssistantFileLinkSource } from "./resolver";
-import { formatFileLinkTooltipPath } from "./tooltip-path";
 import { useFileLink } from "./use-file-link";
 
 interface AssistantMarkdownLinkProps {
@@ -39,7 +38,7 @@ export function AssistantMarkdownLink({
   const { configRef } = useAssistantFileLinkResolverContext();
   const workspaceRoot = configRef.current.workspaceRoot;
   const tooltipPath = useMemo(
-    () => (target ? formatFileLinkTooltipPath({ target, workspaceRoot }) : null),
+    () => (target ? formatInlinePathTargetForTooltip(target, workspaceRoot) : null),
     [target, workspaceRoot],
   );
   const handleAnchorClickCapture = useStableEvent((event: MouseEvent<HTMLAnchorElement>) => {
@@ -148,6 +147,38 @@ export function AssistantMarkdownCodeLink({
   );
 }
 
+function formatInlinePathTargetForTooltip(
+  target: { path: string; lineStart?: number; lineEnd?: number },
+  workspaceRoot: string | undefined,
+): string {
+  let result = relativizePathToWorkspace(target.path, workspaceRoot);
+  if (target.lineStart) {
+    result += `:${target.lineStart}`;
+    if (target.lineEnd && target.lineEnd !== target.lineStart) {
+      result += `-${target.lineEnd}`;
+    }
+  }
+  return result;
+}
+
+function relativizePathToWorkspace(filePath: string, workspaceRoot: string | undefined): string {
+  if (!workspaceRoot) {
+    return filePath;
+  }
+  const root = workspaceRoot.replace(/\/+$/, "");
+  if (!root) {
+    return filePath;
+  }
+  if (filePath === root) {
+    return ".";
+  }
+  const prefix = `${root}/`;
+  if (filePath.startsWith(prefix)) {
+    return filePath.slice(prefix.length);
+  }
+  return filePath;
+}
+
 interface AssistantInlineCodePathLinkProps {
   content: string;
   inheritedStyles: TextStyle;

packages/app/src/assistant-file-links/tooltip-path.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatFileLinkTooltipPath } from "./tooltip-path";
-
-describe("formatFileLinkTooltipPath", () => {
-  it("shows a Windows file path relative to its workspace regardless of separators", () => {
-    expect(
-      formatFileLinkTooltipPath({
-        target: {
-          path: "C:/Users/me/repo/src/app.ts",
-          lineStart: 12,
-          lineEnd: 20,
-        },
-        workspaceRoot: "C:\\Users\\me\\repo",
-      }),
-    ).toBe("src/app.ts:12-20");
-  });
-
-  it("shows the workspace root as a dot", () => {
-    expect(
-      formatFileLinkTooltipPath({
-        target: { path: "/Users/me/repo" },
-        workspaceRoot: "/Users/me/repo",
-      }),
-    ).toBe(".");
-  });
-
-  it("keeps an absolute path outside the workspace", () => {
-    expect(
-      formatFileLinkTooltipPath({
-        target: { path: "/Users/me/notes.md" },
-        workspaceRoot: "/Users/me/repo",
-      }),
-    ).toBe("/Users/me/notes.md");
-  });
-
-  it("keeps the target path when the workspace root is unavailable", () => {
-    expect(formatFileLinkTooltipPath({ target: { path: "src/app.ts", lineStart: 12 } })).toBe(
-      "src/app.ts:12",
-    );
-  });
-});

packages/app/src/assistant-file-links/tooltip-path.ts

@@ -1,35 +0,0 @@
-import { resolveWorkspaceFilePaths, type WorkspaceFileLocation } from "@/workspace/file-open";
-import { normalizeWorkspacePath } from "@/utils/workspace-identity";
-
-interface FormatFileLinkTooltipPathInput {
-  target: WorkspaceFileLocation;
-  workspaceRoot?: string;
-}
-
-export function formatFileLinkTooltipPath({
-  target,
-  workspaceRoot,
-}: FormatFileLinkTooltipPathInput): string {
-  const normalizedTargetPath = normalizeWorkspacePath(target.path);
-  const normalizedWorkspaceRoot = normalizeWorkspacePath(workspaceRoot);
-  let isWorkspaceRoot = false;
-  if (normalizedTargetPath && normalizedWorkspaceRoot) {
-    isWorkspaceRoot = normalizedTargetPath === normalizedWorkspaceRoot;
-    if (/^[A-Za-z]:\//.test(normalizedTargetPath)) {
-      isWorkspaceRoot =
-        normalizedTargetPath.toLowerCase() === normalizedWorkspaceRoot.toLowerCase();
-    }
-  }
-
-  const resolvedPaths = workspaceRoot
-    ? resolveWorkspaceFilePaths({ path: target.path, workspaceRoot })
-    : null;
-  let result = isWorkspaceRoot ? "." : (resolvedPaths?.relativePath ?? target.path);
-  if (target.lineStart) {
-    result += `:${target.lineStart}`;
-    if (target.lineEnd && target.lineEnd !== target.lineStart) {
-      result += `-${target.lineEnd}`;
-    }
-  }
-  return result;
-}

packages/app/src/attachments/types.ts

@@ -79,15 +79,22 @@ export interface ChatHistoryContextAttachment {
     serverId: string;
     agentId: string;
     boundaryMessageId?: string | null;
+    boundaryCursor?: { epoch: string; seq: number } | null;
     itemCount?: number;
   };
 }
 
+export const NEW_WORKSPACE_PICKER_ATTACHMENT_OWNER = "new-workspace-picker";
+
 export type UserComposerAttachment =
   | { kind: "image"; metadata: AttachmentMetadata }
   | { kind: "file"; attachment: UploadedFileAttachment }
   | { kind: "github_issue"; item: GitHubSearchItem }
-  | { kind: "github_pr"; item: GitHubSearchItem };
+  | {
+      kind: "github_pr";
+      item: GitHubSearchItem;
+      owner?: typeof NEW_WORKSPACE_PICKER_ATTACHMENT_OWNER;
+    };
 
 export type WorkspaceComposerAttachment =
   | {

packages/app/src/attachments/utils.test.ts

@@ -34,6 +34,10 @@ describe("fileUriToPath", () => {
   it("converts Windows drive-letter file URIs back to paths", () => {
     expect(fileUriToPath("file:///C:/Users/file.txt")).toBe("C:/Users/file.txt");
   });
+
+  it("converts host-based file URIs back to UNC paths", () => {
+    expect(fileUriToPath("file://server/share/shot%231.png")).toBe("\\\\server\\share\\shot#1.png");
+  });
 });
 
 describe("localFileSourceToPath", () => {

packages/app/src/attachments/utils.ts

@@ -162,7 +162,11 @@ export function fileUriToPath(uri: string): string {
   if (!uri.startsWith("file://")) {
     return uri;
   }
-  const decodedPath = decodeFilePathSource(uri.replace(/^file:\/\//, ""));
+  const fileSource = uri.slice("file://".length);
+  const decodedPath = decodeFilePathSource(fileSource);
+  if (!fileSource.startsWith("/")) {
+    return `\\\\${decodedPath.replace(/\//g, "\\")}`;
+  }
   return normalizeWindowsDrivePath(decodedPath.replace(/^\/([A-Za-z]:[\\/])/, "$1"));
 }
 

packages/app/src/browser-automation/handler.test.ts

@@ -73,10 +73,7 @@ class FakeDaemonClient {
 
 class FakeBrowserBridge {
   public readonly executedRequests: BrowserAutomationExecuteRequest[] = [];
-  public readonly registeredWorkspaceBrowsers: Array<{ browserId: string; workspaceId: string }> =
-    [];
   public readonly unregisteredWorkspaceBrowsers: string[] = [];
-  public readonly clearedPartitions: string[] = [];
   public readonly activeWorkspaceBrowsers: Array<{
     browserId: string | null;
     workspaceId: string;
@@ -94,21 +91,10 @@ class FakeBrowserBridge {
     return this.response ?? currentListTabsPayload(request.requestId);
   };
 
-  public registerWorkspaceBrowser = async (input: {
-    browserId: string;
-    workspaceId: string;
-  }): Promise<void> => {
-    this.registeredWorkspaceBrowsers.push(input);
-  };
-
   public unregisterWorkspaceBrowser = async (browserId: string): Promise<void> => {
     this.unregisteredWorkspaceBrowsers.push(browserId);
   };
 
-  public clearPartition = async (browserId: string): Promise<void> => {
-    this.clearedPartitions.push(browserId);
-  };
-
   public setWorkspaceActiveBrowser = async (input: {
     browserId: string | null;
     workspaceId: string;
@@ -118,9 +104,17 @@ class FakeBrowserBridge {
 }
 
 class FakeResidentBrowser {
-  public readonly ensuredWebviews: Array<{ browserId: string; url: string }> = [];
+  public readonly ensuredWebviews: Array<{
+    browserId: string;
+    workspaceId: string;
+    url: string;
+  }> = [];
 
-  public ensure = (input: { browserId: string; url: string }): HTMLElement | null => {
+  public ensure = (input: {
+    browserId: string;
+    workspaceId: string;
+    url: string;
+  }): HTMLElement | null => {
     this.ensuredWebviews.push(input);
     return null;
   };
@@ -321,12 +315,13 @@ describe("mountBrowserAutomationHandler", () => {
       }),
     );
     expect(openedTabs[0]?.tabId).not.toBe(previousFocusedTabId);
-    expect(browser.browser.registeredWorkspaceBrowsers).toEqual([
-      { browserId: result.browserId, workspaceId: "wks_workspace_a" },
-    ]);
     expect(browser.browser.activeWorkspaceBrowsers).toEqual([]);
     expect(browser.resident.ensuredWebviews).toEqual([
-      { browserId: result.browserId, url: "https://example.com" },
+      {
+        browserId: result.browserId,
+        workspaceId: "wks_workspace_a",
+        url: "https://example.com",
+      },
     ]);
     expect(browser.browser.executedRequests).toEqual([
       {
@@ -366,7 +361,10 @@ describe("mountBrowserAutomationHandler", () => {
       },
     ]);
     expect(browser.resident.ensuredWebviews).toEqual([
-      expect.objectContaining({ url: "https://example.com" }),
+      expect.objectContaining({
+        workspaceId: "wks_workspace_a",
+        url: "https://example.com",
+      }),
     ]);
   });
 
@@ -440,7 +438,7 @@ describe("mountBrowserAutomationHandler", () => {
     });
   });
 
-  test("browser_close_tab removes the workspace tab, browser record, resident webview, registry entry, and partition", async () => {
+  test("browser_close_tab removes the workspace tab, browser record, resident webview, and registry entry", async () => {
     const browser = new BrowserAutomationHandlerHarness();
     const workspaceKey = buildWorkspaceTabPersistenceKey({
       serverId: "server-1",
@@ -466,7 +464,6 @@ describe("mountBrowserAutomationHandler", () => {
     expect(workspaceBrowserTabs(workspaceKey, result.browserId)).toEqual([]);
     expect(useBrowserStore.getState().browsersById[result.browserId]).toBeUndefined();
     expect(browser.browser.unregisteredWorkspaceBrowsers).toEqual([result.browserId]);
-    expect(browser.browser.clearedPartitions).toEqual([result.browserId]);
     expect(currentBrowserTabs()).toEqual([]);
   });
 

packages/app/src/browser-automation/handler.ts

@@ -258,7 +258,6 @@ async function closeBrowserTabForRequest(params: {
   useBrowserStore.getState().removeBrowser(browserId);
   removeResidentBrowserWebview(browserId);
   await browserHost?.unregisterWorkspaceBrowser?.(browserId);
-  await browserHost?.clearPartition?.(browserId);
 
   return {
     requestId: request.requestId,
@@ -337,10 +336,8 @@ async function openBrowserTabForRequest(params: {
     browserId,
   });
 
-  await browserHost?.registerWorkspaceBrowser?.({ browserId, workspaceId });
-
   if (browserHost?.executeAutomationCommand) {
-    ensureResidentBrowserWebview({ browserId, url: normalizedUrl });
+    ensureResidentBrowserWebview({ browserId, workspaceId, url: normalizedUrl });
     const registered = await waitForBrowserRegistration({
       request,
       browserId,

packages/app/src/components/adaptive-modal-sheet.tsx

@@ -22,7 +22,6 @@ import {
 import { getCompactSheetSafeAreaPadding } from "@/components/adaptive-modal-sheet-layout";
 import { createControlGeometry } from "@/components/ui/control-geometry";
 import { isNative, isWeb } from "@/constants/platform";
-import { useWebScrollViewScrollbar } from "@/components/use-web-scrollbar";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
 // Horizontal indent token shared by the sheet header (title, back arrow,
@@ -460,11 +459,6 @@ export interface AdaptiveModalSheetProps {
   desktopMaxWidth?: number;
   scrollable?: boolean;
   presentation?: "push" | "replace";
-  /**
-   * Render the themed desktop-web scrollbar over the scroll area instead of the
-   * native browser scrollbar. No-op on native and on the mobile bottom sheet.
-   */
-  webScrollbar?: boolean;
 }
 
 export function AdaptiveModalSheet({
@@ -479,16 +473,11 @@ export function AdaptiveModalSheet({
   desktopMaxWidth,
   scrollable = true,
   presentation,
-  webScrollbar = false,
 }: AdaptiveModalSheetProps) {
   const { theme } = useUnistyles();
   const { t } = useTranslation();
   const isMobile = useIsCompactFormFactor();
   const insets = useSafeAreaInsets();
-  const desktopScrollRef = useRef<ScrollView>(null);
-  const desktopScrollbar = useWebScrollViewScrollbar(desktopScrollRef, {
-    enabled: webScrollbar && !isMobile,
-  });
   const resolvedSnapPoints = useMemo(() => snapPoints ?? ["65%", "90%"], [snapPoints]);
   const compactSafeAreaPadding = useMemo(
     () =>
@@ -651,19 +640,13 @@ export function AdaptiveModalSheet({
       {scrollable ? (
         <View style={styles.desktopScrollContainer}>
           <ScrollView
-            ref={desktopScrollRef}
             style={styles.desktopScroll}
             contentContainerStyle={styles.desktopContent}
             keyboardShouldPersistTaps="handled"
-            onLayout={desktopScrollbar.onLayout}
-            onScroll={desktopScrollbar.onScroll}
-            onContentSizeChange={desktopScrollbar.onContentSizeChange}
-            scrollEventThrottle={16}
-            showsVerticalScrollIndicator={!webScrollbar}
+            showsVerticalScrollIndicator
           >
             {children}
           </ScrollView>
-          {desktopScrollbar.overlay}
         </View>
       ) : (
         <View style={styles.desktopStaticContent}>{children}</View>

packages/app/src/components/add-host-method-modal.tsx

@@ -4,6 +4,7 @@ import { Pressable, Text, View } from "react-native";
 import { StyleSheet, useUnistyles } from "react-native-unistyles";
 import { QrCode, Link2, ClipboardPaste } from "lucide-react-native";
 import { AdaptiveModalSheet, type SheetHeader } from "./adaptive-modal-sheet";
+import { isFdroidBuild } from "@/constants/build-profile";
 import { isNative } from "@/constants/platform";
 
 const styles = StyleSheet.create((theme) => ({
@@ -86,7 +87,7 @@ export function AddHostMethodModal({
         </View>
       </Pressable>
 
-      {isNative ? (
+      {isNative && !isFdroidBuild ? (
         <Pressable
           style={styles.option}
           onPress={handleScan}

packages/app/src/components/add-project-flow-host.tsx

@@ -0,0 +1,11 @@
+import { AddProjectFlow } from "@/components/add-project-flow";
+import { useAddProjectFlowStore } from "@/stores/add-project-flow-store";
+
+export function AddProjectFlowHost() {
+  const request = useAddProjectFlowStore((state) => state.request);
+  const close = useAddProjectFlowStore((state) => state.close);
+
+  if (!request) return null;
+
+  return <AddProjectFlow key={request.id} request={request} onClose={close} />;
+}

packages/app/src/components/app-diagnostic-host.tsx

@@ -0,0 +1,18 @@
+import { AppDiagnosticSheet } from "@/components/app-diagnostic-sheet";
+import { isElectronRuntime } from "@/desktop/host";
+import { useAppDiagnosticStore } from "@/diagnostics/store";
+import { resolveAppVersion } from "@/utils/app-version";
+
+export function AppDiagnosticHost() {
+  const visible = useAppDiagnosticStore((state) => state.visible);
+  const close = useAppDiagnosticStore((state) => state.close);
+
+  return (
+    <AppDiagnosticSheet
+      visible={visible}
+      onClose={close}
+      appVersion={resolveAppVersion()}
+      isDesktopApp={isElectronRuntime()}
+    />
+  );
+}

packages/app/src/components/attachment-lightbox.tsx

@@ -8,6 +8,7 @@ import { useTranslation } from "react-i18next";
 import type { AttachmentMetadata } from "@/attachments/types";
 import { useAttachmentPreviewUrl } from "@/attachments/use-attachment-preview-url";
 import { isWeb } from "@/constants/platform";
+import { WindowChromeRootRegion, WindowChromeSafeArea } from "@/utils/desktop-window";
 
 interface AttachmentLightboxProps {
   metadata: AttachmentMetadata | null;
@@ -38,15 +39,18 @@ export function AttachmentLightbox({ metadata, onClose }: AttachmentLightboxProp
     };
   }, [metadata, onClose]);
 
-  const closeButtonStyle = useMemo(
+  const closeButtonRowStyle = useMemo(
     () => [
-      styles.closeButton,
+      styles.closeButtonRow,
       {
         top: insets.top + theme.spacing[3],
-        right: insets.right + theme.spacing[3],
       },
     ],
-    [insets.top, insets.right, theme.spacing],
+    [insets.top, theme.spacing],
+  );
+  const closeButtonStyle = useMemo(
+    () => [styles.closeButton, { marginRight: insets.right + theme.spacing[3] }],
+    [insets.right, theme.spacing],
   );
 
   const handleImageError = useCallback(() => setErrored(true), []);
@@ -61,42 +65,46 @@ export function AttachmentLightbox({ metadata, onClose }: AttachmentLightboxProp
 
   return (
     <Modal transparent animationType="fade" statusBarTranslucent visible onRequestClose={onClose}>
-      <View style={styles.root}>
-        <Pressable
-          testID="attachment-lightbox-backdrop"
-          accessibilityRole="button"
-          accessibilityLabel={t("message.attachments.dismissImage")}
-          onPress={onClose}
-          style={styles.backdrop}
-        />
-        <View style={styles.contentLayer}>
-          <View style={styles.imageArea}>
-            {hasError ? (
-              <Text style={styles.errorText}>{t("message.attachments.imageLoadFailed")}</Text>
-            ) : (
-              <Pressable onPress={noopPress} style={styles.imagePressable}>
-                <ExpoImage
-                  testID="attachment-lightbox-image"
-                  source={imageSource}
-                  contentFit="contain"
-                  onError={handleImageError}
-                  style={imageFillStyle}
-                />
-              </Pressable>
-            )}
-          </View>
+      <WindowChromeRootRegion corners="both">
+        <View style={styles.root}>
           <Pressable
-            testID="attachment-lightbox-close"
+            testID="attachment-lightbox-backdrop"
             accessibilityRole="button"
-            accessibilityLabel={t("message.attachments.closeImage")}
-            hitSlop={8}
+            accessibilityLabel={t("message.attachments.dismissImage")}
             onPress={onClose}
-            style={closeButtonStyle}
-          >
-            <X size={16} color={theme.colors.foregroundMuted} />
-          </Pressable>
+            style={styles.backdrop}
+          />
+          <View style={styles.contentLayer}>
+            <View style={styles.imageArea}>
+              {hasError ? (
+                <Text style={styles.errorText}>{t("message.attachments.imageLoadFailed")}</Text>
+              ) : (
+                <Pressable onPress={noopPress} style={styles.imagePressable}>
+                  <ExpoImage
+                    testID="attachment-lightbox-image"
+                    source={imageSource}
+                    contentFit="contain"
+                    onError={handleImageError}
+                    style={imageFillStyle}
+                  />
+                </Pressable>
+              )}
+            </View>
+            <WindowChromeSafeArea placement="inline" style={closeButtonRowStyle}>
+              <Pressable
+                testID="attachment-lightbox-close"
+                accessibilityRole="button"
+                accessibilityLabel={t("message.attachments.closeImage")}
+                hitSlop={8}
+                onPress={onClose}
+                style={closeButtonStyle}
+              >
+                <X size={16} color={theme.colors.foregroundMuted} />
+              </Pressable>
+            </WindowChromeSafeArea>
+          </View>
         </View>
-      </View>
+      </WindowChromeRootRegion>
     </Modal>
   );
 }
@@ -129,6 +137,13 @@ const styles = StyleSheet.create((theme) => ({
     bottom: 0,
     pointerEvents: "box-none",
   },
+  closeButtonRow: {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    alignItems: "flex-end",
+    pointerEvents: "box-none",
+  },
   imageArea: {
     flex: 1,
     alignItems: "center",
@@ -148,7 +163,6 @@ const styles = StyleSheet.create((theme) => ({
     fontSize: theme.fontSize.sm,
   },
   closeButton: {
-    position: "absolute",
     width: 32,
     height: 32,
     borderRadius: 16,

packages/app/src/components/browser-pane.electron.tsx

@@ -740,10 +740,10 @@ export function BrowserPane({
     const residentWebview = takeResidentBrowserWebview(browserId) as ElectronWebview | null;
     const webview = residentWebview ?? (document.createElement("webview") as ElectronWebview);
     webviewRef.current = webview;
-    void getDesktopHost()?.browser?.registerWorkspaceBrowser?.({ browserId, workspaceId });
     if (!residentWebview) {
       prepareBrowserWebview(webview, {
         browserId,
+        workspaceId,
         initialUrl: initialUnsafeNavigationMessage ? "about:blank" : initialUrlRef.current,
       });
     }

packages/app/src/components/browser-webview-resident.browser.test.ts

@@ -1,5 +1,6 @@
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
+  type BrowserWebviewProfileHost,
   clearResidentBrowserWebviewsForTests,
   ensureResidentBrowserWebview,
   prepareBrowserWebview,
@@ -9,6 +10,32 @@ import {
 } from "./browser-webview-resident";
 
 const RESIDENT_HOST_ID = "paseo-browser-resident-webviews";
+const attachedBrowsers: Array<{
+  browserId: string;
+  workspaceId: string;
+  webContentsId: number;
+}> = [];
+const profileHost: BrowserWebviewProfileHost = {
+  profilePartition: "persist:paseo-browser",
+  registerAttachedBrowser: async (input) => {
+    attachedBrowsers.push(input);
+  },
+};
+
+function ensureTestBrowser(input: {
+  browserId: string;
+  workspaceId: string;
+  url: string;
+}): HTMLElement | null {
+  return ensureResidentBrowserWebview({ ...input, profileHost });
+}
+
+function prepareTestBrowser(
+  webview: HTMLElement,
+  input: { browserId: string; workspaceId: string; initialUrl?: string | null },
+): void {
+  prepareBrowserWebview(webview, { ...input, profileHost });
+}
 
 function residentHost(): HTMLElement {
   const host = document.getElementById(RESIDENT_HOST_ID);
@@ -44,6 +71,10 @@ function expectResidentWebviewParking(webview: HTMLElement): void {
 }
 
 describe("resident browser webviews", () => {
+  beforeEach(() => {
+    attachedBrowsers.length = 0;
+  });
+
   afterEach(() => {
     clearResidentBrowserWebviewsForTests();
   });
@@ -65,15 +96,16 @@ describe("resident browser webviews", () => {
   });
 
   it("creates a resident webview for an agent-created unfocused tab", () => {
-    const webview = ensureResidentBrowserWebview({
+    const webview = ensureTestBrowser({
       browserId: "browser-agent",
+      workspaceId: "workspace-agent",
       url: "https://example.com",
     });
 
     expect(webview).not.toBeNull();
     expect(webview?.isConnected).toBe(true);
     expect(webview?.getAttribute("data-paseo-browser-id")).toBe("browser-agent");
-    expect(webview?.getAttribute("partition")).toBe("persist:paseo-browser-browser-agent");
+    expect(webview?.getAttribute("partition")).toBe("persist:paseo-browser");
     expect((webview as HTMLUnknownElement & { src?: string })?.src).toContain(
       "https://example.com",
     );
@@ -81,6 +113,34 @@ describe("resident browser webviews", () => {
     expectResidentWebviewParking(webview as HTMLElement);
   });
 
+  it("shares one profile and registers attached guests with explicit identity", () => {
+    const firstWebview = ensureTestBrowser({
+      browserId: "browser-first",
+      workspaceId: "workspace-a",
+      url: "https://example.com/first",
+    });
+    const secondWebview = ensureTestBrowser({
+      browserId: "browser-second",
+      workspaceId: "workspace-b",
+      url: "https://example.com/second",
+    });
+    if (!firstWebview || !secondWebview) {
+      throw new Error("Expected resident webviews");
+    }
+    Object.assign(firstWebview, { getWebContentsId: () => 101 });
+    Object.assign(secondWebview, { getWebContentsId: () => 202 });
+
+    firstWebview.dispatchEvent(new Event("did-attach"));
+    secondWebview.dispatchEvent(new Event("did-attach"));
+
+    expect(firstWebview.getAttribute("partition")).toBe("persist:paseo-browser");
+    expect(secondWebview.getAttribute("partition")).toBe("persist:paseo-browser");
+    expect(attachedBrowsers).toEqual([
+      { browserId: "browser-first", workspaceId: "workspace-a", webContentsId: 101 },
+      { browserId: "browser-second", workspaceId: "workspace-b", webContentsId: 202 },
+    ]);
+  });
+
   it("normalizes an existing resident host back to permanent parking", () => {
     const staleHost = document.createElement("div");
     staleHost.id = RESIDENT_HOST_ID;
@@ -91,8 +151,9 @@ describe("resident browser webviews", () => {
     staleHost.style.display = "none";
     document.body.appendChild(staleHost);
 
-    const webview = ensureResidentBrowserWebview({
+    const webview = ensureTestBrowser({
       browserId: "browser-stale-host",
+      workspaceId: "workspace-stale-host",
       url: "https://example.com",
     });
 
@@ -111,8 +172,9 @@ describe("resident browser webviews", () => {
     staleHost.style.display = "none";
 
     const staleWebview = document.createElement("webview");
-    prepareBrowserWebview(staleWebview, {
+    prepareTestBrowser(staleWebview, {
       browserId: "browser-stale-child",
+      workspaceId: "workspace-stale-child",
       initialUrl: "https://example.com",
     });
     staleWebview.style.display = "none";
@@ -123,8 +185,9 @@ describe("resident browser webviews", () => {
     staleHost.appendChild(staleWebview);
     document.body.appendChild(staleHost);
 
-    const webview = ensureResidentBrowserWebview({
+    const webview = ensureTestBrowser({
       browserId: "browser-stale-child",
+      workspaceId: "workspace-stale-child",
       url: "https://example.com/agent",
     });
 
@@ -135,12 +198,14 @@ describe("resident browser webviews", () => {
   });
 
   it("parks resident webviews as an overlapping stack", () => {
-    const firstWebview = ensureResidentBrowserWebview({
+    const firstWebview = ensureTestBrowser({
       browserId: "browser-first",
+      workspaceId: "workspace-stack",
       url: "https://example.com/first",
     });
-    const secondWebview = ensureResidentBrowserWebview({
+    const secondWebview = ensureTestBrowser({
       browserId: "browser-second",
+      workspaceId: "workspace-stack",
       url: "https://example.com/second",
     });
 
@@ -152,8 +217,9 @@ describe("resident browser webviews", () => {
   });
 
   it("moves a resident webview into a visible pane without recreating the node", () => {
-    const webview = ensureResidentBrowserWebview({
+    const webview = ensureTestBrowser({
       browserId: "browser-visible",
+      workspaceId: "workspace-visible",
       url: "https://example.com",
     });
 
@@ -170,15 +236,17 @@ describe("resident browser webviews", () => {
   it("returns an existing visible pane webview instead of creating a resident duplicate", () => {
     const visibleHost = document.createElement("div");
     const visibleWebview = document.createElement("webview");
-    prepareBrowserWebview(visibleWebview, {
+    prepareTestBrowser(visibleWebview, {
       browserId: "browser-visible-pane",
+      workspaceId: "workspace-visible-pane",
       initialUrl: "https://example.com",
     });
     visibleHost.appendChild(visibleWebview);
     document.body.appendChild(visibleHost);
 
-    const webview = ensureResidentBrowserWebview({
+    const webview = ensureTestBrowser({
       browserId: "browser-visible-pane",
+      workspaceId: "workspace-visible-pane",
       url: "https://example.com/agent",
     });
 
@@ -187,8 +255,9 @@ describe("resident browser webviews", () => {
   });
 
   it("removes a resident webview when its browser tab closes", () => {
-    const webview = ensureResidentBrowserWebview({
+    const webview = ensureTestBrowser({
       browserId: "browser-closed",
+      workspaceId: "workspace-closed",
       url: "https://example.com",
     });
 

packages/app/src/components/browser-webview-resident.ts

@@ -1,3 +1,9 @@
+import {
+  getDesktopHost,
+  type DesktopAttachedBrowserRegistration,
+  type DesktopBrowserBridge,
+} from "@/desktop/host";
+
 const RESIDENT_BROWSER_HOST_ID = "paseo-browser-resident-webviews";
 const BROWSER_ID_ATTRIBUTE = "data-paseo-browser-id";
 const RESIDENT_VIEWPORT_WIDTH = 1280;
@@ -8,6 +14,62 @@ const residentWebviewSizesByBrowserId = new Map<string, { width: number; height:
 
 interface BrowserWebviewElement extends HTMLElement {
   src: string;
+  getWebContentsId(): number;
+}
+
+interface BrowserWebviewIdentity {
+  browserId: string;
+  workspaceId: string;
+}
+
+export interface BrowserWebviewProfileHost {
+  profilePartition: string;
+  registerAttachedBrowser(input: DesktopAttachedBrowserRegistration): Promise<void>;
+}
+
+function isAttachedBrowserBridge(
+  browser: DesktopBrowserBridge | undefined,
+): browser is BrowserWebviewProfileHost {
+  return (
+    browser !== undefined &&
+    typeof browser.profilePartition === "string" &&
+    browser.profilePartition.startsWith("persist:") &&
+    typeof browser.registerAttachedBrowser === "function"
+  );
+}
+
+function getBrowserBridge(override?: BrowserWebviewProfileHost): BrowserWebviewProfileHost {
+  if (override) {
+    return override;
+  }
+  const browser = getDesktopHost()?.browser;
+  if (!isAttachedBrowserBridge(browser)) {
+    throw new Error("Electron browser profile bridge is unavailable");
+  }
+  return browser;
+}
+
+function registerBrowserWhenAttached(
+  webview: BrowserWebviewElement,
+  identity: BrowserWebviewIdentity,
+  browser: BrowserWebviewProfileHost,
+): void {
+  webview.addEventListener(
+    "did-attach",
+    () => {
+      const webContentsId = webview.getWebContentsId();
+      void browser
+        .registerAttachedBrowser({
+          browserId: identity.browserId,
+          workspaceId: identity.workspaceId,
+          webContentsId,
+        })
+        .catch((error) => {
+          console.error("[browser-webview] attached registration failed", error);
+        });
+    },
+    { once: true },
+  );
 }
 
 function trimNonEmpty(value: string | null | undefined): string | null {
@@ -104,21 +166,30 @@ function clearResidentWebviewParkingStyle(webview: HTMLElement): void {
 
 export function prepareBrowserWebview(
   webview: HTMLElement,
-  input: { browserId: string; initialUrl?: string | null },
+  input: {
+    browserId: string;
+    workspaceId: string;
+    initialUrl?: string | null;
+    profileHost?: BrowserWebviewProfileHost;
+  },
 ): void {
+  const browser = getBrowserBridge(input.profileHost);
   webview.setAttribute(BROWSER_ID_ATTRIBUTE, input.browserId);
-  webview.setAttribute("partition", `persist:paseo-browser-${input.browserId}`);
+  webview.setAttribute("partition", browser.profilePartition);
   webview.setAttribute("allowpopups", "true");
   webview.setAttribute("spellcheck", "false");
   webview.setAttribute("autosize", "on");
   if (input.initialUrl) {
     (webview as BrowserWebviewElement).src = input.initialUrl;
   }
+  registerBrowserWhenAttached(webview as BrowserWebviewElement, input, browser);
 }
 
 export function ensureResidentBrowserWebview(input: {
   browserId: string;
+  workspaceId: string;
   url: string;
+  profileHost?: BrowserWebviewProfileHost;
 }): HTMLElement | null {
   const browserId = trimNonEmpty(input.browserId);
   if (!browserId) {
@@ -144,7 +215,12 @@ export function ensureResidentBrowserWebview(input: {
   }
 
   const webview = ownerDocument.createElement("webview") as BrowserWebviewElement;
-  prepareBrowserWebview(webview, { browserId, initialUrl: input.url });
+  prepareBrowserWebview(webview, {
+    browserId,
+    workspaceId: input.workspaceId,
+    initialUrl: input.url,
+    profileHost: input.profileHost,
+  });
   releaseResidentBrowserWebview(browserId, webview);
   return webview;
 }

packages/app/src/components/command-center.tsx

@@ -9,13 +9,15 @@ import {
 } from "react-native";
 import { memo, useCallback, useEffect, useMemo, useRef, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
-import { Home, Plus, Settings } from "lucide-react-native";
+import { Folder, Home, Plus, Settings } from "lucide-react-native";
 import { StyleSheet, useUnistyles, withUnistyles } from "react-native-unistyles";
-import { useCommandCenter } from "@/hooks/use-command-center";
-import type { AggregatedAgent } from "@/hooks/use-aggregated-agents";
-import { useHosts } from "@/runtime/host-runtime";
-import { formatTimeAgo } from "@/utils/time";
-import { shortenPath } from "@/utils/shorten-path";
+import {
+  useCommandCenter,
+  type CommandCenterActionItem,
+  type CommandCenterAgentItem,
+  type CommandCenterItem,
+  type CommandCenterWorkspaceItem,
+} from "@/hooks/use-command-center";
 import { AgentStatusDot } from "@/components/agent-status-dot";
 import { Shortcut } from "@/components/ui/shortcut";
 import { isNative, isWeb } from "@/constants/platform";
@@ -30,13 +32,12 @@ import {
   BottomSheetTextInput,
 } from "@gorhom/bottom-sheet";
 
-function agentKey(agent: Pick<AggregatedAgent, "serverId" | "id">): string {
-  return `${agent.serverId}:${agent.id}`;
-}
-
 const ThemedBottomSheetTextInput = withUnistyles(BottomSheetTextInput, (theme) => ({
   placeholderTextColor: theme.colors.foregroundMuted,
 }));
+const ThemedFolder = withUnistyles(Folder, (theme) => ({
+  color: theme.colors.foregroundMuted,
+}));
 
 interface CommandCenterRowProps {
   active: boolean;
@@ -73,22 +74,25 @@ const CommandCenterRow = memo(function CommandCenterRow({
 });
 
 interface CommandCenterRowContainerProps {
+  item: CommandCenterItem;
   rowIndex: number;
   active: boolean;
   rowRefs: React.MutableRefObject<Map<number, View>>;
-  onPress: () => void;
+  onSelect: (item: CommandCenterItem) => void;
   onLayout?: (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
   children: ReactNode;
 }
 
 function CommandCenterRowContainer({
+  item,
   rowIndex,
   active,
   rowRefs,
-  onPress,
+  onSelect,
   onLayout,
   children,
 }: CommandCenterRowContainerProps) {
+  const handlePress = useCallback(() => onSelect(item), [onSelect, item]);
   const registerRow = useCallback(
     (el: View | null) => {
       if (el) rowRefs.current.set(rowIndex, el);
@@ -100,7 +104,7 @@ function CommandCenterRowContainer({
     <CommandCenterRow
       active={active}
       registerRow={registerRow}
-      onPress={onPress}
+      onPress={handlePress}
       onLayout={onLayout}
     >
       {children}
@@ -109,12 +113,12 @@ function CommandCenterRowContainer({
 }
 
 interface CommandCenterActionRowProps {
-  item: Extract<ReturnType<typeof useCommandCenter>["items"][number], { kind: "action" }>;
+  item: CommandCenterActionItem;
   rowIndex: number;
   active: boolean;
   rowRefs: React.MutableRefObject<Map<number, View>>;
   onLayout?: (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  onSelect: (item: ReturnType<typeof useCommandCenter>["items"][number]) => void;
+  onSelect: (item: CommandCenterItem) => void;
 }
 
 function CommandCenterActionRow({
@@ -126,14 +130,12 @@ function CommandCenterActionRow({
   onSelect,
 }: CommandCenterActionRowProps) {
   const { theme } = useUnistyles();
-  const handlePress = useCallback(() => onSelect(item), [onSelect, item]);
-  const action = item.action;
   let actionIcon: React.ReactNode = null;
-  if (action.icon === "plus") {
+  if (item.icon === "plus") {
     actionIcon = <Plus size={16} strokeWidth={2.4} color={theme.colors.foregroundMuted} />;
-  } else if (action.icon === "settings") {
+  } else if (item.icon === "settings") {
     actionIcon = <Settings size={16} strokeWidth={2.2} color={theme.colors.foregroundMuted} />;
-  } else if (action.icon === "home") {
+  } else if (item.icon === "home") {
     actionIcon = <Home size={16} strokeWidth={2.2} color={theme.colors.foregroundMuted} />;
   }
   const titleStyle = useMemo(
@@ -142,10 +144,11 @@ function CommandCenterActionRow({
   );
   return (
     <CommandCenterRowContainer
+      item={item}
       rowIndex={rowIndex}
       active={active}
       rowRefs={rowRefs}
-      onPress={handlePress}
+      onSelect={onSelect}
       onLayout={onLayout}
     >
       <View style={styles.rowContent}>
@@ -153,59 +156,25 @@ function CommandCenterActionRow({
           {actionIcon ? <View style={styles.iconSlot}>{actionIcon}</View> : null}
           <View style={styles.textContent}>
             <Text style={titleStyle} numberOfLines={1}>
-              {action.title}
+              {item.title}
             </Text>
           </View>
         </View>
-        {action.shortcutKeys ? (
-          <Shortcut chord={action.shortcutKeys} style={styles.rowShortcut} />
+        {item.shortcutKeys ? (
+          <Shortcut chord={item.shortcutKeys} style={styles.rowShortcut} />
         ) : null}
       </View>
     </CommandCenterRowContainer>
   );
 }
 
-interface CommandCenterAgentRowProps {
-  item: Extract<ReturnType<typeof useCommandCenter>["items"][number], { kind: "agent" }>;
-  rowIndex: number;
-  active: boolean;
-  rowRefs: React.MutableRefObject<Map<number, View>>;
-  onLayout?: (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  onSelect: (item: ReturnType<typeof useCommandCenter>["items"][number]) => void;
-  children: ReactNode;
-}
-
-function CommandCenterAgentRow({
-  rowIndex,
-  active,
-  rowRefs,
-  onLayout,
-  onSelect,
-  item,
-  children,
-}: CommandCenterAgentRowProps) {
-  const handlePress = useCallback(() => onSelect(item), [onSelect, item]);
-  return (
-    <CommandCenterRowContainer
-      rowIndex={rowIndex}
-      active={active}
-      rowRefs={rowRefs}
-      onPress={handlePress}
-      onLayout={onLayout}
-    >
-      {children}
-    </CommandCenterRowContainer>
-  );
-}
-
 interface CommandCenterAgentRowContentProps {
-  agent: AggregatedAgent;
-  showHost: boolean;
+  item: CommandCenterAgentItem;
 }
 
-function CommandCenterAgentRowContent({ agent, showHost }: CommandCenterAgentRowContentProps) {
+function CommandCenterAgentRowContent({ item }: CommandCenterAgentRowContentProps) {
   const { theme } = useUnistyles();
-  const { t } = useTranslation();
+  const agent = item.agent;
   const titleStyle = useMemo(
     () => [styles.title, { color: theme.colors.foreground }],
     [theme.colors.foreground],
@@ -226,11 +195,10 @@ function CommandCenterAgentRowContent({ agent, showHost }: CommandCenterAgentRow
         </View>
         <View style={styles.textContent}>
           <Text style={titleStyle} numberOfLines={1}>
-            {agent.title || t("shell.commandCenter.newAgent")}
+            {item.title}
           </Text>
           <Text style={subtitleStyle} numberOfLines={1} testID="command-center-agent-subtitle">
-            {showHost ? `${agent.serverLabel} · ` : ""}
-            {shortenPath(agent.cwd)} · {formatTimeAgo(agent.lastActivityAt)}
+            {item.subtitle}
           </Text>
         </View>
       </View>
@@ -239,42 +207,40 @@ function CommandCenterAgentRowContent({ agent, showHost }: CommandCenterAgentRow
 }
 
 interface AgentItemsSectionProps {
-  agentItems: Extract<ReturnType<typeof useCommandCenter>["items"][number], { kind: "agent" }>[];
-  actionItemsLength: number;
+  agentItems: CommandCenterAgentItem[];
+  startIndex: number;
   activeIndex: number;
   rowRefs: React.MutableRefObject<Map<number, View>>;
   onRowLayout: (
     rowIndex: number,
   ) => (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  onSelect: (item: ReturnType<typeof useCommandCenter>["items"][number]) => void;
+  onSelect: (item: CommandCenterItem) => void;
   sectionDividerStyle: React.ComponentProps<typeof View>["style"];
   sectionLabelStyle: React.ComponentProps<typeof Text>["style"];
-  showHost: boolean;
 }
 
 function AgentItemsSection({
   agentItems,
-  actionItemsLength,
+  startIndex,
   activeIndex,
   rowRefs,
   onRowLayout,
   onSelect,
   sectionDividerStyle,
   sectionLabelStyle,
-  showHost,
 }: AgentItemsSectionProps) {
   const { t } = useTranslation();
 
   return (
     <>
-      {actionItemsLength > 0 ? <View style={sectionDividerStyle} /> : null}
+      {startIndex > 0 ? <View style={sectionDividerStyle} /> : null}
       <Text style={sectionLabelStyle}>{t("shell.commandCenter.agents")}</Text>
       {agentItems.map((item, index) => {
-        const rowIndex = actionItemsLength + index;
+        const rowIndex = startIndex + index;
         const agent = item.agent;
         return (
-          <CommandCenterAgentRow
-            key={agentKey(agent)}
+          <CommandCenterRowContainer
+            key={`${agent.serverId}:${agent.id}`}
             item={item}
             rowIndex={rowIndex}
             active={rowIndex === activeIndex}
@@ -282,8 +248,74 @@ function AgentItemsSection({
             onLayout={onRowLayout(rowIndex)}
             onSelect={onSelect}
           >
-            <CommandCenterAgentRowContent agent={agent} showHost={showHost} />
-          </CommandCenterAgentRow>
+            <CommandCenterAgentRowContent item={item} />
+          </CommandCenterRowContainer>
+        );
+      })}
+    </>
+  );
+}
+
+interface WorkspaceItemsSectionProps {
+  workspaceItems: CommandCenterWorkspaceItem[];
+  startIndex: number;
+  activeIndex: number;
+  rowRefs: React.MutableRefObject<Map<number, View>>;
+  onRowLayout: (
+    rowIndex: number,
+  ) => (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
+  onSelect: (item: CommandCenterItem) => void;
+  sectionDividerStyle: React.ComponentProps<typeof View>["style"];
+  sectionLabelStyle: React.ComponentProps<typeof Text>["style"];
+}
+
+function WorkspaceItemsSection({
+  workspaceItems,
+  startIndex,
+  activeIndex,
+  rowRefs,
+  onRowLayout,
+  onSelect,
+  sectionDividerStyle,
+  sectionLabelStyle,
+}: WorkspaceItemsSectionProps) {
+  const { t } = useTranslation();
+
+  return (
+    <>
+      {startIndex > 0 ? <View style={sectionDividerStyle} /> : null}
+      <Text style={sectionLabelStyle}>{t("shell.commandCenter.workspaces")}</Text>
+      {workspaceItems.map((item, index) => {
+        const rowIndex = startIndex + index;
+        return (
+          <CommandCenterRowContainer
+            key={`${item.serverId}:${item.workspaceId}`}
+            item={item}
+            rowIndex={rowIndex}
+            active={rowIndex === activeIndex}
+            rowRefs={rowRefs}
+            onSelect={onSelect}
+            onLayout={onRowLayout(rowIndex)}
+          >
+            <View
+              style={styles.rowContent}
+              testID={`command-center-workspace-${item.serverId}:${item.workspaceId}`}
+            >
+              <View style={styles.rowMain}>
+                <View style={styles.iconSlot}>
+                  <ThemedFolder size={16} strokeWidth={2.2} />
+                </View>
+                <View style={styles.textContent}>
+                  <Text style={styles.title} numberOfLines={1}>
+                    {item.title}
+                  </Text>
+                  <Text style={styles.subtitle} numberOfLines={1}>
+                    {item.subtitle}
+                  </Text>
+                </View>
+              </View>
+            </View>
+          </CommandCenterRowContainer>
         );
       })}
     </>
@@ -304,12 +336,8 @@ export function CommandCenter() {
     handleSelectItem,
     handleKeyEvent,
   } = useCommandCenter();
-
   const isCompact = useIsCompactFormFactor();
   const showBottomSheet = isCompact && isNative;
-  // Host names only earn their space once results can span more than one host.
-  const showHost = useHosts().length > 1;
-
   const rowRefs = useRef<Map<number, View>>(new Map());
   const rowLayouts = useRef<Map<number, { y: number; height: number }>>(new Map());
   const resultsRef = useRef<ScrollView>(null);
@@ -409,6 +437,7 @@ export function CommandCenter() {
   );
 
   const actionItems = useMemo(() => items.filter((item) => item.kind === "action"), [items]);
+  const workspaceItems = useMemo(() => items.filter((item) => item.kind === "workspace"), [items]);
   const agentItems = useMemo(() => items.filter((item) => item.kind === "agent"), [items]);
 
   const panelStyle = useMemo(
@@ -438,6 +467,14 @@ export function CommandCenter() {
     () => [styles.sectionDivider, { backgroundColor: theme.colors.border }],
     [theme.colors.border],
   );
+  const sheetBackgroundStyle = useMemo(
+    () => ({ backgroundColor: theme.colors.surface0 }),
+    [theme.colors.surface0],
+  );
+  const sheetHandleStyle = useMemo(
+    () => ({ backgroundColor: theme.colors.palette.zinc[600] }),
+    [theme.colors.palette.zinc],
+  );
 
   const handleKeyPress = useCallback(
     ({ nativeEvent: { key } }: { nativeEvent: { key: string } }) => {
@@ -462,7 +499,7 @@ export function CommandCenter() {
             <Text style={sectionLabelStyle}>{t("shell.commandCenter.actions")}</Text>
             {actionItems.map((item, index) => (
               <CommandCenterActionRow
-                key={`action:${item.action.id}`}
+                key={`action:${item.id}`}
                 item={item}
                 rowIndex={index}
                 active={index === activeIndex}
@@ -474,17 +511,29 @@ export function CommandCenter() {
           </>
         ) : null}
 
-        {agentItems.length > 0 ? (
-          <AgentItemsSection
-            agentItems={agentItems}
-            actionItemsLength={actionItems.length}
+        {workspaceItems.length > 0 ? (
+          <WorkspaceItemsSection
+            workspaceItems={workspaceItems}
+            startIndex={actionItems.length}
+            activeIndex={activeIndex}
+            rowRefs={rowRefs}
+            onRowLayout={handleRowLayout}
+            onSelect={handleSelectItem}
+            sectionDividerStyle={sectionDividerStyle}
+            sectionLabelStyle={sectionLabelStyle}
+          />
+        ) : null}
+
+        {agentItems.length > 0 ? (
+          <AgentItemsSection
+            agentItems={agentItems}
+            startIndex={actionItems.length + workspaceItems.length}
             activeIndex={activeIndex}
             rowRefs={rowRefs}
             onRowLayout={handleRowLayout}
             onSelect={handleSelectItem}
             sectionDividerStyle={sectionDividerStyle}
             sectionLabelStyle={sectionLabelStyle}
-            showHost={showHost}
           />
         ) : null}
       </>
@@ -502,6 +551,8 @@ export function CommandCenter() {
         onDismiss={handleSheetDismiss}
         backdropComponent={renderBackdrop}
         enablePanDownToClose
+        backgroundStyle={sheetBackgroundStyle}
+        handleIndicatorStyle={sheetHandleStyle}
         keyboardBehavior="extend"
         keyboardBlurBehavior="restore"
         accessible={false}
@@ -603,7 +654,7 @@ const styles = StyleSheet.create((theme) => ({
     borderBottomWidth: 1,
   },
   input: {
-    fontSize: theme.fontSize.lg,
+    fontSize: theme.fontSize.base,
     paddingVertical: theme.spacing[1],
     outlineStyle: "none",
   } as object,
@@ -657,13 +708,15 @@ const styles = StyleSheet.create((theme) => ({
     flexShrink: 0,
   },
   title: {
-    fontSize: theme.fontSize.base,
+    fontSize: theme.fontSize.sm,
     fontWeight: "400",
     lineHeight: 20,
+    color: theme.colors.foreground,
   },
   subtitle: {
-    fontSize: theme.fontSize.sm,
+    fontSize: theme.fontSize.xs,
     lineHeight: 18,
+    color: theme.colors.foregroundMuted,
   },
   emptyText: {
     paddingHorizontal: theme.spacing[4],

packages/app/src/components/desktop-sidebar-layout.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vitest";
+import {
+  canDesktopAppSidebarShare,
+  resolveDesktopAppChromeLayout,
+  resolveDesktopAppContentMinimum,
+  resolveDesktopExplorerWidth,
+  resolveDesktopSidebarWidth,
+} from "@/components/desktop-sidebar-layout";
+
+describe("desktop sidebar layout", () => {
+  it("keeps the sidebar toggle window-owned beside left window controls", () => {
+    expect(
+      resolveDesktopAppChromeLayout({
+        desktopSidebarRendered: true,
+        hasTopLeftWindowControls: true,
+        sidebarControlsEnabled: true,
+      }),
+    ).toEqual({
+      sidebarCorners: "top-left",
+      contentCorners: "top-right",
+      sidebarToggleOwner: "window",
+    });
+    expect(
+      resolveDesktopAppChromeLayout({
+        desktopSidebarRendered: true,
+        hasTopLeftWindowControls: false,
+        sidebarControlsEnabled: true,
+      }),
+    ).toEqual({
+      sidebarCorners: "none",
+      contentCorners: "both",
+      sidebarToggleOwner: "content",
+    });
+    expect(
+      resolveDesktopAppChromeLayout({
+        desktopSidebarRendered: false,
+        hasTopLeftWindowControls: true,
+        sidebarControlsEnabled: true,
+      }),
+    ).toEqual({
+      sidebarCorners: "none",
+      contentCorners: "both",
+      sidebarToggleOwner: "window",
+    });
+  });
+
+  it("hides the window-owned sidebar toggle when app chrome is suppressed", () => {
+    expect(
+      resolveDesktopAppChromeLayout({
+        desktopSidebarRendered: false,
+        hasTopLeftWindowControls: true,
+        sidebarControlsEnabled: false,
+      }).sidebarToggleOwner,
+    ).toBe("none");
+  });
+
+  it("clamps a persisted wide sidebar to preserve the center pane", () => {
+    const atHalfScreen = resolveDesktopSidebarWidth({ requestedWidth: 600, viewportWidth: 751 });
+    expect(atHalfScreen).toBe(351);
+    expect(751 - atHalfScreen).toBe(400);
+
+    const atBreakpoint = resolveDesktopSidebarWidth({ requestedWidth: 600, viewportWidth: 720 });
+    expect(atBreakpoint).toBe(320);
+    expect(720 - atBreakpoint).toBe(400);
+
+    expect(resolveDesktopSidebarWidth({ requestedWidth: 600, viewportWidth: 1440 })).toBe(600);
+  });
+
+  it("keeps a temporarily narrow explorer render-only", () => {
+    expect(resolveDesktopExplorerWidth({ requestedWidth: 400, viewportWidth: 751 })).toBe(351);
+    expect(resolveDesktopExplorerWidth({ requestedWidth: 400, viewportWidth: 1440 })).toBe(400);
+  });
+
+  it("yields app navigation when settings or Explorer need the shell width", () => {
+    const settingsMinimum = resolveDesktopAppContentMinimum({
+      isSettingsRoute: true,
+      isWorkspaceExplorerOpen: false,
+      requestedExplorerWidth: 400,
+      viewportWidth: 751,
+    });
+    expect(settingsMinimum).toBe(720);
+    expect(
+      canDesktopAppSidebarShare({
+        contentMinimumWidth: settingsMinimum,
+        requestedSidebarWidth: 320,
+        viewportWidth: 751,
+      }),
+    ).toBe(false);
+
+    const explorerMinimum = resolveDesktopAppContentMinimum({
+      isSettingsRoute: false,
+      isWorkspaceExplorerOpen: true,
+      requestedExplorerWidth: 400,
+      viewportWidth: 751,
+    });
+    expect(explorerMinimum).toBe(751);
+    expect(
+      canDesktopAppSidebarShare({
+        contentMinimumWidth: explorerMinimum,
+        requestedSidebarWidth: 320,
+        viewportWidth: 751,
+      }),
+    ).toBe(false);
+    expect(
+      canDesktopAppSidebarShare({
+        contentMinimumWidth: resolveDesktopAppContentMinimum({
+          isSettingsRoute: false,
+          isWorkspaceExplorerOpen: true,
+          requestedExplorerWidth: 400,
+          viewportWidth: 1120,
+        }),
+        requestedSidebarWidth: 320,
+        viewportWidth: 1120,
+      }),
+    ).toBe(true);
+  });
+});

packages/app/src/components/desktop-sidebar-layout.ts

@@ -0,0 +1,95 @@
+import { SETTINGS_DESKTOP_SPLIT_MIN_WIDTH } from "@/constants/layout";
+import {
+  MAX_EXPLORER_SIDEBAR_WIDTH,
+  MAX_SIDEBAR_WIDTH,
+  MIN_EXPLORER_SIDEBAR_WIDTH,
+  MIN_SIDEBAR_WIDTH,
+} from "@/stores/panel-store";
+
+export const MIN_DESKTOP_CENTER_WIDTH = 400;
+
+export function resolveDesktopAppChromeLayout(input: {
+  desktopSidebarRendered: boolean;
+  hasTopLeftWindowControls: boolean;
+  sidebarControlsEnabled: boolean;
+}) {
+  const sidebarOwnsTopLeft = input.desktopSidebarRendered && input.hasTopLeftWindowControls;
+  let sidebarToggleOwner: "none" | "window" | "content" = "none";
+  if (input.sidebarControlsEnabled) {
+    sidebarToggleOwner = input.hasTopLeftWindowControls ? "window" : "content";
+  }
+  return {
+    sidebarCorners: sidebarOwnsTopLeft ? ("top-left" as const) : ("none" as const),
+    contentCorners: sidebarOwnsTopLeft ? ("top-right" as const) : ("both" as const),
+    sidebarToggleOwner,
+  };
+}
+
+function resolveDesktopPanelWidth(input: {
+  requestedWidth: number;
+  viewportWidth: number;
+  minimumWidth: number;
+  maximumWidth: number;
+}): number {
+  "worklet";
+  const maximumVisibleWidth = Math.max(
+    input.minimumWidth,
+    Math.min(input.maximumWidth, input.viewportWidth - MIN_DESKTOP_CENTER_WIDTH),
+  );
+  return Math.max(input.minimumWidth, Math.min(maximumVisibleWidth, input.requestedWidth));
+}
+
+export function resolveDesktopSidebarWidth(input: {
+  requestedWidth: number;
+  viewportWidth: number;
+}): number {
+  "worklet";
+  return resolveDesktopPanelWidth({
+    ...input,
+    minimumWidth: MIN_SIDEBAR_WIDTH,
+    maximumWidth: MAX_SIDEBAR_WIDTH,
+  });
+}
+
+export function resolveDesktopExplorerWidth(input: {
+  requestedWidth: number;
+  viewportWidth: number;
+}): number {
+  "worklet";
+  return resolveDesktopPanelWidth({
+    ...input,
+    minimumWidth: MIN_EXPLORER_SIDEBAR_WIDTH,
+    maximumWidth: MAX_EXPLORER_SIDEBAR_WIDTH,
+  });
+}
+
+export function resolveDesktopAppContentMinimum(input: {
+  isSettingsRoute: boolean;
+  isWorkspaceExplorerOpen: boolean;
+  requestedExplorerWidth: number;
+  viewportWidth: number;
+}): number {
+  const workspaceMinimum = input.isWorkspaceExplorerOpen
+    ? MIN_DESKTOP_CENTER_WIDTH +
+      resolveDesktopExplorerWidth({
+        requestedWidth: input.requestedExplorerWidth,
+        viewportWidth: input.viewportWidth,
+      })
+    : 0;
+  return Math.max(input.isSettingsRoute ? SETTINGS_DESKTOP_SPLIT_MIN_WIDTH : 0, workspaceMinimum);
+}
+
+export function canDesktopAppSidebarShare(input: {
+  contentMinimumWidth: number;
+  requestedSidebarWidth: number;
+  viewportWidth: number;
+}): boolean {
+  return (
+    input.viewportWidth -
+      resolveDesktopSidebarWidth({
+        requestedWidth: input.requestedSidebarWidth,
+        viewportWidth: input.viewportWidth,
+      }) >=
+    input.contentMinimumWidth
+  );
+}

packages/app/src/components/diff-scroll.web.tsx

@@ -1,6 +1,5 @@
-import { useCallback, useMemo } from "react";
+import { useCallback } from "react";
 import { ScrollView, type LayoutChangeEvent, type StyleProp, type ViewStyle } from "react-native";
-import { useWebScrollbarStyle } from "@/hooks/use-web-scrollbar-style";
 
 interface DiffScrollProps {
   children: React.ReactNode;
@@ -16,8 +15,6 @@ export function DiffScroll({
   style,
   contentContainerStyle,
 }: DiffScrollProps) {
-  const webScrollbarStyle = useWebScrollbarStyle();
-  const combinedStyle = useMemo(() => [style, webScrollbarStyle], [style, webScrollbarStyle]);
   const handleLayout = useCallback(
     (e: LayoutChangeEvent) => onScrollViewWidthChange(e.nativeEvent.layout.width),
     [onScrollViewWidthChange],
@@ -28,7 +25,7 @@ export function DiffScroll({
       horizontal
       nestedScrollEnabled
       showsHorizontalScrollIndicator
-      style={combinedStyle}
+      style={style}
       contentContainerStyle={contentContainerStyle}
       onLayout={handleLayout}
     >

packages/app/src/components/diff-viewer.tsx

@@ -6,7 +6,6 @@ import { StyleSheet } from "react-native-unistyles";
 import type { DiffLine } from "@/utils/tool-call-parsers";
 import { diffLinePrefix } from "@/utils/diff-highlight";
 import { syntaxTokenStyleFor } from "@/styles/syntax-token-styles";
-import { useWebScrollbarStyle } from "@/hooks/use-web-scrollbar-style";
 import { inlineUnistylesStyle } from "@/styles/unistyles-inline-style";
 import { getCodeInsets } from "./code-insets";
 import { CODE_SURFACE_DATASET } from "@/styles/code-surface";
@@ -127,7 +126,6 @@ export function DiffViewer({
   const { t } = useTranslation();
   const [scrollViewWidth, setScrollViewWidth] = React.useState(0);
   const resolvedEmptyLabel = emptyLabel ?? t("diffViewer.empty");
-  const webScrollbarStyle = useWebScrollbarStyle();
   const handleInnerLayout = React.useCallback(
     (e: { nativeEvent: { layout: { width: number } } }) =>
       setScrollViewWidth(e.nativeEvent.layout.width),
@@ -139,9 +137,8 @@ export function DiffViewer({
       styles.verticalScroll,
       maxHeight !== undefined && inlineUnistylesStyle({ maxHeight }),
       fillAvailableHeight && styles.fillHeight,
-      webScrollbarStyle,
     ],
-    [maxHeight, fillAvailableHeight, webScrollbarStyle],
+    [maxHeight, fillAvailableHeight],
   );
   const linesContainerStyle = React.useMemo(
     () => [
@@ -180,7 +177,6 @@ export function DiffViewer({
       horizontal
       nestedScrollEnabled
       showsHorizontalScrollIndicator
-      style={webScrollbarStyle}
       contentContainerStyle={styles.horizontalContent}
       onLayout={handleInnerLayout}
     >